private static Mock <IBlockEventsHandler> BlockEventsHandlerCreateMock(Action <string, object, MessageHeaders, IMessagePublisher> callBack)
{
Mock <IBlockEventsHandler> blockEventsHandler = new Mock <IBlockEventsHandler>();
blockEventsHandler.Setup(x => x.HandleAsync(It.IsAny <string>(), It.IsAny <BlockHeaderReadEvent>(), It.IsAny <MessageHeaders>(), It.IsAny <IMessagePublisher>()))
.ReturnsAsync(MessageHandlingResult.Success())
.Callback(callBack)
.Verifiable();
blockEventsHandler.Setup(x => x.HandleAsync(It.IsAny <string>(), It.IsAny <BlockNotFoundEvent>(), It.IsAny <MessageHeaders>(), It.IsAny <IMessagePublisher>()))
.ReturnsAsync(MessageHandlingResult.Success())
.Callback(callBack)
.Verifiable();
blockEventsHandler.Setup(x => x.HandleAsync(It.IsAny <string>(), It.IsAny <TransferAmountTransactionsBatchEvent>(), It.IsAny <MessageHeaders>(), It.IsAny <IMessagePublisher>()))
.ReturnsAsync(MessageHandlingResult.Success())
.Callback(callBack)
.Verifiable();
blockEventsHandler.Setup(x => x.HandleAsync(It.IsAny <string>(), It.IsAny <TransferCoinsTransactionsBatchEvent>(), It.IsAny <MessageHeaders>(), It.IsAny <IMessagePublisher>()))
.ReturnsAsync(MessageHandlingResult.Success())
.Callback(callBack)
.Verifiable();
blockEventsHandler.Setup(x => x.HandleAsync(It.IsAny <string>(), It.IsAny <LastIrreversibleBlockUpdatedEvent>(), It.IsAny <MessageHeaders>(), It.IsAny <IMessagePublisher>()))
.ReturnsAsync(MessageHandlingResult.Success())
.Callback(callBack)
.Verifiable();
return(blockEventsHandler);
}
public async Task <MessageHandlingResult> ProcessMessageAsync(
Message message, IEndpointHandlingConfig handlingConfig, CancellationToken ct)
{
try
{
var messageContext = MessageContext.Create(message);
var contractMessage = _serialiser.Deserialise <TMessage>(message);
if (contractMessage == null)
{
return(MessageHandlingResult.UnrecognisedMessageType(
$"Serialiser could not de-serialise message to {typeof(TMessage).AssemblyQualifiedName}",
message.UserProperties));
}
var stopwatch = Stopwatch.StartNew();
var handlingResult = await _handler.HandleMessageAsync(contractMessage, messageContext, ct).ConfigureAwait(false);
_instrumentor.TrackElapsed(
LogEventIds.HandlerMeasuredElapsed, stopwatch.ElapsedMilliseconds, _handler.GetType().Name, message.UserProperties);
return(handlingResult);
}
catch (OperationCanceledException ex)
{
_logger.LogWarning(LogEventIds.ProcessorCancelled, ex, $"Operation was cancelled in Processor<{typeof(TMessage).Name}>");
return(MessageHandlingResult.Abandoned(ex, message.UserProperties));
}
}
public async Task Test_that_filter_can_interrupt_invocation_chain_with_state()
{
// Arrange
var messageId = Guid.NewGuid();
const string state = "state";
const string correlationId = "correlationId";
const string exchange = "exchange";
const string routingKey = "routingKey";
const int retryCount = 123;
var options = new MessageSubscriptionOptions <TestMessage, string>(routingKey);
options.WithHandler <TestMessageHandlerWithState>();
options.WithState(state);
var filterMock = new Mock <IMessageFilter>();
filterMock
.Setup(x => x.HandleMessageAsync(It.IsNotNull <MessageFilteringContext>()))
.Returns <MessageFilteringContext>(context => Task.FromResult(MessageHandlingResult.TransientFailure()));
var globalFilters = new List <IMessageFilter>
{
filterMock.Object
};
var subscription = new MessageSubscription <TestMessage, string>(options, globalFilters);
// Action
var result = await subscription.InvokeHandlerAsync
(
_serviceProvider,
new TestMessage
{
Id = messageId
},
new MessageHeaders(correlationId),
new MessageHandlingContext(exchange, retryCount, routingKey),
_messagePublisherMock.Object
);
// Assert
Assert.AreEqual(MessageHandlingResult.TransientFailure(), result);
_testHandlerWithStateImplMock.Verify
(
x => x.HandleAsync
(
It.IsAny <string>(),
It.IsAny <TestMessage>(),
It.IsAny <MessageHeaders>(),
It.IsAny <IMessagePublisher>()
),
times: Times.Never
);
filterMock.Verify(x => x.HandleMessageAsync(It.IsNotNull <MessageFilteringContext>()), Times.Once());
}
public async Task Test_that_handler_with_state_invoked_without_filters()
{
// Arrange
var messageId = Guid.NewGuid();
const string state = "state";
const string correlationId = "correlationId";
const string exchange = "exchange";
const string routingKey = "routingKey";
const int retryCount = 123;
var options = new MessageSubscriptionOptions <TestMessage, string>(routingKey);
options.WithHandler <TestMessageHandlerWithState>();
options.WithState(state);
var subscription = new MessageSubscription <TestMessage, string>(options, Array.Empty <IMessageFilter>());
_testHandlerWithStateImplMock
.Setup(x => x.HandleAsync
(
It.IsAny <string>(),
It.IsAny <TestMessage>(),
It.IsAny <MessageHeaders>(),
It.IsAny <IMessagePublisher>()
))
.Returns <string, TestMessage, MessageHeaders, IMessagePublisher>((s, m, h, p) => Task.FromResult(MessageHandlingResult.Success()));
// Action
var result = await subscription.InvokeHandlerAsync
(
_serviceProvider,
new TestMessage
{
Id = messageId
},
new MessageHeaders(correlationId),
new MessageHandlingContext(exchange, retryCount, routingKey),
_messagePublisherMock.Object
);
// Assert
Assert.AreEqual(MessageHandlingResult.Success(), result);
_testHandlerWithStateImplMock.Verify
(
x => x.HandleAsync
(
It.Is <string>(s => s == state),
It.Is <TestMessage>(m => m.Id == messageId),
It.IsNotNull <MessageHeaders>(),
It.IsNotNull <IMessagePublisher>()
),
times: Times.Once
);
}
public void Return_Expected_Result_Using_CompletedMessageType_Helper_Given_AdditionalProperties(
string additionalPropertyKey, string additionalPropertyValue)
{
var additionalProperties = new Dictionary <string, object>
{
{ additionalPropertyKey, additionalPropertyValue }
};
var result = MessageHandlingResult.Completed(additionalProperties);
result.Result.Should().Be(MessageHandlingResult.HandlingResult.Completed);
result.AdditionalProperties[additionalPropertyKey].Should().Be(additionalPropertyValue);
result.AdditionalProperties.Count.Should().Be(1);
}
public async Task DeadLetters_A_Message_Given_Correctly_Configured_TopicHandlingOptions_And_Result_Is_UnrecognisedMessageType_When_Handling_Messages()
{
_mockProcessor.Reset();
_mockProcessor
.Setup(m => m.ProcessMessageAsync(It.IsAny <Message>(), _options, CancellationToken.None))
.ReturnsAsync(MessageHandlingResult.UnrecognisedMessageType("Bad ting"));
await _listener.StartListeningAsync(CancellationToken.None).ConfigureAwait(false);
await ReceiveMessages(1).ConfigureAwait(false);
_spyMessageReceiver.DeadLetterAsyncCalled.Should().BeTrue();
}
public async Task Abandons_A_Message_Given_Correctly_Configured_TopicHandlingOptions_And_Result_Is_Abandoned_When_Handling_Messages()
{
_mockProcessor.Reset();
_mockProcessor
.Setup(m => m.ProcessMessageAsync(It.IsAny <Message>(), _options, CancellationToken.None))
.ReturnsAsync(MessageHandlingResult.Abandoned(new AbandonedMutexException()));
await _listener.StartListeningAsync(CancellationToken.None).ConfigureAwait(false);
await ReceiveMessages(1).ConfigureAwait(false);
_spyMessageReceiver.AbandonAsyncCalled.Should().BeTrue();
}
public void Return_Expected_Result_Using_DeadLetteredMessageType_Helper_Given_Details_And_AdditionalProperties(
string details, string additionalPropertyKey, string additionalPropertyValue)
{
var additionalProperties = new Dictionary <string, object>
{
{ additionalPropertyKey, additionalPropertyValue }
};
var result = MessageHandlingResult.DeadLettered(details, additionalProperties);
result.Result.Should().Be(MessageHandlingResult.HandlingResult.DeadLettered);
result.AdditionalProperties["AzureBusDepot.DeadLettered"].Should().Be(details);
result.AdditionalProperties[additionalPropertyKey].Should().Be(additionalPropertyValue);
result.AdditionalProperties.Count.Should().Be(2);
}
public void Return_Expected_Result_Using_UnrecognisedMessageType_Helper_Given_Details_And_AdditionalProperties_And_Reserved_Property_Keys_Already_Exist(
string details, string additionalPropertyKey, string additionalPropertyValue)
{
var additionalProperties = new Dictionary <string, object>
{
{ "AzureBusDepot.UnrecognisedMessageType", "existing" },
{ additionalPropertyKey, additionalPropertyValue }
};
var result = MessageHandlingResult.UnrecognisedMessageType(details, additionalProperties);
result.Result.Should().Be(MessageHandlingResult.HandlingResult.UnrecognisedMessageType);
result.AdditionalProperties["AzureBusDepot.UnrecognisedMessageType"].Should().Be(details);
result.AdditionalProperties[additionalPropertyKey].Should().Be(additionalPropertyValue);
result.AdditionalProperties.Count.Should().Be(2);
}
public async Task Handle_Deserialised_Message_Given_Valid_Message()
{
var message = NewMessageWithBody();
_mockSerialiser
.Setup(s => s.Deserialise <MyEvent>(It.IsAny <Message>()))
.Returns(MyEvent.Default);
_mockHandler
.Setup(h => h.HandleMessageAsync(MyEvent.Default, It.IsAny <MessageContext>(), CancellationToken.None))
.ReturnsAsync(MessageHandlingResult.Completed());
await _processor.ProcessMessageAsync(message, MyEndpointHandlingConfig.Default, CancellationToken.None).ConfigureAwait(false);
_mockHandler.Verify(s => s.HandleMessageAsync(MyEvent.Default, It.IsAny <MessageContext>(), CancellationToken.None), Times.Once);
}
public void Return_Expected_Result_Using_AbandonedMessageType_Helper_Given_Exception_And_AdditionalProperties(
string additionalPropertyKey, string additionalPropertyValue)
{
var exception = new MessageSizeExceededException("That's no moon");
var additionalProperties = new Dictionary <string, object>
{
{ additionalPropertyKey, additionalPropertyValue }
};
var result = MessageHandlingResult.Abandoned(exception, additionalProperties);
result.Result.Should().Be(MessageHandlingResult.HandlingResult.Abandoned);
result.AdditionalProperties["AzureBusDepot.Abandoned"].Should().Be("Exception");
result.AdditionalProperties["AzureBusDepot.Exception.Message"].Should().Be(exception.Message);
result.AdditionalProperties[additionalPropertyKey].Should().Be(additionalPropertyValue);
result.AdditionalProperties.Count.Should().Be(4);
}
public MultiMessageTypeListenerShould()
{
_mockProcessor = new Mock <IMessageProcessor <MyEvent> >();
_mockProcessor
.Setup(m => m.ProcessMessageAsync(It.IsAny <Message>(), _options, CancellationToken.None))
.ReturnsAsync(MessageHandlingResult.Completed());
_mockProcessorDispatcher = new Mock <IMessageProcessorDispatcher>();
_mockProcessorDispatcher.Setup(m => m.GetProcessorForMessage(It.IsAny <Message>())).Returns(_mockProcessor.Object);
_listener = new MultiMessageTypeListener <MyEndpointHandlingConfig>(
new NullLogger <MultiMessageTypeListener <MyEndpointHandlingConfig> >(),
_mockProcessorDispatcher.Object,
new MessageReceiverFactory(),
new VoidInstrumentor(),
_options);
}
public async Task <MessageHandlingResult> HandleMessageAsync(
MySecondCommand message, MessageContext context, CancellationToken ct)
{
_logger.LogDebug(LogEventIds.HandlerStarted, $"{nameof(MySecondCommandHandler)}:{nameof(HandleMessageAsync)} started");
try
{
await FakeCallToPersistToSomeDatabase(message, ct);
}
catch (Exception ex)
{
_logger.LogError(LogEventIds.HandlerException, ex, $"Unhandled exception in {nameof(MySecondCommandHandler)}");
return(MessageHandlingResult.DeadLettered(ex, context.UserProperties));
}
_logger.LogDebug(LogEventIds.HandlerFinished, $"{nameof(MySecondCommandHandler)}:{nameof(HandleMessageAsync)} finished");
return(MessageHandlingResult.Completed(context.UserProperties));
}
public async Task Track_Request_Telemetry_When_Handling_Messages(int count, bool isSuccessful, string customProperty)
{
var customProperties = new Dictionary <string, object> {
{ "customProperty", customProperty }
};
_mockProcessor.Reset();
_mockProcessor
.Setup(m => m.ProcessMessageAsync(It.IsAny <Message>(), _options, CancellationToken.None))
.ReturnsAsync(isSuccessful ? MessageHandlingResult.Completed(customProperties) : MessageHandlingResult.DeadLettered("BOOM", customProperties));
await _listener.StartListeningAsync(CancellationToken.None).ConfigureAwait(false);
await ReceiveMessages(count).ConfigureAwait(false);
_mockInstrumentor.Verify(
i => i.TrackRequest(
LogEventIds.ListenerHandlerFinished, It.IsAny <long>(), It.IsAny <DateTimeOffset>(), "MultiMessageTypeListener<MyEndpointHandlingConfig>", null, null, isSuccessful, It.Is <IDictionary <string, object> >(d => (string)d["customProperty"] == customProperty)),
Times.Exactly(count));
}
public async Task <MessageHandlingResult> HandleAsync(ReadBlockCommand command, MessageHeaders headers, IMessagePublisher replyPublisher)
{
var blockListener = new BlockListener
(
replyPublisher,
_rawObjectRepository,
_transactionsBatchSize,
_maxTransactionsSavingParallelism,
_transferModel
);
using (blockListener)
{
await _blockReader.ReadBlockAsync(command.BlockNumber, blockListener);
await blockListener.FlushAsync();
}
return(MessageHandlingResult.Success());
}
public async Task <MessageHandlingResult> HandleMessageAsync(
MyFirstCommand message, MessageContext context, CancellationToken ct)
{
_logger.LogDebug(LogEventIds.HandlerStarted, $"{nameof(MyFirstCommandHandler)}:{nameof(HandleMessageAsync)} started");
try
{
await FakeCallToHttpApiToPutAssociatedItem(message, ct).ConfigureAwait(false);
await FakeSendingOfMessage(message, ct).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.LogError(LogEventIds.HandlerException, ex, $"Unhandled exception in {nameof(MyFirstCommandHandler)}");
return(MessageHandlingResult.DeadLettered(ex, context.UserProperties));
}
_logger.LogDebug(LogEventIds.HandlerFinished, $"{nameof(MyFirstCommandHandler)}:{nameof(HandleMessageAsync)} finished");
return(MessageHandlingResult.Completed(context.UserProperties));
}
public MultiMessageTypeListenerShould()
{
_spyLogger = new SpyLogger <MultiMessageTypeListener <MyEndpointHandlingConfig> >();
_spyMessageReceiver = new SpyMessageReceiver(_options);
_mockMessageReceiverFactory = new Mock <IMessageReceiverFactory>();
_mockMessageReceiverFactory.Setup(m => m.CreateMessageReceiver(_options, null)).Returns(_spyMessageReceiver);
_mockInstrumentor = new Mock <IInstrumentor>();
_mockProcessor = new Mock <IMessageProcessor <MyEvent> >();
_mockProcessor
.Setup(m => m.ProcessMessageAsync(It.IsAny <Message>(), _options, CancellationToken.None))
.ReturnsAsync(MessageHandlingResult.Completed());
_mockProcessorDispatcher = new Mock <IMessageProcessorDispatcher>();
_mockProcessorDispatcher.Setup(m => m.GetProcessorForMessage(It.IsAny <Message>())).Returns(_mockProcessor.Object);
_listener = new MultiMessageTypeListener <MyEndpointHandlingConfig>(
_spyLogger,
_mockProcessorDispatcher.Object,
_mockMessageReceiverFactory.Object,
_mockInstrumentor.Object,
_options);
}
protected async Task <bool> HandleMessageOutcome(
Message message,
MessageHandlingResult result)
{
var isSuccessful = result.Result == MessageHandlingResult.HandlingResult.Completed;
var shouldAutoComplete = _endpointHandlingConfig.AutoComplete || _receiver.IsClosedOrClosing;
if (shouldAutoComplete)
{
return(isSuccessful);
}
try
{
switch (result.Result)
{
case MessageHandlingResult.HandlingResult.Completed:
await _receiver.CompleteAsync(message.SystemProperties.LockToken).ConfigureAwait(false);
break;
case MessageHandlingResult.HandlingResult.DeadLettered:
case MessageHandlingResult.HandlingResult.UnrecognisedMessageType:
await _receiver.DeadLetterAsync(message.SystemProperties.LockToken, result.AdditionalProperties).ConfigureAwait(false);
break;
case MessageHandlingResult.HandlingResult.Abandoned:
await _receiver.AbandonAsync(message.SystemProperties.LockToken, result.AdditionalProperties).ConfigureAwait(false);
break;
}
}
catch (MessageLockLostException ex)
{
_logger.LogError(LogEventIds.ListenerException, ex, $"MessageLockLostException in {_name}>");
}
return(isSuccessful);
}
public async Task <MessageHandlingResult> HandleMessageAsync(
MyEvent message, MessageContext context, CancellationToken ct)
{
_logger.LogDebug(LogEventIds.HandlerStarted, $"{nameof(MyEventHandler)}:{nameof(HandleMessageAsync)} started");
try
{
// Just some fake tasks to mimic doing something
var associatedItem = await FakeCallToHttpApiToGetAssociatedItem(message, ct).ConfigureAwait(false);
var dbContractItem = (message.Id, message.Name, associatedItem.Id, associatedItem.Name);
await FakeCallToPersistToSomeDatabase(dbContractItem, ct);
}
catch (DivideByZeroException ex)
{
_logger.LogError(LogEventIds.HandlerException, ex, $"Unhandled exception in {nameof(MyEventHandler)}");
return(MessageHandlingResult.DeadLettered(ex, context.UserProperties));
}
_logger.LogDebug(LogEventIds.HandlerFinished, $"{nameof(MyEventHandler)}:{nameof(HandleMessageAsync)} finished");
return(MessageHandlingResult.Completed(context.UserProperties));
}
public async Task Test_that_handler_invoked_with_two_filter()
{
// Arrange
var messageId = Guid.NewGuid();
const string correlationId = "correlationId";
const string exchange = "exchange";
const string routingKey = "routingKey";
const int retryCount = 123;
var options = new MessageSubscriptionOptions <TestMessage>(routingKey);
options.WithHandler <TestMessageHandler>();
var filterMock = new Mock <IMessageFilter>();
filterMock
.Setup(x => x.HandleMessageAsync(It.IsNotNull <MessageFilteringContext>()))
.Returns <MessageFilteringContext>(context => context.InvokeNextAsync());
var globalFilters = new List <IMessageFilter>
{
filterMock.Object,
filterMock.Object
};
var subscription = new MessageSubscription <TestMessage>(options, globalFilters);
_testHandlerImplMock
.Setup(x => x.HandleAsync
(
It.IsAny <TestMessage>(),
It.IsAny <MessageHeaders>(),
It.IsAny <IMessagePublisher>()
))
.Returns <TestMessage, MessageHeaders, IMessagePublisher>((m, h, p) => Task.FromResult(MessageHandlingResult.Success()));
// Action
var result = await subscription.InvokeHandlerAsync
(
_serviceProvider,
new TestMessage
{
Id = messageId
},
new MessageHeaders(correlationId),
new MessageHandlingContext(exchange, retryCount, routingKey),
_messagePublisherMock.Object
);
// Assert
Assert.AreEqual(MessageHandlingResult.Success(), result);
_testHandlerImplMock.Verify
(
x => x.HandleAsync
(
It.Is <TestMessage>(m => m.Id == messageId),
It.IsNotNull <MessageHeaders>(),
It.IsNotNull <IMessagePublisher>()
),
times: Times.Once
);
filterMock.Verify(x => x.HandleMessageAsync(It.IsNotNull <MessageFilteringContext>()), Times.Exactly(2));
}
public Task <MessageHandlingResult> HandleMessageAsync(
MyEvent message, MessageContext context, CancellationToken ct)
{
return(Task.FromResult(MessageHandlingResult.Completed()));
}
public Task <MessageHandlingResult> HandleAsync(string integrationName, BlockNotFoundEvent evt, MessageHeaders headers, IMessagePublisher replyPublisher)
{
return(Task.FromResult(MessageHandlingResult.Success()));
}
public Task <MessageHandlingResult> HandleAsync(string state, TransferCoinsTransactionsBatchEvent message, MessageHeaders headers,
IMessagePublisher replyPublisher)
{
return(Task.FromResult(MessageHandlingResult.Success()));
}
public Task <MessageHandlingResult> HandleAsync(string integrationName, LastIrreversibleBlockUpdatedEvent evt, MessageHeaders headers, IMessagePublisher replyPublisher)
{
return(Task.FromResult(MessageHandlingResult.Success()));
}
public void SetUp()
{
_testHandlerImplMock = new Mock <ITestMessageHandlerImplementation>();
_testHandlerWithStateImplMock = new Mock <ITestMessageHandlerWithStateImplementation>();
_testHandlerImplMock
.Setup(x => x.HandleAsync
(
It.IsAny <TestMessage>(),
It.IsAny <MessageHeaders>(),
It.IsAny <IMessagePublisher>()
))
.Returns <TestMessage, MessageHeaders, IMessagePublisher>((m, h, p) => Task.FromResult(MessageHandlingResult.Success()));
_testHandlerWithStateImplMock
.Setup(x => x.HandleAsync
(
It.IsAny <string>(),
It.IsAny <TestMessage>(),
It.IsAny <MessageHeaders>(),
It.IsAny <IMessagePublisher>()
))
.Returns <string, TestMessage, MessageHeaders, IMessagePublisher>((s, m, h, p) => Task.FromResult(MessageHandlingResult.Success()));
var services = new ServiceCollection();
services.AddSingleton(LogFactory.Create().AddUnbufferedConsole());
services.AddTransient <TestMessageHandler>();
services.AddTransient <TestMessageHandlerWithState>();
services.AddTransient(c => _testHandlerImplMock.Object);
services.AddTransient(c => _testHandlerWithStateImplMock.Object);
_serviceProvider = services.BuildServiceProvider();
}
