public async Task WhenMessageIsLockedByAnotherHandler_MessageWillBeLeftInTheQueue()
{
var messageLock = new FakeMessageLock(false);
var testResolver = new InMemoryServiceResolver(sc => sc
.AddLogging(l =>
l.AddXUnit(_outputHelper))
.AddSingleton<IMessageLockAsync>(messageLock));
var monitor = new TrackingLoggingMonitor(LoggerFactory.Create(lf => lf.AddXUnit()).CreateLogger<TrackingLoggingMonitor>());
var handler = new InspectableHandler<OrderAccepted>();
var middleware = new HandlerMiddlewareBuilder(testResolver, testResolver)
.UseExactlyOnce<OrderAccepted>(nameof(InspectableHandler<OrderAccepted>),
TimeSpan.FromSeconds(1))
.UseHandler(ctx => handler)
.Build();
var context = TestHandleContexts.From<OrderAccepted>();
var result = await middleware.RunAsync(context, null, CancellationToken.None);
handler.ReceivedMessages.ShouldBeEmpty();
result.ShouldBeFalse();
}
public WhenSqsIsSlow(ITestOutputHelper testOutputHelper)
{
var loggerFactory = testOutputHelper.ToLoggerFactory();
MiddlewareBase <ReceiveMessagesContext, IList <Message> > sqsMiddleware =
new DelegateMiddleware <ReceiveMessagesContext, IList <Message> >();
var messages = new List <Message> {
new TestMessage()
};
var queue = new FakeSqsQueue(async ct =>
{
await Task.Delay(100);
Interlocked.Increment(ref _callCount);
return(messages);
});
var monitor = new TrackingLoggingMonitor(
loggerFactory.CreateLogger <TrackingLoggingMonitor>());
_messageReceiveBuffer = new MessageReceiveBuffer(
10,
10,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1),
queue,
sqsMiddleware,
monitor,
loggerFactory.CreateLogger <IMessageReceiveBuffer>());
}
public WhenThereAreNoSubscribers(ITestOutputHelper testOutputHelper)
{
_outputHelper = testOutputHelper;
var loggerFactory = testOutputHelper.ToLoggerFactory();
MiddlewareBase <ReceiveMessagesContext, IList <Message> > sqsMiddleware =
new DelegateMiddleware <ReceiveMessagesContext, IList <Message> >();
var messages = new List <Message> {
new TestMessage()
};
var queue = new FakeSqsQueue(ct =>
{
Interlocked.Increment(ref _callCount);
return(Task.FromResult(messages.AsEnumerable()));
});
var monitor = new TrackingLoggingMonitor(
loggerFactory.CreateLogger <TrackingLoggingMonitor>());
_messageReceiveBuffer = new MessageReceiveBuffer(
10,
10,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1),
queue,
sqsMiddleware,
monitor,
loggerFactory.CreateLogger <IMessageReceiveBuffer>());
}
public WhenDispatchingMessage(ITestOutputHelper outputHelper)
{
_outputHelper = outputHelper;
_loggerFactory = TestLoggerFactory.Create(lb => lb.AddXUnit(outputHelper));
_messageMonitor = new TrackingLoggingMonitor(_loggerFactory.CreateLogger <TrackingLoggingMonitor>());
_middlewareMap = new MiddlewareMap();
}
public async Task Then_The_Message_Is_Handled()
{
// Arrange
var monitor = new TrackingLoggingMonitor(NullLogger <TrackingLoggingMonitor> .Instance);
var handler = new ThrowingHandler();
var services = GivenJustSaying()
.ConfigureJustSaying((builder) => builder.Publications((options) =>
options.WithQueue <SimpleMessage>(UniqueName)))
.ConfigureJustSaying(
(builder) => builder.Subscriptions(
(options) => options.ForQueue <SimpleMessage>(
(queue) => queue.WithName(UniqueName)))
.Services(c => c.WithMessageMonitoring(() => monitor)))
.AddSingleton <IHandlerAsync <SimpleMessage> >(handler);
var message = new SimpleMessage();
await WhenAsync(
services,
async (publisher, listener, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Act
await publisher.PublishAsync(message, cancellationToken);
await handler.DoneSignal.Task;
// Assert
handler.MessageReceived.ShouldNotBeNull();
monitor.HandledErrors.Count.ShouldBe(1);
});
}
public StopwatchMiddlewareTests(ITestOutputHelper outputHelper)
{
var loggerFactory = LoggerFactory.Create(lf => lf.AddXUnit(outputHelper));
_handler = new InspectableHandler <OrderAccepted>();
_monitor = new TrackingLoggingMonitor(loggerFactory.CreateLogger <TrackingLoggingMonitor>());
var serviceResolver = new FakeServiceResolver(c =>
c.AddSingleton <IHandlerAsync <OrderAccepted> >(_handler)
.AddSingleton <IMessageMonitor>(_monitor));
_middleware = new HandlerMiddlewareBuilder(serviceResolver, serviceResolver)
.UseHandler <OrderAccepted>()
.UseStopwatch(_handler.GetType())
.Build();
}
private void GivenInternal()
{
Queues = new List <ISqsQueue>();
Handler = new InspectableHandler <SimpleMessage>();
var testResolver = new FakeServiceResolver(sc => sc
.AddLogging(l => l.AddXUnit(OutputHelper)));
Middleware = new HandlerMiddlewareBuilder(testResolver, testResolver).UseHandler(ctx => Handler).Build();
Monitor = new TrackingLoggingMonitor(LoggerFactory.CreateLogger <TrackingLoggingMonitor>());
SerializationRegister = new FakeSerializationRegister();
MiddlewareMap = new MiddlewareMap();
Given();
}
private void GivenInternal()
{
Queues = new List <ISqsQueue>();
Handler = new InspectableHandler <SimpleMessage>();
Monitor = new TrackingLoggingMonitor(LoggerFactory.CreateLogger <TrackingLoggingMonitor>());
SerializationRegister = new FakeSerializationRegister();
MiddlewareMap = new MiddlewareMap();
CompletionMiddleware = new AwaitableMiddleware(OutputHelper);
var testResolver = new InMemoryServiceResolver(OutputHelper, Monitor,
sc => sc.AddSingleton <IHandlerAsync <SimpleMessage> >(Handler));
Middleware = new HandlerMiddlewareBuilder(testResolver, testResolver)
.Use(CompletionMiddleware)
.UseDefaults <SimpleMessage>(typeof(InspectableHandler <SimpleMessage>))
.Build();
Given();
}
public async Task MonitorShouldBeCalled()
{
// Arrange
var future = new Future <SimpleMessage>();
var monitor = new TrackingLoggingMonitor(LoggerFactory.CreateLogger <TrackingLoggingMonitor>());
var services = GivenJustSaying()
.ConfigureJustSaying(
(builder) => builder.WithLoopbackQueue <SimpleMessage>(UniqueName))
.AddSingleton(future)
.AddSingleton <IMessageMonitor>(monitor)
.AddJustSayingHandler <SimpleMessage, HandlerWithMessageContext>();
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage
{
Content = content
};
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Act
await publisher.PublishAsync(message, cancellationToken);
// Assert
await future.DoneSignal;
monitor.HandledTimes.ShouldHaveSingleItem().ShouldBeGreaterThan(TimeSpan.Zero);
monitor.PublishMessageTimes.ShouldHaveSingleItem().ShouldBeGreaterThan(TimeSpan.Zero);
monitor.ReceiveMessageTimes.ShouldHaveSingleItem().duration
.ShouldBeGreaterThan(TimeSpan.Zero);
});
}
public WhenSqsIsSlow(ITestOutputHelper testOutputHelper)
{
var loggerFactory = testOutputHelper.ToLoggerFactory();
MiddlewareBase <ReceiveMessagesContext, IList <Message> > sqsMiddleware =
new DelegateMiddleware <ReceiveMessagesContext, IList <Message> >();
var sqsClient = Substitute.For <IAmazonSQS>();
var queue = Substitute.For <ISqsQueue>();
queue.Uri.Returns(new Uri("http://test.com"));
queue.Client.Returns(sqsClient);
var monitor = new TrackingLoggingMonitor(
loggerFactory.CreateLogger <TrackingLoggingMonitor>());
sqsClient.ReceiveMessageAsync(Arg.Any <ReceiveMessageRequest>(), Arg.Any <CancellationToken>())
.Returns(_ =>
{
Thread.Sleep(TimeSpan.FromMilliseconds(100));
Interlocked.Increment(ref _callCount);
var messages = new List <Message> {
new TestMessage()
};
return(new ReceiveMessageResponse {
Messages = messages
});
});
_messageReceiveBuffer = new MessageReceiveBuffer(
10,
10,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1),
queue,
sqsMiddleware,
monitor,
loggerFactory.CreateLogger <IMessageReceiveBuffer>());
}
protected virtual void Given()
{
Config = Substitute.For <IMessagingConfig>();
Monitor = new TrackingLoggingMonitor(LoggerFactory.CreateLogger <TrackingLoggingMonitor>());
}
