public async Task WithMessageRouting_WithMessageHandlerContextFilter_GoesThroughRegisteredMessageHandlers() { // Arrange var services = new ServiceCollection(); var collection = new MessageHandlerCollection(services); var spyHandler = new StubTestMessageHandler <TestMessage, TestMessageContext>(); var ignoredSameTypeHandler = new StubTestMessageHandler <TestMessage, TestMessageContext>(); var ignoredDefaultHandler = new DefaultTestMessageHandler(); var ignoredHandler = new TestMessageHandler(); collection.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(serviceProvider => ignoredDefaultHandler) .WithMessageHandler <StubTestMessageHandler <TestMessage, TestMessageContext>, TestMessage, TestMessageContext>( messageContextFilter: ctx => false, implementationFactory: serviceProvider => ignoredSameTypeHandler) .WithMessageHandler <StubTestMessageHandler <TestMessage, TestMessageContext>, TestMessage, TestMessageContext>(serviceProvider => spyHandler) .WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(serviceProvider => ignoredHandler); // Act services.AddMessageRouting(); // Assert IServiceProvider provider = services.BuildServiceProvider(); var router = provider.GetRequiredService <IMessageRouter>(); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); var context = TestMessageContext.Generate(); string json = JsonConvert.SerializeObject(new TestMessage()); await router.RouteMessageAsync(json, context, correlationInfo, CancellationToken.None); Assert.True(spyHandler.IsProcessed); Assert.False(ignoredSameTypeHandler.IsProcessed); Assert.False(ignoredDefaultHandler.IsProcessed); Assert.False(ignoredHandler.IsProcessed); }
public void WithMessageHandlerWithCustomContext_WithMessageContextFilterWithMessageBodyFilterWithImplementationFactory_UsesSerializer(bool matchesContext, bool matchesBody) { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedMessage = new TestMessage(); var expectedContext = TestMessageContext.Generate(); var expectedHandler = new TestMessageHandler(); // Act services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageContextFilter: context => { Assert.Same(expectedContext, context); return(matchesContext); }, messageBodyFilter: body => { Assert.Same(expectedMessage, body); return(matchesBody); }, implementationFactory: serviceProvider => expectedHandler); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); Assert.NotNull(handlers); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); Assert.NotSame(expectedHandler, handler); Assert.Equal(matchesContext, handler.CanProcessMessageBasedOnContext(expectedContext)); Assert.Equal(matchesBody, handler.CanProcessMessageBasedOnMessage(expectedMessage)); }
public async Task WithMessageHandlerWithCustomContext_WithMessageContextFilterMessageBodySerializerImplementationFactory_UsesSerializer(bool matches) { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedBody = $"test-message-body-{Guid.NewGuid()}"; var expectedMessage = new TestMessage(); var expectedContext = TestMessageContext.Generate(); var serializer = new TestMessageBodySerializer(expectedBody, expectedMessage); // Act services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageContextFilter: context => { Assert.Same(expectedContext, context); return(matches); }, messageBodySerializerImplementationFactory: serviceProvider => serializer); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); Assert.NotNull(handlers); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); bool actual = handler.CanProcessMessageBasedOnContext(expectedContext); Assert.Equal(matches, actual); MessageResult result = await handler.TryCustomDeserializeMessageAsync(expectedBody); Assert.NotNull(result); Assert.Same(expectedMessage, result.DeserializedMessage); }
public async Task ProcessMessageContextAsync_FuncMessageProcessor_Test() { //Arrange var message = CreateMessage(); var context = new TestMessageContext(message, _messageReceiver, _messageSender); var processor = Substitute.For <Func <Message, CancellationToken, Task> >(); processor(Arg.Any <Message>(), Arg.Any <CancellationToken>()).Returns(Task.CompletedTask); var sut = new MessageContextProcessor(processor, _failurePolicy, e => true); //Act await sut.ProcessMessageContextAsync(context, CancellationToken.None).ConfigureAwait(false); //Assert await processor.Received()(Arg.Is(message), Arg.Is(CancellationToken.None)) .ConfigureAwait(false); await _messageReceiver.Received().CompleteAsync(Arg.Is(message.SystemProperties.LockToken)).ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().ReceiveDeferredMessageAsync(Arg.Any <long>()).ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().AbandonAsync(Arg.Any <string>()).ConfigureAwait(false); _failurePolicy.DidNotReceiveWithAnyArgs().CanHandle(Arg.Any <Exception>()); await _failurePolicy.DidNotReceiveWithAnyArgs() .HandleFailureAsync(Arg.Any <MessageContext>(), Arg.Any <CancellationToken>()).ConfigureAwait(false); }
public async Task ProcessMessageContextAsync_Deferred_Success_Test() { //Arrange var message = CreateMessage(); message.Label = Constants.DeferredKey; message.CorrelationId = long.MaxValue.ToString(); var deferredMessage = CreateMessage(); _messageReceiver.ReceiveDeferredMessageAsync(Arg.Is(long.MaxValue)).Returns(deferredMessage); var context = new TestMessageContext(message, _messageReceiver, _messageSender); //Act await _sut.ProcessMessageContextAsync(context, CancellationToken.None).ConfigureAwait(false); //Assert await _messageProcessor.Received().ProcessMessageAsync(Arg.Is(deferredMessage), Arg.Is(CancellationToken.None)) .ConfigureAwait(false); await _messageReceiver.Received().CompleteAsync(Arg.Is(message.SystemProperties.LockToken)).ConfigureAwait(false); await _messageReceiver.Received().CompleteAsync(Arg.Is(deferredMessage.SystemProperties.LockToken)).ConfigureAwait(false); await _messageReceiver.Received().ReceiveDeferredMessageAsync(Arg.Is(long.MaxValue)).ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().AbandonAsync(null).ConfigureAwait(false); _failurePolicy.DidNotReceiveWithAnyArgs().CanHandle(Arg.Any <Exception>()); await _failurePolicy.DidNotReceiveWithAnyArgs() .HandleFailureAsync(Arg.Any <MessageContext>(), Arg.Any <CancellationToken>()).ConfigureAwait(false); }
public void StartUnitOfWork() { testMessageContext = new TestMessageContext(); testMessageContext.Items["AutofacLifetimeScope"] = container.BeginLifetimeScope("UnitOfWorkLifetime"); disposables.Add(TransactionContext.None()); disposables.Add(FakeMessageContext.Establish(testMessageContext)); }
public async Task ProcessMessageContextAsync_FailurePolicy_Handle_Test() { //Arrange var message = CreateMessage(); var context = new TestMessageContext(message, _messageReceiver, _messageSender); _failurePolicy.CanHandle(Arg.Any <Exception>()).Returns(true); var exception = new Exception(); _messageProcessor.ProcessMessageAsync(Arg.Any <Message>(), Arg.Any <CancellationToken>()) .Throws(exception); //Act await _sut.ProcessMessageContextAsync(context, CancellationToken.None).ConfigureAwait(false); //Assert await _messageProcessor.Received().ProcessMessageAsync(Arg.Is(message), Arg.Is(CancellationToken.None)) .ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().CompleteAsync(null).ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().AbandonAsync(null).ConfigureAwait(false); _failurePolicy.Received().CanHandle(Arg.Is(exception)); await _failurePolicy.Received().HandleFailureAsync(Arg.Is(context), Arg.Is(CancellationToken.None)) .ConfigureAwait(false); }
public async Task ProcessMessageContextAsync_Deferred_UsePlugin_Success_Test() { //Arrange var message = CreateMessage(); _messageReceiver.RegisteredPlugins.Returns( new List <ServiceBusPlugin> { new DeferredMessagePlugin(_messageReceiver) }); var context = new TestMessageContext(message, _messageReceiver, _messageSender); //Act await _sut.ProcessMessageContextAsync(context, CancellationToken.None).ConfigureAwait(false); //Assert await _messageProcessor.Received().ProcessMessageAsync(Arg.Is(message), Arg.Is(CancellationToken.None)) .ConfigureAwait(false); await _messageReceiver.Received().CompleteAsync(Arg.Is(message.SystemProperties.LockToken)).ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().ReceiveDeferredMessageAsync(Arg.Any <long>()).ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().AbandonAsync(null).ConfigureAwait(false); _failurePolicy.DidNotReceiveWithAnyArgs().CanHandle(Arg.Any <Exception>()); await _failurePolicy.DidNotReceiveWithAnyArgs() .HandleFailureAsync(Arg.Any <MessageContext>(), Arg.Any <CancellationToken>()).ConfigureAwait(false); }
public async Task CustomMessageHandler_WithContextFilter_UsesFilterDuringSelection() { // Arrange var messageId = Guid.NewGuid().ToString(); var message = new TestMessage { TestProperty = Guid.NewGuid().ToString() }; string messageJson = JsonConvert.SerializeObject(message); var context = new TestMessageContext(messageId, new Dictionary <string, object>()); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); var spyHandler1 = new TestMessageHandler(); var spyHandler2 = new TestMessageHandler(); var collection = new MessageHandlerCollection(new ServiceCollection()); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageContextFilter: ctx => ctx.MessageId == "some other ID", implementationFactory: provider => spyHandler2); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( messageContextFilter: ctx => ctx.MessageId == messageId, implementationFactory: provider => spyHandler1); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(); collection.WithMessageHandler <DefaultTestMessageHandler, TestMessage>(); IServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); var router = new TestMessageRouter(serviceProvider, _logger); // Act await router.RouteMessageAsync(messageJson, context, correlationInfo, CancellationToken.None); // Assert Assert.True(spyHandler1.IsProcessed); Assert.False(spyHandler2.IsProcessed); }
public void CustomMessageHandlerFactory_WithMessageBodyAndContextFilter_SubtractsRegistration(bool matchesBody, bool matchesContext) { // Arrange var collection = new MessageHandlerCollection(new ServiceCollection()); var spyHandler = new TestMessageHandler(); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>( (TestMessageContext messageContext) => matchesContext, (TestMessage messageBody) => matchesBody, provider => spyHandler); ServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); // Act IEnumerable <MessageHandler> messageHandlers = MessageHandler.SubtractFrom(serviceProvider, _logger); // Assert MessageHandler messageHandler = Assert.Single(messageHandlers); Assert.NotNull(messageHandler); var context = TestMessageContext.Generate(); Assert.Equal(matchesContext, messageHandler.CanProcessMessageBasedOnContext(messageContext: context)); Assert.Equal(matchesBody, messageHandler.CanProcessMessageBasedOnMessage(new TestMessage())); }
public async Task CustomMessageHandlerFactory_WithCustomContext_SubtractsRegistration() { // Arrange var spyHandler = new TestMessageHandler(); var collection = new MessageHandlerCollection(new ServiceCollection()); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(provider => spyHandler); IServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); // Act IEnumerable <MessageHandler> messageHandlers = MessageHandler.SubtractFrom(serviceProvider, _logger); // Assert MessageHandler messageHandler = Assert.Single(messageHandlers); Assert.NotNull(messageHandler); var message = new TestMessage(); var context = TestMessageContext.Generate(); var correlationInfo = new MessageCorrelationInfo("operation-id", "transaction-id"); await messageHandler.ProcessMessageAsync(message, context, correlationInfo, CancellationToken.None); Assert.True(spyHandler.IsProcessed); }
public void CustomMessageHandlerConstructor_WithContextFilterObsolete_SubtractsRegistration(bool matchesContext) { // Arrange var collection = new MessageHandlerCollection(new ServiceCollection()); collection.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>((TestMessageContext messageContext) => matchesContext); ServiceProvider serviceProvider = collection.Services.BuildServiceProvider(); // Act IEnumerable <MessageHandler> messageHandlers = MessageHandler.SubtractFrom(serviceProvider, _logger); // Assert MessageHandler messageHandler = Assert.Single(messageHandlers); Assert.NotNull(messageHandler); var context = TestMessageContext.Generate(); Assert.Equal(matchesContext, messageHandler.CanProcessMessage(messageContext: context)); }
public void WithMessageHandlerWithCustomContext_WithMessageContextFilter_UsesFilter(bool matches) { // Arrange var services = new MessageHandlerCollection(new ServiceCollection()); var expectedContext = TestMessageContext.Generate(); // Act services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(messageContextFilter: context => { Assert.Same(expectedContext, context); return(matches); }); // Assert IServiceProvider provider = services.Services.BuildServiceProvider(); IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance); MessageHandler handler = Assert.Single(handlers); Assert.NotNull(handler); bool actual = handler.CanProcessMessageBasedOnContext(expectedContext); Assert.Equal(matches, actual); }
public async Task ProcessMessageContextAsync_Failed_Complete_Test() { //Arrange var message = CreateMessage(); var context = new TestMessageContext(message, _messageReceiver, _messageSender); _messageProcessor.ProcessMessageAsync(Arg.Any <Message>(), Arg.Any <CancellationToken>()) .Throws(new InvalidOperationException()); //Act await _sut.ProcessMessageContextAsync(context, CancellationToken.None).ConfigureAwait(false); //Assert await _messageProcessor.Received().ProcessMessageAsync(Arg.Is(message), Arg.Is(CancellationToken.None)) .ConfigureAwait(false); await _messageReceiver.Received().CompleteAsync(Arg.Is(message.SystemProperties.LockToken)).ConfigureAwait(false); await _messageReceiver.DidNotReceiveWithAnyArgs().AbandonAsync(Arg.Any <string>()).ConfigureAwait(false); _failurePolicy.DidNotReceiveWithAnyArgs().CanHandle(Arg.Any <Exception>()); await _failurePolicy.DidNotReceiveWithAnyArgs() .HandleFailureAsync(Arg.Any <MessageContext>(), Arg.Any <CancellationToken>()).ConfigureAwait(false); }
public TestMessageRepository(TestMessageContext context) { this.context = context; }