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