public void SetUp()
{
_model = new Model();
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
new EventStub(1).Write(writer);
}
EmbeddedEventStore.Connection.AppendToStreamAsync(
_model.KnownIdentifier,
ExpectedVersion.NoStream,
new EventData(
Guid.NewGuid(),
typeof(EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0])).Wait();
EmbeddedEventStore.Connection.AppendToStreamAsync(
_model.KnownIdentifier,
ExpectedVersion.Any,
new EventData(
Guid.NewGuid(),
typeof(EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0])).Wait();
}
_root = SnapshotableAggregateRootEntityStub.Factory();
_state = new object();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(1, _state))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(1, _state))));
_sut = new AsyncSnapshotableRepository <SnapshotableAggregateRootEntityStub>(
() => _root,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public void SetUp()
{
EmbeddedEventStore.Connection.DeleteAllStreams();
_model = new Model();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(Optional <Snapshot> .Empty));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(Optional <Snapshot> .Empty));
_sut = new AsyncSnapshotableRepository <SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
/// <summary>
/// Attempts to get the aggregate root entity associated with the aggregate identifier.
/// </summary>
/// <param name="identifier">The aggregate identifier.</param>
/// <returns>The found <typeparamref name="TAggregateRoot" />, or empty if not found.</returns>
public async Task <Optional <TAggregateRoot> > GetOptionalAsync(string identifier)
{
if (_unitOfWork.TryGet(identifier, out Aggregate aggregate))
{
return(new Optional <TAggregateRoot>((TAggregateRoot)aggregate.Root));
}
Optional <Snapshot> snapshot = await _reader.ReadOptionalAsync(identifier);
var version = StreamPosition.Start;
if (snapshot.HasValue)
{
version = snapshot.Value.Version + 1;
}
UserCredentials streamUserCredentials = _configuration.StreamUserCredentialsResolver.Resolve(identifier);
string streamName = _configuration.StreamNameResolver.Resolve(identifier);
StreamEventsSlice slice =
await
_connection.ReadStreamEventsForwardAsync(streamName, version, _configuration.SliceSize, false,
streamUserCredentials);
if (slice.Status == SliceReadStatus.StreamDeleted || slice.Status == SliceReadStatus.StreamNotFound)
{
return(Optional <TAggregateRoot> .Empty);
}
TAggregateRoot root = _rootFactory();
if (snapshot.HasValue)
{
root.RestoreSnapshot(snapshot.Value.State);
}
root.Initialize(slice.Events.Select(resolved => _configuration.Deserializer.Deserialize(resolved)));
while (!slice.IsEndOfStream)
{
slice =
await
_connection.ReadStreamEventsForwardAsync(streamName, slice.NextEventNumber, _configuration.SliceSize,
false, streamUserCredentials);
root.Initialize(slice.Events.Select(resolved => _configuration.Deserializer.Deserialize(resolved)));
}
aggregate = new Aggregate(identifier, (int)slice.LastEventNumber, root);
_unitOfWork.Attach(aggregate);
return(new Optional <TAggregateRoot>(root));
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new ConcurrentUnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_resolver = A.Fake <IStreamNameResolver>();
_reader = A.Fake <IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(100, new object()))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional <Snapshot>(new Snapshot(100, new object()))));
_sut = new AsyncSnapshotableRepository <SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public void GetAsyncReadsSnapshotOfUnknownId()
{
Catch.ExceptionOf(() => { var _ = _sut.GetAsync(_model.UnknownIdentifier).Result; });
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier)).MustHaveHappened();
}
public void SetUp()
{
EmbeddedEventStore.Instance.Connection.DeleteAllStreams();
_model = new Model();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(Optional<Snapshot>.Empty));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(Optional<Snapshot>.Empty));
_sut = new AsyncSnapshotableRepository<SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Instance.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public void SetUp()
{
_model = new Model();
using (var stream = new MemoryStream())
{
using (var writer = new BinaryWriter(stream))
{
new EventStub(1).Write(writer);
}
EmbeddedEventStore.Instance.Connection.AppendToStream(
_model.KnownIdentifier,
ExpectedVersion.NoStream,
new EventData(
Guid.NewGuid(),
typeof (EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0]));
EmbeddedEventStore.Instance.Connection.AppendToStream(
_model.KnownIdentifier,
ExpectedVersion.Any,
new EventData(
Guid.NewGuid(),
typeof (EventStub).AssemblyQualifiedName,
false,
stream.ToArray(),
new byte[0]));
}
_root = SnapshotableAggregateRootEntityStub.Factory();
_state = new object();
_unitOfWork = new ConcurrentUnitOfWork();
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(1, _state))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(1, _state))));
_sut = new AsyncSnapshotableRepository<SnapshotableAggregateRootEntityStub>(
() => _root,
_unitOfWork,
EmbeddedEventStore.Instance.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}
public async Task GetAsyncReadsSnapshotOfUnknownId()
{
await Catch.ExceptionOf(async() => { var _ = await _sut.GetAsync(_model.UnknownIdentifier); });
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier)).MustHaveHappened();
}
public async Task SetUp()
{
await EmbeddedEventStore.Connection.DeleteAllStreamsAsync();
_model = new Model();
_root = SnapshotableAggregateRootEntityStub.Factory();
_unitOfWork = new ConcurrentUnitOfWork();
_unitOfWork.Attach(new Aggregate(_model.KnownIdentifier, 0, _root));
_resolver = A.Fake<IStreamNameResolver>();
_reader = A.Fake<IAsyncSnapshotReader>();
A.CallTo(() => _resolver.Resolve(_model.KnownIdentifier)).Returns(_model.KnownIdentifier);
A.CallTo(() => _resolver.Resolve(_model.UnknownIdentifier)).Returns(_model.UnknownIdentifier);
A.CallTo(() => _reader.ReadOptionalAsync(_model.KnownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(100, new object()))));
A.CallTo(() => _reader.ReadOptionalAsync(_model.UnknownIdentifier))
.Returns(Task.FromResult(new Optional<Snapshot>(new Snapshot(100, new object()))));
_sut = new AsyncSnapshotableRepository<SnapshotableAggregateRootEntityStub>(
SnapshotableAggregateRootEntityStub.Factory,
_unitOfWork,
EmbeddedEventStore.Connection,
EventReaderConfigurationFactory.CreateWithResolver(_resolver),
_reader);
}