public async Task EventBus_Should_Invoke_Event_Handlers_Implicit_Topic()
{
// Create handlers
var state = new FakeState {
Data = "A"
};
var fakeHandler1 = new FakeEventHandler1(state);
var fakeHandler2 = new FakeEventHandler2(state);
// Create message broker
var messageBroker = new FakeMessageBroker();
messageBroker.Subscribe(fakeHandler1);
messageBroker.Subscribe(fakeHandler2);
// Create service bus
var eventBus = new FakeEventBus(messageBroker);
eventBus.Subscribe(fakeHandler1);
eventBus.Subscribe(fakeHandler2);
// Publish to service bus
var @event = new FakeIntegrationEvent("B");
await eventBus.PublishAsync(@event);
// Assert
Assert.Equal(@event.CreationDate, state.Date);
Assert.Equal("B", state.Data);
}
public async Task ServiceBus_PublishIntegrationEventsAsyncPersistsChangesToContext()
{
var @event = new FakeIntegrationEvent("Fake Value");
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var mockSerializer = new Mock <IMessageSerializer>();
var sut = new ServiceBus(
Mock.Of <IMessageSerializer>(),
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IQueueClient>(),
Mock.Of <ITopicClient>(),
Mock.Of <ILogger>(),
context);
await sut.PublishEventsAsync(@event);
}
using (var context = new InfrastructureContext(options))
{
var eventEntity = await context.IntegrationEvents.FindAsync(@event.MessageId);
Assert.NotNull(eventEntity);
Assert.Equal(@event.MessageId, eventEntity.Id);
}
}
public async Task OnProcessMessageAsync_MessageProcessing_Fails_And_MaxDeliveryCount_Reached_Should_DeadLetter_Message()
{
// Arrange
var eventName = nameof(FakeIntegrationEvent);
var eventId = Guid.NewGuid();
var eventIdAsString = eventId.ToString();
var integrationEvent = new FakeIntegrationEvent(eventId);
var payload = JsonSerializer.Serialize(integrationEvent);
Mock.Get(_fixture.ProcessingPipeline)
.Setup(s => s
.Handle(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), CancellationToken.None))
.ReturnsAsync(false);
await _fixture.Processor.Start(CancellationToken.None);
// Act
var args = await _fixture.ServiceBusProcessor.SimulateMessageReceivingOf(
messageId : eventIdAsString,
subject : eventName,
payload,
attempt : EventsProcessor.MaxDeliveryCount + 1);
// Assert
args
.WasDeadLettered
.Should()
.Be(true);
}
public async Task OnProcessMessageAsync_ProcessingPipeline_Throws_Exception_Should_Not_Swallow_It()
{
// Arrange
var eventName = nameof(FakeIntegrationEvent);
var eventId = Guid.NewGuid();
var eventIdAsString = eventId.ToString();
var integrationEvent = new FakeIntegrationEvent(eventId);
var payload = JsonSerializer.Serialize(integrationEvent);
Mock.Get(_fixture.ProcessingPipeline)
.Setup(s => s
.Handle(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), CancellationToken.None))
.Throws(new Exception("Unit tests exception"));
await _fixture.Processor.Start(CancellationToken.None);
// Act
// Assert
await Assert.ThrowsAsync <Exception>(async() =>
{
await _fixture.ServiceBusProcessor.SimulateMessageReceivingOf(
messageId: eventIdAsString,
subject: eventName,
payload,
rethrowExceptions: true);
});
}
public async Task OnProcessMessageAsync_MessageProcessing_Is_Successful_Should_Complete_Message()
{
// Arrange
var eventName = nameof(FakeIntegrationEvent);
var eventId = Guid.NewGuid();
var eventIdAsString = eventId.ToString();
var integrationEvent = new FakeIntegrationEvent(eventId);
var payload = JsonSerializer.Serialize(integrationEvent);
Mock.Get(_fixture.ProcessingPipeline)
.Setup(s => s
.Handle(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), CancellationToken.None))
.ReturnsAsync(true);
await _fixture.Processor.Start(CancellationToken.None);
// Act
var args = await _fixture.ServiceBusProcessor.SimulateMessageReceivingOf(
messageId : eventIdAsString,
subject : eventName,
payload);
// Assert
args
.WasCompleted
.Should()
.Be(true);
}
public async Task Publish_Message_Serialized_Should_Be_Sent()
{
// Arrange
_fixture
.SetupMessageSerializerToReturnJson(out var json);
var integrationEvent = new FakeIntegrationEvent();
// Act
var result = await _fixture.Publisher
.Publish(integrationEvent, CancellationToken.None);
// Assert
result.Should().Be(true);
_fixture.SentMessage
.Subject
.Should()
.Be(nameof(FakeIntegrationEvent));
_fixture.SentMessage
.Body.ToString()
.Should()
.Be(json);
_fixture.SentMessage
.MessageId
.Should()
.Be(integrationEvent.Id.ToString());
}
public async Task EventBus_Should_Invoke_Event_Handlers(TopicType topicType, string prefix)
{
// Topic name
var topicName = topicType == TopicType.Explicit ? "my-topic" : null;
// Create handlers
var state = new FakeState {
Data = "A"
};
var fakeHandler1 = new FakeEventHandler1(state);
var fakeHandler2 = new FakeEventHandler2(state);
// Create message broker
var messageBroker = new FakeMessageBroker();
messageBroker.Subscribe(fakeHandler1, topicName, prefix);
messageBroker.Subscribe(fakeHandler2, topicName, prefix);
// Create service bus
var eventBus = new FakeEventBus(messageBroker);
eventBus.Subscribe(fakeHandler1, topicName, prefix);
eventBus.Subscribe(fakeHandler2, topicName, prefix);
// Publish to service bus
var @event = new FakeIntegrationEvent("B");
await eventBus.PublishAsync(@event, topicName, prefix);
// Assert
Assert.Equal(@event.CreationDate, state.Date);
Assert.Equal("B", state.Data);
}
/// <summary>
/// Setup message serializer to return instance of <see cref="FakeIntegrationEvent"/>
/// and save in memento state, so it can be accessed later on.
/// </summary>
/// <returns></returns>
public EventProcessingPipelineFixture SetupMessageSerializerToReturnMessages()
{
var message = new FakeIntegrationEvent();
Mock.Get(MessageSerializer)
.Setup(s => s
.UnpackFromJson(It.IsAny <string>(), It.IsAny <Type>()))
.Returns(message);
Memento
.Save(message);
return(this);
}
public async Task AddEventAsync_Should_Add_Entry_To_IntegrationEventLogs()
{
// Arrange
var initialRecords = _fixture.OperationalDbContext.IntegrationEventLogs.Count();
var integrationEvent = new FakeIntegrationEvent();
// Act
await _fixture.EventLogService.AddEventAsync(integrationEvent, CancellationToken.None);
await _fixture.OperationalDbContext.SaveChangesAsync(CancellationToken.None);
// Assert
var resultingTotal = _fixture.OperationalDbContext.IntegrationEventLogs.Count();
resultingTotal.Should().Be(initialRecords + 1);
}
public async Task MarkEventAsInProgressAsync_Should_Mark_Event_AsInProgress()
{
// Arrange
var integrationEvent = new FakeIntegrationEvent();
await _fixture.EventLogService.AddEventAsync(integrationEvent, CancellationToken.None);
await _fixture.OperationalDbContext.SaveChangesAsync(CancellationToken.None);
// Act
await _fixture.EventLogService.MarkEventAsInProgressAsync(integrationEvent.Id);
// Assert
var eventEntry = _fixture.OperationalDbContext
.IntegrationEventLogs.First(e => e.EventId == integrationEvent.Id);
eventEntry.State.Should().Be(EventStateEnum.InProgress);
}
public async Task MarkEventAsInProgressAsync_Called_2_Times_Should_Increment_TimesSent_Counter()
{
// Arrange
var integrationEvent = new FakeIntegrationEvent();
await _fixture.EventLogService.AddEventAsync(integrationEvent, CancellationToken.None);
await _fixture.OperationalDbContext.SaveChangesAsync(CancellationToken.None);
// Act
await _fixture.EventLogService.MarkEventAsInProgressAsync(integrationEvent.Id);
await _fixture.EventLogService.MarkEventAsInProgressAsync(integrationEvent.Id);
// Assert
var eventEntry = _fixture.OperationalDbContext
.IntegrationEventLogs.First(e => e.EventId == integrationEvent.Id);
eventEntry.TimesSent.Should().Be(2);
}
public async Task Publish_Has_3_PreSending_Steps_Should_Execute_Them()
{
// Arrange
var @event = new FakeIntegrationEvent();
_fixture
.Setup3PreSendingSteps();
// Act
await _fixture.Publisher
.Publish(@event, CancellationToken.None);
// Assert
foreach (var preSendingStep in _fixture.PreSendingSteps)
{
Mock.Get(preSendingStep)
.Verify(v => v.Execute(@event, CancellationToken.None));
}
}
public async Task ServiceBus_PublishIntegrationEventsAsyncInvokesSerializeOnIMessageSerializer()
{
var @event = new FakeIntegrationEvent("Fake Value");
var options = SetupContext();
using (var context = new InfrastructureContext(options))
{
var mockSerializer = new Mock <IMessageSerializer>();
var sut = new ServiceBus(mockSerializer.Object,
Mock.Of <IHttpContextAccessor>(),
Mock.Of <IQueueClient>(),
Mock.Of <ITopicClient>(),
Mock.Of <ILogger>(),
context);
await sut.PublishEventsAsync(@event);
mockSerializer.Verify(s => s.Serialize <IntegrationEvent>(@event));
}
}
public async Task OnProcessMessageAsync_Should_Trigger_Message_ProcessingPipeline()
{
// Arrange
var eventName = nameof(FakeIntegrationEvent);
var eventId = Guid.NewGuid();
var eventIdAsString = eventId.ToString();
var integrationEvent = new FakeIntegrationEvent(eventId);
var payload = JsonSerializer.Serialize(integrationEvent);
await _fixture.Processor.Start(CancellationToken.None);
// Act
await _fixture.ServiceBusProcessor.SimulateMessageReceivingOf(
messageId : eventIdAsString,
subject : eventName,
payload);
// Assert
Mock.Get(_fixture.ProcessingPipeline)
.Verify(v => v
.Handle(eventIdAsString, eventName, payload, CancellationToken.None), Times.Once);
}
public async Task OnProcessMessageAsync_Should_Call_ProcessingMessage_Callback()
{
// Arrange
var eventName = nameof(FakeIntegrationEvent);
var eventId = Guid.NewGuid();
var eventIdAsString = eventId.ToString();
var integrationEvent = new FakeIntegrationEvent(eventId);
var payload = JsonSerializer.Serialize(integrationEvent);
await _fixture.Processor.Start(CancellationToken.None);
// Act
await _fixture.ServiceBusProcessor.SimulateMessageReceivingOf(
messageId : eventIdAsString,
subject : eventName,
payload);
// Assert
_fixture
.ServiceBusProcessor
.WasProcessingCallbackCalled
.Should()
.Be(true);
}
/// <summary> /// Saves <see cref="FakeIntegrationEvent"/> message in collection of /// processed messages in memento state. /// </summary> /// <param name="message"></param> public void Save(FakeIntegrationEvent message) => _messages.Add(message);
