public async Task Should_write_batched()
{
var key1 = DomainId.NewGuid();
var key2 = DomainId.NewGuid();
var bulk = sut.WithBatchContext(None.Type);
await bulk.LoadAsync(new[] { key1, key2 });
var persistedEvents1 = Save.Events();
var persistence1 = bulk.WithEventSourcing(None.Type, key1, persistedEvents1.Write);
var persistedEvents2 = Save.Events();
var persistence2 = bulk.WithEventSourcing(None.Type, key2, persistedEvents2.Write);
await persistence1.WriteSnapshotAsync(12);
await persistence2.WriteSnapshotAsync(12);
A.CallTo(() => snapshotStore.WriteAsync(A <DomainId> ._, A <int> ._, A <long> ._, A <long> ._, A <CancellationToken> ._))
.MustNotHaveHappened();
A.CallTo(() => snapshotStore.WriteManyAsync(A <IEnumerable <(DomainId, int, long)> > ._, A <CancellationToken> ._))
.MustNotHaveHappened();
await bulk.CommitAsync();
await bulk.DisposeAsync();
A.CallTo(() => snapshotStore.WriteManyAsync(A <IEnumerable <(DomainId, int, long)> > .That.Matches(x => x.Count() == 2), A <CancellationToken> ._))
.MustHaveHappenedOnceExactly();
}
public async Task Should_write_to_store_with_previous_version()
{
InvalidateMessage message = null;
pubSub.Subscribe <InvalidateMessage>(m =>
{
message = m;
});
A.CallTo(() => snapshotStore.ReadAsync(key))
.Returns((123, 13));
var actualObject = await sut.GetSingleAsync <MyStatefulObject, string>(key);
Assert.Same(statefulObject, actualObject);
Assert.Equal(123, statefulObject.State);
statefulObject.SetState(456);
await statefulObject.WriteStateAsync();
A.CallTo(() => snapshotStore.WriteAsync(key, 456, 13, 14))
.MustHaveHappened();
Assert.NotNull(message);
Assert.Equal(key, message.Key);
}
public void Should_configure_new_keys()
{
A.CallTo(() => store.ReadAsync(A <DomainId> ._, default))
.Returns((null !, true, 0));
var options = new OpenIddictServerOptions();
sut.Configure(options);
Assert.NotEmpty(options.SigningCredentials);
Assert.NotEmpty(options.EncryptionCredentials);
A.CallTo(() => store.WriteAsync(A <DomainId> ._, A <DefaultKeyStore.State> ._, 0, 0, default))
.MustHaveHappenedOnceExactly();
}
public async Task WriteSnapshotAsync(TState state)
{
try
{
var newVersion = UseEventSourcing() ? versionEvents : versionSnapshot + 1;
if (newVersion != versionSnapshot)
{
try
{
await snapshotStore.WriteAsync(ownerKey, state, versionSnapshot, newVersion);
}
catch (InconsistentStateException ex)
{
throw new DomainObjectVersionException(ownerKey.ToString(), typeof(TOwner), ex.CurrentVersion, ex.ExpectedVersion);
}
versionSnapshot = newVersion;
}
UpdateVersion();
invalidate?.Invoke();
}
catch
{
failed?.Invoke();
throw;
}
}
public void Should_write_new_item_to_store_with_friendly_name()
{
sut.StoreElement(new XElement("a"), "friendly-name");
A.CallTo(() => store.WriteAsync("friendly-name", A <DefaultXmlRepository.State> .That.Matches(x => x.Xml == "<a />"), EtagVersion.Any, EtagVersion.Any))
.MustHaveHappened();
}
public async Task Should_write_to_store_with_previous_version()
{
A.CallTo(() => snapshotStore.ReadAsync(key))
.Returns((123, 13));
var actualObject = await sut.GetSingleAsync <MyStatefulObject, string>(key);
Assert.Same(statefulObject, actualObject);
Assert.Equal(123, statefulObject.State);
statefulObject.SetState(456);
await statefulObject.WriteStateAsync();
A.CallTo(() => snapshotStore.WriteAsync(key, 456, 13, 14))
.MustHaveHappened();
}
public async Task Should_generate_signing_credentials_once()
{
A.CallTo(() => store.ReadAsync(A <Guid> ._))
.Returns((null !, 0));
var credentials1 = await sut.GetSigningCredentialsAsync();
var credentials2 = await sut.GetSigningCredentialsAsync();
Assert.Same(credentials1, credentials2);
A.CallTo(() => store.ReadAsync(A <Guid> ._))
.MustHaveHappenedOnceExactly();
A.CallTo(() => store.WriteAsync(A <Guid> ._, A <DefaultKeyStore.State> ._, 0, 0))
.MustHaveHappenedOnceExactly();
}
public async Task Should_write_to_store_with_previous_version()
{
A.CallTo(() => snapshotStore.ReadAsync(key))
.Returns((20, true, 10));
var persistedState = Save.Snapshot(0);
var persistence = sut.WithSnapshots(None.Type, key, persistedState.Write);
await persistence.ReadAsync();
Assert.Equal(10, persistence.Version);
Assert.Equal(20, persistedState.Value);
await persistence.WriteSnapshotAsync(100);
A.CallTo(() => snapshotStore.WriteAsync(key, 100, 10, 11))
.MustHaveHappened();
}
public async Task Should_write_to_store_with_previous_version()
{
A.CallTo(() => snapshotStore.ReadAsync(key))
.Returns((20, 10));
var persistedState = 0;
var persistence = sut.WithSnapshots <object, int, string>(key, x => persistedState = x);
await persistence.ReadAsync();
Assert.Equal(10, persistence.Version);
Assert.Equal(20, persistedState);
await persistence.WriteSnapshotAsync(100);
A.CallTo(() => snapshotStore.WriteAsync(key, 100, 10, 11))
.MustHaveHappened();
}
public void Should_write_to_store()
{
var xml = new XElement("xml");
sut.StoreElement(xml, "name");
A.CallTo(() => store.WriteAsync("name", A <DefaultXmlRepository.State> ._, A <long> ._, 0))
.MustHaveHappened();
}
public async Task Should_write_state_and_events_when_created()
{
await SetupEmptyAsync();
var result = await sut.ExecuteAsync(new CreateAuto { Value = 4 });
A.CallTo(() => snapshotStore.WriteAsync(id, A <MyDomainState> .That.Matches(x => x.Value == 4), -1, 0))
.MustHaveHappened();
A.CallTo(() => persistence.WriteEventsAsync(A <IEnumerable <Envelope <IEvent> > > .That.Matches(x => x.Count() == 1)))
.MustHaveHappened();
Assert.True(result is EntityCreatedResult <Guid>);
Assert.Empty(sut.GetUncomittedEvents());
Assert.Equal(4, sut.Snapshot.Value);
Assert.Equal(0, sut.Snapshot.Version);
}
public Task UpdateAsync()
{
return(stateForAssets.ReadAllAsync(async(state, version) =>
{
state.Slug = state.FileName.ToAssetSlug();
await stateForAssets.WriteAsync(state.Id, state, version, version);
}));
}
public Task UpdateAsync()
{
return(stateForAssets.ReadAllAsync(async(state, version) =>
{
state.Slug = state.FileName.ToAssetSlug();
var key = DomainId.Combine(state.AppId.Id, state.Id).ToString();
await stateForAssets.WriteAsync(key, state, version, version);
}));
}
public async Task Should_write_events_to_store()
{
SetupEventStore(3);
var persistedEvents = Save.Events();
var persistence = sut.WithEventSourcing(None.Type, key, persistedEvents.Write);
await persistence.ReadAsync();
await persistence.WriteEventAsync(Envelope.Create(new MyEvent()));
await persistence.WriteEventAsync(Envelope.Create(new MyEvent()));
A.CallTo(() => eventStore.AppendAsync(A <Guid> ._, key, 2, A <ICollection <EventData> > .That.Matches(x => x.Count == 1)))
.MustHaveHappened();
A.CallTo(() => eventStore.AppendAsync(A <Guid> ._, key, 3, A <ICollection <EventData> > .That.Matches(x => x.Count == 1)))
.MustHaveHappened();
A.CallTo(() => snapshotStore.WriteAsync(A <string> ._, A <int> ._, A <long> ._, A <long> ._))
.MustNotHaveHappened();
}
public async Task UpdateAsync(
CancellationToken ct)
{
await foreach (var(state, version) in stateForAssets.ReadAllAsync(ct))
{
state.Slug = state.FileName.ToAssetSlug();
var key = DomainId.Combine(state.AppId.Id, state.Id);
await stateForAssets.WriteAsync(key, state, version, version, ct);
}
}
public async Task WriteSnapshotAsync(TSnapshot state)
{
var newVersion = UseEventSourcing() ? versionEvents : versionSnapshot + 1;
if (newVersion != versionSnapshot)
{
await snapshotStore.WriteAsync(ownerKey, state, versionSnapshot, newVersion);
versionSnapshot = newVersion;
}
UpdateVersion();
}
public async Task WriteSnapshotAsync(TSnapshot state)
{
var newVersion = UseEventSourcing() ? versionEvents : versionSnapshot + 1;
if (newVersion != versionSnapshot)
{
try
{
await snapshotStore.WriteAsync(ownerKey, state, versionSnapshot, newVersion);
}
catch (InconsistentStateException ex)
{
throw new DomainObjectVersionException(ownerKey.ToString(), ownerType, ex.CurrentVersion, ex.ExpectedVersion);
}
versionSnapshot = newVersion;
}
UpdateVersion();
}
public void StoreElement(XElement element, string friendlyName)
{
store.WriteAsync(friendlyName, new State {
Xml = element.ToString()
}, EtagVersion.Any, EtagVersion.Any).Wait();
}
public void StoreElement(XElement element, string friendlyName)
{
var state = new State(element);
store.WriteAsync(friendlyName, state, EtagVersion.Any, 0);
}