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); }