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