public void NoEventsExecutedIfNoAppliedEventsExist() { TestAggregateRoot aggregateRoot = new TestAggregateRoot(Guid.NewGuid()); sut.ApplyChangesAsync(aggregateRoot).Wait(); Assert.AreEqual(0, sut.EventBroker.ExecutedEvents.Count); }
public void ResolvedUnitOfWorkEventHandlersAreExecutedInCorrectOrder() { TestAggregateRoot aggregateRoot = new TestAggregateRoot(Guid.NewGuid()); aggregateRoot.ApplyEvent(domainEvent); sut.ApplyChanges(aggregateRoot); unitOfWorkDomainEventHandler1.Received().Execute(domainEvent, unitOfWork); unitOfWorkDomainEventHandler2.Received().Execute(domainEvent, unitOfWork); }
public void AllAppliedEventsAreExecuted() { TestAggregateRoot aggregateRoot = new TestAggregateRoot(Guid.NewGuid()); var domainEvent1 = ApplyNewEvent(aggregateRoot); var domainEvent2 = ApplyNewEvent(aggregateRoot); sut.ApplyChangesAsync(aggregateRoot).Wait(); Assert.AreEqual(2, sut.EventBroker.ExecutedEvents.Count); Assert.IsTrue(sut.EventBroker.ExecutedEvents.Contains(domainEvent1)); Assert.IsTrue(sut.EventBroker.ExecutedEvents.Contains(domainEvent2)); }
public void ResolvedEventHandlersAreExecutedInCorrectOrder() { TestAggregateRoot aggregateRoot = new TestAggregateRoot(Guid.NewGuid()); aggregateRoot.ApplyEvent(domainEvent); sut.ApplyChangesAsync(aggregateRoot).Wait(); Received.InOrder(() => { domainEventHandler1.ExecuteAsync(domainEvent); domainEventHandler2.ExecuteAsync(domainEvent); }); }
public void AllAppliedEventsForAllAggregateRootsAreExecuted() { TestAggregateRoot aggregateRoot1 = new TestAggregateRoot(Guid.NewGuid()); var domainEvent1 = ApplyNewEvent(aggregateRoot1); var domainEvent2 = ApplyNewEvent(aggregateRoot1); TestAggregateRoot aggregateRoot2 = new TestAggregateRoot(Guid.NewGuid()); var domainEvent3 = ApplyNewEvent(aggregateRoot2); var domainEvent4 = ApplyNewEvent(aggregateRoot2); sut.ApplyChangesAsync(new List<TestAggregateRoot> { aggregateRoot1, aggregateRoot2 }).Wait(); Assert.AreEqual(4, sut.EventBroker.ExecutedEvents.Count); Assert.IsTrue(sut.EventBroker.ExecutedEvents.Contains(domainEvent1)); Assert.IsTrue(sut.EventBroker.ExecutedEvents.Contains(domainEvent2)); Assert.IsTrue(sut.EventBroker.ExecutedEvents.Contains(domainEvent3)); Assert.IsTrue(sut.EventBroker.ExecutedEvents.Contains(domainEvent4)); }
public void OnlyUnitOfWorkEventsAreHandledIfCommitFails() { TestAggregateRoot aggregateRoot = new TestAggregateRoot(Guid.NewGuid()); aggregateRoot.ApplyEvent(domainEvent); unitOfWork .When(u => u.SaveChanges()) .Do(callInfo => { throw new InvalidOperationException(); }); try { sut.ApplyChanges(aggregateRoot); Assert.Fail("No exception thrown."); } catch (InvalidOperationException) { } unitOfWorkDomainEventHandler1.Received().Execute(domainEvent, unitOfWork); unitOfWorkDomainEventHandler2.Received().Execute(domainEvent, unitOfWork); unitOfWork.Received().SaveChanges(); domainEventHandler3.DidNotReceive().Execute(domainEvent); domainEventHandler4.DidNotReceive().Execute(domainEvent); }
public void MultipleChangesInUnitOfWorkAreSavedOnce() { TestAggregateRoot aggregateRoot1 = new TestAggregateRoot(Guid.NewGuid()); aggregateRoot1.ApplyEvent(domainEvent); TestDomainEvent domainEvent2 = new TestDomainEvent(Guid.NewGuid()); unitOfWorkEventHandlerResolver.ResolveEventHandlers<IUnitOfWorkDomainEventHandler<TestDomainEvent, TestUnitOfWork>>().Returns(unitOfWorkDomainEventHandlers); TestAggregateRoot aggregateRoot2 = new TestAggregateRoot(Guid.NewGuid()); aggregateRoot2.ApplyEvent(domainEvent2); sut.ApplyChanges(new List<TestAggregateRoot> { aggregateRoot1, aggregateRoot2 }); Received.InOrder(() => { unitOfWorkDomainEventHandler1.Execute(domainEvent, unitOfWork); unitOfWorkDomainEventHandler1.Execute(domainEvent2, unitOfWork); unitOfWork.SaveChanges(); }); }
public void ChangesInUnitOfWorkAreSaved() { TestAggregateRoot aggregateRoot = new TestAggregateRoot(Guid.NewGuid()); aggregateRoot.ApplyEvent(domainEvent); sut.ApplyChanges(aggregateRoot); unitOfWork.Received().SaveChanges(); }
public void VersionIsSet() { sut = new TestAggregateRoot(id, 10); Assert.AreEqual(10, sut.Version); }
public void IdCannotBeDefaultEmpty() { sut = new TestAggregateRoot(Guid.Empty); }
public void Setup() { id = Guid.NewGuid(); sut = new TestAggregateRoot(id); }
public void OnlyUnitOfWorkEventsAreHandledIfCommitFails() { TestAggregateRoot aggregateRoot = new TestAggregateRoot(Guid.NewGuid()); aggregateRoot.ApplyEvent(domainEvent); unitOfWork .When(u => u.SaveChanges()) .Do(callInfo => { throw new InvalidOperationException(); }); try { sut.ApplyChangesAsync(aggregateRoot).Wait(); Assert.Fail("No exception thrown."); } catch (AggregateException e) { if (e.InnerException == null) { Assert.Fail("Expected inner exception of type AggregateException. No inner exception received."); } if (!(e.InnerException is InvalidOperationException)) { Assert.Fail("Expected inner exception of type AggregateException. Received '{0}'.", e.InnerException); } } unitOfWorkDomainEventHandler1.Received().ExecuteAsync(domainEvent, unitOfWork); unitOfWorkDomainEventHandler2.Received().ExecuteAsync(domainEvent, unitOfWork); unitOfWork.Received().SaveChanges(); domainEventHandler3.DidNotReceive().ExecuteAsync(domainEvent); domainEventHandler4.DidNotReceive().ExecuteAsync(domainEvent); }
private DomainEvent ApplyNewEvent(TestAggregateRoot aggregateRoot) { var domainEvent = new TestDomainEvent(Guid.NewGuid()); aggregateRoot.ApplyEvent(domainEvent); return domainEvent; }