public async Task When_occur_error_on_publishing_Then_rollback_should_be_called()
{
var snapshotStrategy = CreateSnapshotStrategy(false);
_eventPublisherMock.Setup(e => e.PublishAsync(It.IsAny <IDomainEvent>()))
.Callback(DoThrowExcetion)
.Returns(Task.CompletedTask);
_eventPublisherMock.Setup(e => e.PublishAsync(It.IsAny <IEnumerable <IDomainEvent> >()))
.Callback(DoThrowExcetion)
.Returns(Task.CompletedTask);
var eventStoreMock = new Mock <IEventStore>();
eventStoreMock.SetupAllProperties();
var session = _sessionFactory(eventStoreMock.Object, _eventPublisherMock.Object, snapshotStrategy);
await session.AddAsync(StubAggregate.Create("Test"));
try
{
await session.SaveChangesAsync();
}
catch (Exception)
{
eventStoreMock.Verify(e => e.Rollback(), Times.Once);
_eventPublisherMock.Verify(e => e.Rollback(), Times.Once);
}
}
public async Task Should_throws_exception_When_aggregate_version_is_wrong()
{
var stores = new InMemoryStores();
// create first session instance
var session = _sessionFactory(stores, stores.EventStore, stores.SnapshotStore, _eventPublisherMock.Object, null, null);
var stubAggregate1 = StubAggregate.Create("Walter White");
await session.AddAsync(stubAggregate1).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
stubAggregate1.ChangeName("Going to Version 2. Expected Version 1.");
// create second session instance to getting clear tracking
session = _sessionFactory(stores, stores.EventStore, stores.SnapshotStore, _eventPublisherMock.Object, null, null);
var stubAggregate2 = await session.GetByIdAsync <StubAggregate>(stubAggregate1.Id).ConfigureAwait(false);
stubAggregate2.ChangeName("Going to Version 2");
await session.AddAsync(stubAggregate2).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
Func <Task> wrongVersion = async() => await session.AddAsync(stubAggregate1);
wrongVersion.ShouldThrowExactly <ExpectedVersionException <StubAggregate> >().And.Aggregate.Should().Be(stubAggregate1);
}
public async Task When_occur_error_on_Save_in_EventStore_Then_rollback_should_be_called()
{
var snapshotStrategy = CreateSnapshotStrategy(false);
var transactionMock = new Mock <ITransaction>();
transactionMock.SetupAllProperties();
var eventStoreMock = new Mock <IEventStore>();
eventStoreMock.SetupAllProperties();
eventStoreMock.Setup(e => e.AppendAsync(It.IsAny <IEnumerable <IUncommittedEvent> >()))
.Callback(DoThrowExcetion)
.Returns(Task.CompletedTask);
var snapshotStoreMock = new Mock <ISnapshotStore>();
var session = _sessionFactory(transactionMock.Object, eventStoreMock.Object, snapshotStoreMock.Object, _eventPublisherMock.Object, snapshotStrategy, null);
await session.AddAsync(StubAggregate.Create("Test")).ConfigureAwait(false);
try
{
await session.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception)
{
transactionMock.Verify(e => e.Rollback(), Times.Once);
_eventPublisherMock.Verify(e => e.Rollback(), Times.Once);
}
}
public async Task When_Save_events_Then_aggregate_projection_should_be_updated()
{
var snapshotStrategy = CreateSnapshotStrategy(false);
var eventStore = new StubEventStore();
var session = _sessionFactory(eventStore, _eventPublisherMock.Object, snapshotStrategy, null);
var stubAggregate1 = StubAggregate.Create("Walter White");
await session.AddAsync(stubAggregate1).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
stubAggregate1 = await session.GetByIdAsync <StubAggregate>(stubAggregate1.Id).ConfigureAwait(false);
stubAggregate1.ChangeName("Jesse Pinkman");
await session.SaveChangesAsync().ConfigureAwait(false);
eventStore.Projections.Count.Should().Be(1);
var projectionKey = new InMemoryEventStore.ProjectionKey(stubAggregate1.Id, typeof(StubAggregateProjection).Name);
eventStore.Projections.ContainsKey(projectionKey).Should().BeTrue();
var projection = _textSerializer.Deserialize <StubAggregateProjection>(eventStore.Projections[projectionKey].ToString());
projection.Id.Should().Be(stubAggregate1.Id);
projection.Name.Should().Be(stubAggregate1.Name);
}
public async Task Should_internal_rollback_When_exception_was_throw_on_saving()
{
var snapshotStrategy = CreateSnapshotStrategy(false);
var transactionMock = new Mock <ITransaction>();
var eventStoreMock = new Mock <IEventStore>();
eventStoreMock.Setup(e => e.AppendAsync(It.IsAny <IEnumerable <IUncommittedEvent> >()))
.Callback(DoThrowExcetion)
.Returns(Task.CompletedTask);
var snapshotStoreMock = new Mock <ISnapshotStore>();
var session = _sessionFactory(transactionMock.Object, eventStoreMock.Object, snapshotStoreMock.Object, _eventPublisherMock.Object, snapshotStrategy, null);
var stubAggregate = StubAggregate.Create("Guilty");
await session.AddAsync(stubAggregate).ConfigureAwait(false);
try
{
await session.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception)
{
transactionMock.Verify(e => e.Rollback(), Times.Once);
_eventPublisherMock.Verify(e => e.Rollback(), Times.Once);
}
}
public void Stream_MetadataProvider()
{
var stubStream = StubAggregate.Create("Test");
var metadataProvider = new StreamTypeMetadataProvider();
var metadata = stubStream.UncommitedEvents.SelectMany(e => metadataProvider.Provide(stubStream, e.OriginalEvent, EventSource.Metadata.Empty));
metadata.Count().Should().Be(3);
}
public void Should_take_event_name_based_on_attribute()
{
var stubAggregate = StubAggregate.Create("Test");
var metadataProvider = new EventTypeMetadataProvider();
var metadatas = stubAggregate.UncommitedEvents.SelectMany(e => metadataProvider.Provide(stubAggregate, e, EventSource.Metadata.Empty));
var metadata = new EventSource.Metadata(metadatas);
metadata.GetValue(MetadataKeys.EventName).Should().Be("StubCreated");
}
public void Aggregate_MetadataProvider()
{
var stubAggregate = StubAggregate.Create("Test");
var metadataProvider = new AggregateTypeMetadataProvider();
var metadata = stubAggregate.UncommitedEvents.SelectMany(e => metadataProvider.Provide(stubAggregate, e, EventSource.Metadata.Empty));
metadata.Count().Should().Be(3);
}
public void Event_MetadataProvider()
{
var stubAggregate = StubAggregate.Create("Test");
var metadataProvider = new EventTypeMetadataProvider();
var metadata = stubAggregate.UncommittedEvents.SelectMany(e => metadataProvider.Provide(stubAggregate, e.Data, MetadataCollection.Empty));
metadata.Count().Should().Be(2);
}
public async Task When_Save_Then_the_uncommited_events_should_be_published()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
_repository.Add(testAggregate);
await _session.CommitAsync();
_mockEventPublisher.Verify(e => e.EnqueueAsync(It.IsAny <IEnumerable <IDomainEvent> >()));
}
public async Task When_Save_Then_the_uncommited_events_should_be_published()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
await _repository.AddAsync(testAggregate).ConfigureAwait(false);
await _unitOfWork.CommitAsync().ConfigureAwait(false);
_mockEventPublisher.Verify(e => e.PublishAsync(It.IsAny <IEnumerable <IDomainEvent> >()));
}
public async Task When_load_stream_should_be_correct_version()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
_repository.Add(testAggregate);
await _session.CommitAsync();
var testAggregate2 = await _repository.GetByIdAsync <StubAggregate>(testAggregate.AggregateId);
testAggregate.Version.Should().Be(testAggregate2.Version);
}
public void CorrelationId_MetadataProvider()
{
var stubAggregate = StubAggregate.Create("Test");
stubAggregate.ChangeName("Test 1");
stubAggregate.ChangeName("Test 2");
var metadataProvider = new CorrelationIdMetadataProvider();
var metadatas = stubAggregate.UncommitedEvents.SelectMany(e => metadataProvider.Provide(stubAggregate, e, EventSource.Metadata.Empty));
metadatas.Select(e => e.Value).Distinct().Count().Should().Be(1);
}
public async Task When_load_aggregate_should_be_correct_version()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
await _repository.AddAsync(testAggregate).ConfigureAwait(false);
await _unitOfWork.CommitAsync().ConfigureAwait(false);
var testAggregate2 = await _repository.GetByIdAsync <StubAggregate>(testAggregate.Id).ConfigureAwait(false);
testAggregate.Version.Should().Be(testAggregate2.Version);
}
public async Task When_calling_Save_it_will_add_the_domain_events_to_the_domain_event_storage()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
_repository.Add(testAggregate);
await _session.CommitAsync();
var events = await _inMemoryDomainEventStore.GetEventsByAggregateId(testAggregate.AggregateId);
events.Count().Should().Be(2);
}
public async Task When_calling_Save_it_will_add_the_domain_events_to_the_domain_event_storage()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
await _repository.AddAsync(testAggregate).ConfigureAwait(false);
await _unitOfWork.CommitAsync().ConfigureAwait(false);
var events = await _inMemoryDomainEventStore.GetAllEventsAsync(testAggregate.Id);
events.Count().Should().Be(2);
}
public async Task Aggregate_stream_is_loaded_into_subAggregate()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
_repository.Add(testAggregate);
await _session.CommitAsync();
var testSubAggregate = await _repository.GetByIdAsync <StubSubAggregate>(testAggregate.AggregateId);
testSubAggregate.Version.Should().Be(testAggregate.Version);
testSubAggregate.Name.Should().Be(testAggregate.Name);
}
public async Task Should_not_retrieve_the_aggregate_from_tracking_after_commit()
{
var eventStore = new InMemoryEventStore();
var session = _sessionFactory(eventStore, _eventPublisherMock.Object);
var stubAggregate1 = StubAggregate.Create("Walter White");
session.Add(stubAggregate1);
await session.CommitAsync();
var stubAggregate2 = await session.GetByIdAsync <StubAggregate>(stubAggregate1.AggregateId);
stubAggregate1.Should().NotBeSameAs(stubAggregate2);
}
public async Task Should_publish_in_correct_order()
{
var events = new List <IDomainEvent>();
var stores = new InMemoryStores();
_eventPublisherMock.Setup(e => e.PublishAsync(It.IsAny <IEnumerable <IDomainEvent> >())).Callback <IEnumerable <IDomainEvent> >(evts => events.AddRange(evts)).Returns(Task.CompletedTask);
_eventPublisherMock.Setup(e => e.CommitAsync()).Returns(Task.CompletedTask);
var session = _sessionFactory(stores, stores.EventStore, stores.SnapshotStore, _eventPublisherMock.Object, null, null);
var stubAggregate1 = StubAggregate.Create("Walter White");
var stubAggregate2 = StubAggregate.Create("Heinsenberg");
stubAggregate1.ChangeName("Saul Goodman");
stubAggregate2.Relationship(stubAggregate1.Id);
stubAggregate1.ChangeName("Jesse Pinkman");
await session.AddAsync(stubAggregate1).ConfigureAwait(false);
await session.AddAsync(stubAggregate2).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
events[0].Should().BeOfType <Event <StubAggregateCreatedEvent> >().Which.InnerEvent.AggregateId.Should().Be(stubAggregate1.Id);
events[0].Should().BeOfType <Event <StubAggregateCreatedEvent> >().Which.InnerEvent.Name.Should().Be("Walter White");
events[1].Should().BeOfType <Event <StubAggregateCreatedEvent> >().Which.InnerEvent.AggregateId.Should().Be(stubAggregate2.Id);
events[1].Should().BeOfType <Event <StubAggregateCreatedEvent> >().Which.InnerEvent.Name.Should().Be("Heinsenberg");
events[2].Should().BeOfType <Event <NameChangedEvent> >().Which.InnerEvent.AggregateId.Should().Be(stubAggregate1.Id);
events[2].Should().BeOfType <Event <NameChangedEvent> >().Which.InnerEvent.Name.Should().Be("Saul Goodman");
events[3].Should().BeOfType <Event <StubAggregateRelatedEvent> >().Which.InnerEvent.AggregateId.Should().Be(stubAggregate2.Id);
events[3].Should().BeOfType <Event <StubAggregateRelatedEvent> >().Which.InnerEvent.StubAggregateId.Should().Be(stubAggregate1.Id);
events[4].Should().BeOfType <Event <NameChangedEvent> >().Which.InnerEvent.AggregateId.Should().Be(stubAggregate1.Id);
events[4].Should().BeOfType <Event <NameChangedEvent> >().Which.InnerEvent.Name.Should().Be("Jesse Pinkman");
}
public async Task Should_retrieve_the_aggregate_from_tracking()
{
var stores = new InMemoryStores();
var session = _sessionFactory(stores, stores.EventStore, stores.SnapshotStore, _eventPublisherMock.Object, null, null);
var stubAggregate1 = StubAggregate.Create("Walter White");
await session.AddAsync(stubAggregate1).ConfigureAwait(false);
await session.SaveChangesAsync().ConfigureAwait(false);
stubAggregate1.ChangeName("Changes");
var stubAggregate2 = await session.GetByIdAsync <StubAggregate>(stubAggregate1.Id).ConfigureAwait(false);
stubAggregate2.ChangeName("More changes");
stubAggregate1.Should().BeSameAs(stubAggregate2);
}
public async Task Should_not_throw_exception_when_different_representations_of_same_stream_do_not_have_changes()
{
var eventStore = new InMemoryEventStore();
// create first session instance
var session = _sessionFactory(eventStore, _eventPublisherMock.Object);
var stubAggregate1 = StubAggregate.Create("Walter White");
session.Add(stubAggregate1);
await session.CommitAsync();
stubAggregate1 = await session.GetByIdAsync <StubAggregate>(stubAggregate1.AggregateId);
await session.GetByIdAsync <StubSubAggregate>(stubAggregate1.AggregateId);
stubAggregate1.ChangeName("Heisenberg");
await session.CommitAsync();
}
public async Task SubAggregate_updates_are_reflected_in_aggregate()
{
var testAggregate = StubAggregate.Create("Walter White");
testAggregate.ChangeName("Heinsenberg");
_repository.Add(testAggregate);
await _session.CommitAsync();
var testSubAggregate = await _repository.GetByIdAsync <StubSubAggregate>(testAggregate.AggregateId);
testSubAggregate.ChangeName("Schrodinger");
_repository.Add(testSubAggregate);
await _session.CommitAsync();
testAggregate = await _repository.GetByIdAsync <StubAggregate>(testAggregate.AggregateId);
testAggregate.Name.Should().Be("Schrodinger");
}
public async Task Should_publish_in_correct_order()
{
var events = new List <IDomainEvent>();
var eventStore = new InMemoryEventStore();
_eventPublisherMock.Setup(e => e.EnqueueAsync(It.IsAny <IEnumerable <IDomainEvent> >())).Callback <IEnumerable <IDomainEvent> >(evts => events.AddRange(evts)).Returns(Task.CompletedTask);
_eventPublisherMock.Setup(e => e.CommitAsync()).Returns(Task.CompletedTask);
var session = _sessionFactory(eventStore, _eventPublisherMock.Object);
var stubAggregate1 = StubAggregate.Create("Walter White");
var stubAggregate2 = StubAggregate.Create("Heinsenberg");
stubAggregate1.ChangeName("Saul Goodman");
stubAggregate2.Relationship(stubAggregate1.AggregateId);
stubAggregate1.ChangeName("Jesse Pinkman");
session.Add(stubAggregate1);
session.Add(stubAggregate2);
await session.CommitAsync();
events[0].Should().BeOfType <StubAggregateCreatedEvent>().Which.AggregateId.Should().Be(stubAggregate1.AggregateId);
events[0].Should().BeOfType <StubAggregateCreatedEvent>().Which.Name.Should().Be("Walter White");
events[1].Should().BeOfType <StubAggregateCreatedEvent>().Which.AggregateId.Should().Be(stubAggregate2.AggregateId);
events[1].Should().BeOfType <StubAggregateCreatedEvent>().Which.Name.Should().Be("Heinsenberg");
events[2].Should().BeOfType <NameChangedEvent>().Which.AggregateId.Should().Be(stubAggregate1.AggregateId);
events[2].Should().BeOfType <NameChangedEvent>().Which.Name.Should().Be("Saul Goodman");
events[3].Should().BeOfType <StubAggregateRelatedEvent>().Which.AggregateId.Should().Be(stubAggregate2.AggregateId);
events[3].Should().BeOfType <StubAggregateRelatedEvent>().Which.StubAggregateId.Should().Be(stubAggregate1.AggregateId);
events[4].Should().BeOfType <NameChangedEvent>().Which.AggregateId.Should().Be(stubAggregate1.AggregateId);
events[4].Should().BeOfType <NameChangedEvent>().Which.Name.Should().Be("Jesse Pinkman");
}
public async Task When_occur_error_on_Save_in_EventStore_Then_rollback_should_be_called()
{
var eventStoreMock = new Mock <IEventStore>();
eventStoreMock.SetupAllProperties();
eventStoreMock.Setup(e => e.SaveAsync(It.IsAny <IEnumerable <ISerializedEvent> >()))
.Callback(DoThrowExcetion)
.Returns(Task.CompletedTask);
var session = _sessionFactory(eventStoreMock.Object, _eventPublisherMock.Object);
session.Add(StubAggregate.Create("Test"));
try
{
await session.CommitAsync();
}
catch (Exception)
{
eventStoreMock.Verify(e => e.Rollback(), Times.Once);
_eventPublisherMock.Verify(e => e.Rollback(), Times.Once);
}
}
public async Task Should_internal_rollback_When_exception_was_throw_on_saving()
{
var eventStoreMock = new Mock <IEventStore>();
eventStoreMock.Setup(e => e.SaveAsync(It.IsAny <IEnumerable <ISerializedEvent> >()))
.Callback(DoThrowExcetion)
.Returns(Task.CompletedTask);
var session = _sessionFactory(eventStoreMock.Object, _eventPublisherMock.Object);
var stubAggregate = StubAggregate.Create("Guilty");
session.Add(stubAggregate);
try
{
await session.CommitAsync();
}
catch (Exception)
{
eventStoreMock.Verify(e => e.Rollback(), Times.Once);
_eventPublisherMock.Verify(e => e.Rollback(), Times.Once);
}
}
