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