private DomainEvent ApplyNewEvent(TestAggregateRoot aggregateRoot) { var domainEvent = new TestDomainEvent(Guid.NewGuid()); aggregateRoot.ApplyEvent(domainEvent); return(domainEvent); }
public void Setup() { unitOfWorkDomainEventHandler1 = Substitute.For <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> >(); unitOfWorkDomainEventHandler2 = Substitute.For <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> >(); unitOfWorkDomainEventHandlers = new List <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> > { unitOfWorkDomainEventHandler1, unitOfWorkDomainEventHandler2 }; domainEventHandler3 = Substitute.For <IDomainEventHandler <TestDomainEvent> >(); domainEventHandler4 = Substitute.For <IDomainEventHandler <TestDomainEvent> >(); domainEventHandlers = new List <IDomainEventHandler <TestDomainEvent> > { domainEventHandler3, domainEventHandler4 }; eventHandlerResolver = Substitute.For <IDomainEventHandlerResolver>(); unitOfWorkEventHandlerResolver = Substitute.For <IUnitOfWorkDomainEventHandlerResolver>(); unitOfWork = Substitute.For <TestUnitOfWork>(); domainEvent = new TestDomainEvent(Guid.NewGuid()); unitOfWorkEventHandlerResolver.ResolveEventHandlers <IUnitOfWorkDomainEventHandler <TestDomainEvent, TestUnitOfWork> >().Returns(unitOfWorkDomainEventHandlers); eventHandlerResolver.ResolveEventHandlers <IDomainEventHandler <TestDomainEvent> >().Returns(domainEventHandlers); sut = new TestUnitOfWorkDomainRepository(eventHandlerResolver, unitOfWorkEventHandlerResolver, unitOfWork); }
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 async Task Send_SendsMessageToServiceBus() { var id = Guid.NewGuid(); var serializer = new JsonMessageSerializer(); var encoder = new Utf8Encoder(); var messenger = new ServiceBusDomainMessenger( new [] { new GlobalUserPropertyStrategy("Id") }, serializer, encoder, _fixture.Sender); var client = _fixture.CreateClient(id); TestDomainEvent domainEvent = null; client.RegisterMessageHandler((msg, token) => { var json = System.Text.Encoding.UTF8.GetString(msg.Body); domainEvent = serializer.DeserializeObject <TestDomainEvent>(json); return(Task.CompletedTask); }, new MessageHandlerOptions(args => Task.CompletedTask) { MaxConcurrentCalls = 1, AutoComplete = false }); await messenger.SendAsync(new TestDomainEvent(id)); while (domainEvent?.Id != id) { Thread.Sleep(2000); } domainEvent.Id.Should().Be(id); }
protected override void When() { TestCorrelationId = Guid.NewGuid(); var msg = new TestDomainEvent(TestCorrelationId, Guid.Empty); TestMessageId = msg.MsgId; Bus.Publish(msg); var msg2 = new ParentTestDomainEvent(TestCorrelationId, TestMessageId); ParentMsgId = msg2.MsgId; Bus.Publish(msg2); Assert.Equal(BusMessages.Count, 2); var msg3 = new ChildTestDomainEvent(TestCorrelationId, ParentMsgId); ChildMsgId = msg3.MsgId; Bus.Publish(msg3); Assert.Equal(BusMessages.Count, 3); var msg4 = new GrandChildTestDomainEvent(TestCorrelationId, ChildMsgId); Bus.Publish(msg4); Assert.Equal(BusMessages.Count, 4); //used in multiple_message_handle_invocations_are_correct test }
public void Verify_issued_by_is_resilient_to_missing_value() { var sut = new TestDomainEvent(); sut.Context = new Dictionary <string, object>(); Assert.That(sut.IssuedBy, Is.Null, "Context is null, issued by is not present"); }
public void Verify_issued_by_is_resilient_to_null() { var sut = new TestDomainEvent(); sut.Context = null; Assert.That(sut.IssuedBy, Is.Null, "Context is null, issued by is not present"); }
public void GetUserProperties_WhenDomainEventContainsNonRegisteredPropertyName_ReturnsDictionaryWithoutPropertyValue() { var strategy = new GlobalUserPropertyStrategy(); var domainEvent = new TestDomainEvent(Guid.NewGuid()); var results = strategy.GetUserProperties(domainEvent).ToArray(); results.Should().HaveCount(0); }
public void Verify_issued_by() { var sut = new TestDomainEvent(); sut.Context = new Dictionary <string, object>(); sut.Context.Add(MessagesConstants.UserId, "User_1234"); Assert.That(sut.IssuedBy, Is.EqualTo("User_1234")); }
public async Task ShouldPublishUncommittedEventsOnSaveAsync() { TestDomainEvent domainEvent = new TestDomainEvent(); var aggregate = new TestAggregate(domainEvent); eventStoreMock.Setup(x => x.AppendEventAsync(domainEvent)).ReturnsAsync(new AppendResult(1)); await sut.SaveAsync(aggregate); domainEventPublisherMock.Verify(x => x.PublishAsync(domainEvent)); }
public void AppliedEventIsReturned() { var domainEvent = new TestDomainEvent(Guid.NewGuid()); sut.ApplyEvent(domainEvent); IEnumerable <IDomainEvent> appliedEvents = sut.GetAppliedEvents(); Assert.AreEqual(1, appliedEvents.Count()); Assert.AreSame(domainEvent, appliedEvents.Single()); }
public void Commit_timestamp_taken_from_base_header() { var sut = new TestDomainEvent(); var changeset = new Changeset(1, new[] { sut }); var ts = new DateTime(2020, 12, 3, 23, 21, 4); changeset.Add(ChangesetCommonHeaders.Timestamp, ts); sut.Context = changeset.Headers; Assert.That(sut.CommitStamp, Is.EqualTo(ts)); }
public void Verify_issued_by_override_by_correct_header() { var sut = new TestDomainEvent(); sut.Context = new Dictionary <string, object>(); sut.Context.Add(MessagesConstants.UserId, "User_1234"); sut.Context.Add(MessagesConstants.OnBehalfOf, "User_42"); Assert.That(sut.IssuedBy, Is.EqualTo("User_42")); }
public void Should_create_empty_metadata() { //Arrange //Act var domainEvent = new TestDomainEvent(null); //Assert domainEvent.Metadata.Should().NotBeNull(); }
public void Publish_ExecutesOnlySpecificAndGeneralHandlersForEvent_When_ThereIsAMixOfGeneralSubscribersAndSpecificSubcribersForThatEventAndSpecificSubscribersForOtherEvents() { //arrange var generalHandlerExecuted1 = false; var generalHandlerExecuted2 = false; var specificHandlerExecuted1 = false; var specificHandlerExecuted2 = false; var specificOtherHandlerExecuted1 = false; var specificOtherHandlerExecuted2 = false; var publisher = new DomainEventPublisher(); var testDomainEvent = new TestDomainEvent(); Action <DomainEvent> generalEventHandle1 = domainEventParam => { generalHandlerExecuted1 = true; }; Action <DomainEvent> generalEventHandle2 = domainEventParam => { generalHandlerExecuted2 = true; }; Action <DomainEvent> specificEventHandle1 = domainEventParam => { specificHandlerExecuted1 = true; }; Action <DomainEvent> specificEventHandle2 = domainEventParam => { specificHandlerExecuted2 = true; }; Action <DomainEvent> specificOtherEventHandle1 = domainEventParam => { specificOtherHandlerExecuted1 = true; }; Action <DomainEvent> specificOtherEventHandle2 = domainEventParam => { specificOtherHandlerExecuted2 = true; }; publisher.Subscribe <DomainEvent>(generalEventHandle1); publisher.Subscribe <DomainEvent>(generalEventHandle2); publisher.Subscribe <TestDomainEvent>(specificEventHandle1); publisher.Subscribe <TestDomainEvent>(specificEventHandle2); publisher.Subscribe <TestDomainEvent2>(specificOtherEventHandle1); publisher.Subscribe <TestDomainEvent2>(specificOtherEventHandle2); //act publisher.Publish <TestDomainEvent>(new TestDomainEvent()); //assert Assert.AreEqual(true, generalHandlerExecuted1); Assert.AreEqual(true, generalHandlerExecuted2); Assert.AreEqual(true, specificHandlerExecuted1); Assert.AreEqual(true, specificHandlerExecuted2); Assert.AreEqual(false, specificOtherHandlerExecuted1); Assert.AreEqual(false, specificOtherHandlerExecuted2); }
public void When_raising_future_event() { _testCommand = new ScheduleEventInFutureCommand(DateTime.Now, Guid.NewGuid(), "test value"); _aggregate = new TestAggregate(_testCommand.AggregateId); _aggregate.ScheduleInFuture(_testCommand.RaiseTime, _testCommand.Value); _futureEventEnvelop = _aggregate.GetEvent <FutureEventScheduledEvent>(); _aggregate.RaiseScheduledEvent(_futureEventEnvelop.Id); _producedEvent = _aggregate.GetEvent <TestDomainEvent>(); _futureEventOccuredEvent = _aggregate.GetEvent <FutureEventOccuredEvent>(); }
public void Commit_timestamp_resilient_to_null() { var sut = new TestDomainEvent(); var changeset = new Changeset(1, new[] { sut }); Assert.That(sut.CommitStamp, Is.EqualTo(DateTime.MinValue)); // now add a null value. changeset.Add(ChangesetCommonHeaders.Timestamp, null); Assert.That(sut.CommitStamp, Is.EqualTo(DateTime.MinValue)); }
public void Should_invoke_event_specific_apply_methods_when_load_from_history() { //Arrange var domainEvent = new TestDomainEvent(); var sut = new TestEventSourcedAggregateRoot(); //Act sut.LoadFromHistory(new[] { domainEvent }); //Assert sut.ApplyWasCalled.Should().BeTrue(); }
public void GetUserProperties_WhenDomainEventContainsRegisteredPropertyName_ReturnsDictionaryWithPropertyValue() { var id = Guid.NewGuid(); var strategy = new GlobalUserPropertyStrategy("Id"); var domainEvent = new TestDomainEvent(id); var results = strategy.GetUserProperties(domainEvent).ToArray(); results.Should().HaveCount(1); results.First().Key.Should().Be("Id"); results.First().Value.Should().Be(id); }
public void Test_Publish_NoTopics_WhenNotSetup() { var bb = new BigBrother("", ""); bb.TelemetrySubscriptions.Clear(); // disable normal telemetry var dEvent = new TestDomainEvent(); var mPublisher = new Mock <IPublishEvents>(); bb.Publish(dEvent); mPublisher.Verify(x => x.Publish(It.IsAny <TelemetryEvent>()), Times.Never); }
public void Context() { _raisedDomainEvent = null; var domainEventHandlerFactory = new FakeDomainEventHandlerFactory(domainEvent => _raisedDomainEvent = (TestDomainEvent)domainEvent); DomainEvents.Initialize(domainEventHandlerFactory, isDelayedDomainEventHandlingEnabled: true); DomainEvents.ResetDelayedEventsStorage(); _entity = new TestEntityWithDomainEvent(); _entity.BehaviouralMethodWithRaisingDomainEvent(); }
public void AppliedEventsAreReturnedInAppliedOrder() { var domainEvent1 = new TestDomainEvent(Guid.NewGuid()); var domainEvent2 = new TestDomainEvent(Guid.NewGuid()); sut.ApplyEvent(domainEvent2); sut.ApplyEvent(domainEvent1); IEnumerable <IDomainEvent> appliedEvents = sut.GetAppliedEvents(); Assert.AreEqual(2, appliedEvents.Count()); Assert.AreSame(domainEvent2, appliedEvents.ElementAt(0)); Assert.AreSame(domainEvent1, appliedEvents.ElementAt(1)); }
public void Should_set_snapshot_version_on_save() { //Arrange var domainEvent = new TestDomainEvent(); var sut = new TestSnapshotAggregateRoot(Guid.NewGuid()); sut.LoadFromHistory(new [] { domainEvent, domainEvent }); //Act var(_, snapshotVersion) = ((ISnapshotableEntity)sut).TakeSnapshot(); //Assert sut.Version.Should().Be(snapshotVersion); }
public async Task When_raising_future_event() { _scheduledTime = DateTime.Now.AddSeconds(1); _testCommand = new ScheduleEventInFutureCommand(_scheduledTime, Guid.NewGuid(), "test value"); var waitResults = await GridNode.PrepareCommand(_testCommand) .Expect <FutureEventScheduledEvent>() .And <TestDomainEvent>() .Execute(); _futureEventEnvelop = waitResults.Message <FutureEventScheduledEvent>(); _producedEvent = waitResults.Message <TestDomainEvent>(); _aggregate = LoadAggregate <TestAggregate>(_testCommand.AggregateId); }
public async Task ShouldLoadAnAggregateAndApplyEventsAsync() { TestDomainEvent domainEvent = new TestDomainEvent(); eventStoreMock.Setup(x => x.ReadEventsAsync(DefaultId)) .ReturnsAsync(new List <Event <TestAggregateId> >() { new Event <TestAggregateId>(domainEvent, 0) }); var aggregate = await sut.GetByIdAsync(DefaultId); Assert.NotNull(aggregate); Assert.Single(aggregate.AppliedEvents); Assert.Equal(domainEvent, aggregate.AppliedEvents[0]); }
public void VersionIsSetToPreviouslyGeneratedEvents() { const long expectedVersion = 313; var domainEvent1 = new TestDomainEvent(Guid.NewGuid(), 1); var domainEvent2 = new TestDomainEvent(Guid.NewGuid(), 2); sut.ApplyEvent(domainEvent2); sut.ApplyEvent(domainEvent1); sut.SetVersion(expectedVersion); Assert.AreEqual(expectedVersion, domainEvent1.EntityVersion); Assert.AreEqual(expectedVersion, domainEvent2.EntityVersion); }
public async Task ShouldLoadAnAggregateAndApplyEventsAsync() { var domainEvent = new TestDomainEvent(); this.eventStoreMock.Setup(x => x.ReadEventsAsync <Guid>($"TestAggregate-{DefaultId}", null, null)) .ReturnsAsync(new List <Event <Guid> >() { new Event <Guid>(domainEvent, 0) }); var aggregate = await this.sut.GetByIdAsync(DefaultId).AnyContext(); Assert.NotNull(aggregate); Assert.Single(aggregate.AppliedEvents); Assert.Equal(domainEvent, aggregate.AppliedEvents[0]); }
public void Should_support_serialization() { //Arrange var sut = new TestEventSourcedAggregateRoot(Guid.NewGuid()); var domainEvent = new TestDomainEvent(); sut.LoadFromHistory(new[] { domainEvent }); //Act var serializedObject = JsonConvert.SerializeObject(sut); var deserializedObject = JsonConvert.DeserializeObject <TestEventSourcedAggregateRoot>(serializedObject); //Assert deserializedObject.Should().Be(sut); }
public void Test_Publish_UsesTopics_WhenSetup() { var bb = new BigBrother("", ""); bb.TelemetrySubscriptions.Clear(); // disable normal telemetry var dEvent = new TestDomainEvent(); var mPublisher = new Mock <IPublishEvents>(); mPublisher.Setup(x => x.Publish(It.IsAny <TelemetryEvent>())).Returns(Task.CompletedTask); bb.PublishEventsToTopics(mPublisher.Object); bb.Publish(dEvent); mPublisher.VerifyAll(); }
public async Task ShouldPublishUncommittedEventsOnSaveAsync() { // arrange var @event = new TestDomainEvent(); var aggregate = new TestAggregate(@event); this.mediatorMock.Setup(x => x.Publish(It.IsAny <TestDomainEvent>(), It.IsAny <CancellationToken>())).Returns(It.IsAny <Task>()); this.eventStoreMock.Setup(x => x.SaveEventAsync($"TestAggregate-{@event.AggregateId}", @event)).ReturnsAsync(new EventResult(1)); // act await this.sut.SaveAsync(aggregate).AnyContext(); // assert this.eventStoreMock.Verify(x => x.SaveEventAsync(It.IsAny <string>(), It.IsAny <TestDomainEvent>())); //this.mediatorMock.Verify(x => x.Publish(It.IsAny<TestDomainEvent>(), It.IsAny<CancellationToken>())); }
public void Publish_ExecutesHandleForEvent_When_ThereIsOneGeneralSubscriber() { //arrange var generalHandlerExecuted = false; var publisher = new DomainEventPublisher(); var testDomainEvent = new TestDomainEvent(); Action<DomainEvent> domainEventHandle = domainEventParam => { generalHandlerExecuted = true; }; publisher.Subscribe<DomainEvent>(domainEventHandle); //act publisher.Publish<TestDomainEvent>(new TestDomainEvent()); //assert Assert.AreEqual(true, generalHandlerExecuted); }
public void Publish_ExecutesHandleForEvent_When_ThereIsOneSpecificSubscriber() { //arrange var specificHandlerExecuted = false; var publisher = new DomainEventPublisher(); var testDomainEvent = new TestDomainEvent(); Action<DomainEvent> testDomainEventHandle = testDomainEventParam => { specificHandlerExecuted = true; }; publisher.Subscribe<TestDomainEvent>(testDomainEventHandle); //act publisher.Publish<TestDomainEvent>(new TestDomainEvent()); //assert Assert.AreEqual(specificHandlerExecuted, true); }
public void Publish_ExecutesOnlyGeneralHandlersForEvent_When_ThereIsAMixOfGeneralSubscribersAndSpecificSubscribersForOtherEvents() { //arrange var generalHandlerExecuted1 = false; var generalHandlerExecuted2 = false; var specificHandlerExecuted1 = false; var specificHandlerExecuted2 = false; var publisher = new DomainEventPublisher(); var testDomainEvent = new TestDomainEvent(); Action<DomainEvent> generalEventHandle1 = domainEventParam => { generalHandlerExecuted1 = true; }; Action<DomainEvent> generalEventHandle2 = domainEventParam => { generalHandlerExecuted2 = true; }; Action<DomainEvent> specificEventHandle1 = domainEventParam => { specificHandlerExecuted1 = true; }; Action<DomainEvent> specificEventHandle2 = domainEventParam => { specificHandlerExecuted2 = true; }; publisher.Subscribe<DomainEvent>(generalEventHandle1); publisher.Subscribe<DomainEvent>(generalEventHandle2); publisher.Subscribe<TestDomainEvent2>(specificEventHandle1); publisher.Subscribe<TestDomainEvent2>(specificEventHandle2); //act publisher.Publish<TestDomainEvent>(new TestDomainEvent()); //assert Assert.AreEqual(true, generalHandlerExecuted1); Assert.AreEqual(true, generalHandlerExecuted2); Assert.AreEqual(false, specificHandlerExecuted1); Assert.AreEqual(false, specificHandlerExecuted2); }