public async Task ShouldProcessMessageFromQueue()
{
// Given
const string expectedMessage = "Test message";
var queueCreationOptions
= new RabbitQueueCreationOptions
{
QueueName = Guid.NewGuid().ToString(),
RetriesCount = 0,
RetryInitialTimeout = TimeSpan.Zero,
ExceptionHandlingPolicy = ExceptionHandlingPolicy.None
};
// When
var messageHandler = new CatchingMessageHandler <string>();
using (var queue = _queuesFactory.Create <string>(queueCreationOptions))
{
await queue.SendMessageAsync(expectedMessage);
await queue.SubscribeAsync(messageHandler);
await Task.Delay(_completionTimeout);
}
// Then
_mockLogger.VerifyNoErrorsWasLogged();
Assert.Equal(expectedMessage, messageHandler.Messages.Single());
Assert.Equal(0UL, GetQueueMessagesCount(queueCreationOptions.QueueName));
}
public async Task ShouldPushBadMessageIntoErrorsQueue()
{
// Given
const string expectedMessage = "Test message";
var queueCreationOptions
= new RabbitQueueCreationOptions
{
QueueName = Guid.NewGuid().ToString(),
RetriesCount = 0,
RetryInitialTimeout = TimeSpan.FromMilliseconds(100),
ExceptionHandlingPolicy = ExceptionHandlingPolicy.SendToErrorsQueue
};
var errorQueueCreationOptions
= new RabbitQueueCreationOptions
{
QueueName = $"{queueCreationOptions.QueueName}.Errors",
RetriesCount = 0,
RetryInitialTimeout = TimeSpan.FromMilliseconds(100),
ExceptionHandlingPolicy = ExceptionHandlingPolicy.None
};
// When
var messageHandler = new ThrowingExceptionMessageHandler();
using (var queue = _queuesFactory.Create <string>(queueCreationOptions))
{
await queue.SubscribeAsync(messageHandler);
await queue.SendMessageAsync(expectedMessage);
await Task.Delay(_completionTimeout);
}
var errorMessagesHandler = new CatchingMessageHandler <ErrorInformation>();
using (var errorsQueue = _queuesFactory.Create <ErrorInformation>(errorQueueCreationOptions))
{
await errorsQueue.SubscribeAsync(errorMessagesHandler);
await Task.Delay(_completionTimeout);
}
// Then
_mockLogger.VerifyErrorWasLogged <InvalidOperationException>();
Assert.Empty(messageHandler.Messages);
Assert.Equal(0UL, GetQueueMessagesCount(queueCreationOptions.QueueName));
Assert.Contains(expectedMessage, errorMessagesHandler.Messages.Single().MessageContent);
Assert.Equal(0UL, GetQueueMessagesCount(errorQueueCreationOptions.QueueName));
}
public MessagesProcessingServiceTests()
{
_mockLogger = MockLoggerExtensions.CreateMockLogger();
_messageHandler = new CatchingMessageHandler <string>();
_host = new HostBuilder()
.UseEnvironment(EnvironmentName.Development)
.UseContentRoot(Path.GetDirectoryName(GetType().GetTypeInfo().Assembly.Location))
.ConfigureAppConfiguration(
(context, builder) =>
{
var hostingEnvironment = context.HostingEnvironment;
builder
.AddDefaultConfigs(hostingEnvironment.ContentRootPath, hostingEnvironment.EnvironmentName)
.AddCiDependentSettings(hostingEnvironment.EnvironmentName);
}
)
.ConfigureServices(
(context, collection) =>
collection
.AddRabbitMqSupport()
.AddNotificationsProcessingService(context.Configuration.GetSection("NotificationsProcessingServiceOptions"))
.Configure <TypedRabbitQueuesFactoryOptions>(context.Configuration.GetSection("QueuesFactoryOptions"))
)
.UseServiceProviderFactory(new AutofacServiceProviderFactory())
.ConfigureContainer <ContainerBuilder>(
builder =>
{
builder.RegisterInstance(_messageHandler).As <IMessageHandler <string> >();
}
)
.ConfigureLogging(
builder =>
{
var mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(x => x.CreateLogger(It.IsAny <string>())).Returns(_mockLogger.Object);
builder.Services.Replace(ServiceDescriptor.Singleton(mockLoggerFactory.Object));
})
.Build();
_completionTimeout = _host.Services.GetService <IConfiguration>().GetSection("CompletionTimeout").Get <TimeSpan>();
}
