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