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 async Task MiddlewareBuilder_WithoutDefaults_ShouldExecute()
{
var callRecord = new List <string>();
void Before(string id) => callRecord.Add($"Before_{id}");
void After(string id) => callRecord.Add($"After_{id}");
var outer = new TrackingMiddleware("outer", Before, After);
var inner = new TrackingMiddleware("inner", Before, After);
var handler = new InspectableHandler <SimpleMessage>();
var middlewareBuilder = new HandlerMiddlewareBuilder(_resolver, _resolver)
.Configure(hmb =>
hmb.Use(outer)
.Use(inner)
.UseHandler(ctx => handler));
var handlerMiddleware = middlewareBuilder.Build();
var context = TestHandleContexts.From <SimpleMessage>();
await handlerMiddleware.RunAsync(context, null, CancellationToken.None);
callRecord.ShouldBe(new[] { "Before_outer", "Before_inner", "After_inner", "After_outer" });
handler.ReceivedMessages.ShouldHaveSingleItem();
}
public async Task Then_Both_Handlers_Receive_Messages()
{
// Arrange
var genericHandler = new InspectableHandler <GenericMessage <SimpleMessage> >();
var nonGenericHandler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying((builder) => builder.WithLoopbackTopic <GenericMessage <SimpleMessage> >($"{UniqueName}-generic"))
.ConfigureJustSaying((builder) => builder.WithLoopbackTopic <SimpleMessage>($"{UniqueName}-nongeneric"))
.AddSingleton <IHandlerAsync <GenericMessage <SimpleMessage> > >(genericHandler)
.AddSingleton <IHandlerAsync <SimpleMessage> >(nonGenericHandler);
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Act
await publisher.PublishAsync(new GenericMessage <SimpleMessage>(), cancellationToken);
await publisher.PublishAsync(new SimpleMessage(), cancellationToken);
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
genericHandler.ReceivedMessages.ShouldHaveSingleItem();
nonGenericHandler.ReceivedMessages.ShouldHaveSingleItem();
});
});
}
public async Task Then_The_Defaults_Are_The_Defaults_For_Sure()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying((builder) =>
builder.WithLoopbackTopic <SimpleMessage>(UniqueName))
.AddJustSayingHandlers(new[] { handler });
string json = "";
await WhenAsync(
services,
(_, listener, _, _) =>
{
dynamic interrogation = listener.Interrogate();
dynamic middlewares = interrogation.Data.Middleware;
json = JsonConvert.SerializeObject(middlewares, Formatting.Indented)
.Replace(UniqueName, "TestQueueName");
return(Task.CompletedTask);
});
json.ShouldMatchApproved(c => c.SubFolder("Approvals"));
}
public async Task Then_The_Handler_Only_Receives_The_Message_Once()
{
// Arrange
var messageLock = new MessageLockStore();
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.AddSingleton <IMessageLockAsync>(messageLock)
.ConfigureJustSaying((builder) =>
builder.WithLoopbackTopic <SimpleMessage>(UniqueName,
c =>
c.WithReadConfiguration(rc =>
rc.WithMiddlewareConfiguration(m =>
m.UseExactlyOnce <SimpleMessage>("simple-message-lock")))))
.AddJustSayingHandlers(new[] { handler });
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
var message = new SimpleMessage();
// Act
await publisher.PublishAsync(message, cancellationToken);
await publisher.PublishAsync(message, cancellationToken);
await Task.Delay(1.Seconds(), cancellationToken);
handler.ReceivedMessages.Where(m => m.Id.ToString() == message.UniqueKey())
.ShouldHaveSingleItem();
});
}
public async Task Then_Both_Handlers_Receive_The_Message()
{
var messageLock = new MessageLockStore();
var handler1 = new InspectableHandler <SimpleMessage>();
var handler2 = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.AddSingleton <IMessageLockAsync>(messageLock)
.ConfigureJustSaying((builder) =>
builder.WithLoopbackTopic <SimpleMessage>(UniqueName,
t => t.WithReadConfiguration(rc =>
rc.WithMiddlewareConfiguration(m =>
m.UseExactlyOnce <SimpleMessage>("some-key")))))
.AddJustSayingHandlers(new[] { handler1, handler2 });
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
var message = new SimpleMessage();
// Act
await publisher.PublishAsync(message, cancellationToken);
await Task.Delay(1.Seconds(), cancellationToken);
// Assert
handler1.ReceivedMessages.ShouldHaveSingleItem().Id.ShouldBe(message.Id);
handler2.ReceivedMessages.ShouldHaveSingleItem().Id.ShouldBe(message.Id);
});
}
public async Task Then_The_Message_Is_Handled()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying(
(builder) => builder.WithLoopbackTopic <SimpleMessage>(UniqueName))
.AddSingleton <IMessageSerializationFactory, SystemTextJsonSerializationFactory>()
.AddSingleton <IHandlerAsync <SimpleMessage> >(handler);
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage()
{
Content = content
};
await WhenAsync(
services,
async (publisher, listener, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Act
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken);
handler.ReceivedMessages.ShouldHaveSingleItem().Content.ShouldBe(content);
});
}
public async Task Then_The_Pipeline_Should_Only_Contain_User_Specified_Middlewares()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
var testMiddleware = new InspectableMiddleware <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying((builder) =>
MessagingBusBuilderTestExtensions.WithLoopbackTopic <SimpleMessage>(builder,
UniqueName,
c => c.WithMiddlewareConfiguration(m =>
{
m.Use(testMiddleware);
m.UseHandler(_ => handler);
})))
.AddJustSayingHandlers(new[] { handler });
string json = "";
await WhenAsync(
services,
(_, listener, _, _) =>
{
dynamic middlewares = ((dynamic)listener.Interrogate().Data).Middleware;
json = JsonConvert.SerializeObject(middlewares, Formatting.Indented)
.Replace(UniqueName, "TestQueueName");
return(Task.CompletedTask);
});
json.ShouldMatchApproved(c => c.SubFolder("Approvals"));
}
public async Task HandleMessageFromQueueLogs_ShouldHaveContext(bool handlerShouldSucceed, LogLevel level, string status, string exceptionMessage)
{
var handler = new InspectableHandler <SimpleMessage>()
{
ShouldSucceed = handlerShouldSucceed,
};
if (exceptionMessage != null)
{
handler.OnHandle = msg => throw new Exception(exceptionMessage);
}
var services = GivenJustSaying(levelOverride: LogLevel.Information)
.ConfigureJustSaying(
(builder) => builder.WithLoopbackQueue <SimpleMessage>(UniqueName)
.Subscriptions(sub => sub.WithDefaults(sgb =>
sgb.WithDefaultConcurrencyLimit(10))))
.AddSingleton <IHandlerAsync <SimpleMessage> >(handler);
var sp = services.BuildServiceProvider();
var cts = new CancellationTokenSource();
var publisher = sp.GetRequiredService <IMessagePublisher>();
await publisher.StartAsync(cts.Token);
await sp.GetRequiredService <IMessagingBus>().StartAsync(cts.Token);
var message = new SimpleMessage();
await publisher.PublishAsync(message, cts.Token);
await Patiently.AssertThatAsync(() => handler.ReceivedMessages
.ShouldHaveSingleItem()
.Id.ShouldBe(message.Id));
var testLogger = sp.GetRequiredService <ITestLoggerSink>();
await Patiently.AssertThatAsync(() =>
{
var handleMessage = testLogger.LogEntries
.SingleOrDefault(le => le.OriginalFormat == "{Status} handling message with Id '{MessageId}' of type {MessageType} in {TimeToHandle}ms.");
handleMessage.ShouldNotBeNull();
handleMessage.LogLevel.ShouldBe(level);
handleMessage.Exception?.Message.ShouldBe(exceptionMessage);
var propertyMap = new Dictionary <string, object>(handleMessage.Properties);
propertyMap.ShouldContainKeyAndValue("Status", status);
propertyMap.ShouldContainKeyAndValue("MessageId", message.Id);
propertyMap.ShouldContainKeyAndValue("MessageType", message.GetType().FullName);
propertyMap.ShouldContainKey("TimeToHandle");
});
cts.Cancel();
}
public async Task CanSubscribeUsingQueueArn()
{
IAwsClientFactory clientFactory = CreateClientFactory();
var sqsClient = clientFactory.GetSqsClient(Region);
var snsClient = clientFactory.GetSnsClient(Region);
var queueResponse = await sqsClient.CreateQueueAsync(UniqueName);
var anotherUniqueName = $"{Guid.NewGuid():N}-integration-tests";
var topicResponse = await snsClient.CreateTopicAsync(anotherUniqueName);
var subscriptionArn = await snsClient.SubscribeQueueAsync(topicResponse.TopicArn, sqsClient, queueResponse.QueueUrl);
var queueArn = (await sqsClient.GetQueueAttributesAsync(queueResponse.QueueUrl, new List <string> {
SQSConstants.ATTRIBUTE_QUEUE_ARN
})).Attributes[SQSConstants.ATTRIBUTE_QUEUE_ARN];
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying(builder =>
builder
.Subscriptions(c =>
c.ForQueueArn <SimpleMessage>(queueArn))
.Publications(c =>
c.WithTopicArn <SimpleMessage>(topicResponse.TopicArn)
)
)
.AddJustSayingHandlers(new[] { handler });
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);
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
handler.ReceivedMessages.ShouldHaveSingleItem().Content.ShouldBe(content);
});
});
}
public ChannelInitializerTest()
{
_group = new DefaultEventLoopGroup(1);
_server = new ServerBootstrap()
.Group(_group)
.Channel <LocalServerChannel>()
.LocalAddress(SERVER_ADDRESS);
_client = new Bootstrap()
.Group(_group)
.Channel <LocalChannel>()
.Handler(new ChannelHandlerAdapter());
_testHandler = new InspectableHandler();
}
public async Task ThenItIsUsed()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
var accessor = new RecordingMessageContextAccessor(new MessageContextAccessor());
var subject = Guid.NewGuid().ToString();
var subjectProvider = new ConstantSubjectProvider(subject);
var services = GivenJustSaying()
.ConfigureJustSaying((builder) =>
builder.WithLoopbackTopic <SimpleMessage>(UniqueName))
.ConfigureJustSaying(builder =>
builder.Services(s => s.WithMessageContextAccessor(() => accessor)))
.ConfigureJustSaying((builder) =>
builder.Messaging(m =>
m.WithMessageSubjectProvider(subjectProvider)))
.AddSingleton <IHandlerAsync <SimpleMessage> >(handler);
var id = Guid.NewGuid();
var message = new SimpleMessage()
{
Id = id
};
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
await WhenAsync(
services,
async (publisher, listener, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Let's send an OrderPlaced, but the subject will be a GUID
// because of the custom subject provider
await publisher.PublishAsync(message, cancellationToken);
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
var receivedMessage = handler.ReceivedMessages.ShouldHaveSingleItem();
receivedMessage.Id.ShouldBe(id);
var context = accessor.ValuesWritten.ShouldHaveSingleItem();
dynamic json = JsonConvert.DeserializeObject(context.Message.Body);
string subject = json.Subject;
subject.ShouldBe(subject);
});
});
}
public async Task Add_Different_Handler_Per_Queue()
{
// Arrange
string group1 = "group1";
string group2 = "group2";
string queueName1 = "queue1";
string queueName2 = "queue2";
JustSaying.JustSayingBus bus = CreateBus();
var handler1 = new InspectableHandler <TestJustSayingMessage>();
var handler2 = new InspectableHandler <TestJustSayingMessage>();
bus.AddMessageHandler(queueName1, () => handler1);
bus.AddMessageHandler(queueName2, () => handler2);
ISqsQueue queue1 = TestQueue(bus.SerializationRegister, queueName1);
ISqsQueue queue2 = TestQueue(bus.SerializationRegister, queueName2);
bus.AddQueue(group1, queue1);
bus.AddQueue(group2, queue2);
using var cts = new CancellationTokenSource();
// Act
await bus.StartAsync(cts.Token);
await Patiently.AssertThatAsync(_outputHelper,
() =>
{
handler1.ReceivedMessages.Count.ShouldBeGreaterThan(0);
handler2.ReceivedMessages.Count.ShouldBeGreaterThan(0);
});
cts.Cancel();
await bus.Completion;
foreach (var message in handler1.ReceivedMessages)
{
message.QueueName.ShouldBe(queueName1);
}
foreach (var message in handler2.ReceivedMessages)
{
message.QueueName.ShouldBe(queueName2);
}
bus.Dispose();
}
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();
}
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();
}
public async Task Then_The_Message_Is_Handled()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying((builder) =>
builder
.Publications((options) =>
options.WithTopic <SimpleMessage>(configure => { configure.WithName("my-special-topic"); }))
.Subscriptions((options) =>
options.ForTopic <SimpleMessage>("my-special-topic",
subscriptionBuilder => { subscriptionBuilder.WithName(UniqueName); })))
.AddSingleton <IHandlerAsync <SimpleMessage> >(handler);
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage()
{
Content = content
};
string json = "";
await WhenAsync(
services,
async (publisher, listener, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
var listenerJson = JsonConvert.SerializeObject(listener.Interrogate(), Formatting.Indented);
var publisherJson = JsonConvert.SerializeObject(publisher.Interrogate(), Formatting.Indented);
await publisher.PublishAsync(message, cancellationToken);
json = string.Join($"{Environment.NewLine}{Environment.NewLine}",
listenerJson,
publisherJson)
.Replace(UniqueName, "integrationTestQueueName", StringComparison.Ordinal);
await Patiently.AssertThatAsync(OutputHelper,
() =>
handler.ReceivedMessages.Any(x => x.Content == content).ShouldBeTrue());
});
json.ShouldMatchApproved(opt => opt.SubFolder("Approvals"));
}
protected override void Given()
{
base.Given();
var handler = new InspectableHandler <SimpleMessage>();
var testResolver = new InMemoryServiceResolver(_outputHelper,
_messageMonitor,
sc => sc.AddSingleton <IHandlerAsync <SimpleMessage> >(handler));
var middleware = new HandlerMiddlewareBuilder(testResolver, testResolver)
.UseBackoff(MessageBackoffStrategy)
.UseDefaults <SimpleMessage>(handler.GetType())
.Build();
_middlewareMap.Add <OrderAccepted>(_queue.QueueName, middleware);
}
public async Task Can_Create_Messaging_Bus_Fluently_For_A_Queue()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
using var container = new Container(
(registry) =>
{
registry.For <ILoggerFactory>()
.Use(() => OutputHelper.ToLoggerFactory())
.Singleton();
registry.For <IHandlerAsync <SimpleMessage> >()
.Use(handler);
registry.AddJustSaying(
(builder) =>
{
builder.Client((options) =>
options.WithBasicCredentials("accessKey", "secretKey")
.WithServiceUri(TestEnvironment.SimulatorUrl))
.Messaging((options) => options.WithRegion("eu-west-1"))
.Publications((options) => options.WithQueue <SimpleMessage>())
.Subscriptions((options) => options.ForQueue <SimpleMessage>());
});
});
IMessagePublisher publisher = container.GetInstance <IMessagePublisher>();
IMessagingBus listener = container.GetInstance <IMessagingBus>();
var message = new SimpleMessage();
using var source = new CancellationTokenSource(TimeSpan.FromSeconds(20));
await listener.StartAsync(source.Token);
await publisher.StartAsync(source.Token);
// Act
await publisher.PublishAsync(message, source.Token);
await Patiently.AssertThatAsync(OutputHelper,
() => handler.ReceivedMessages.Any());
// Assert
handler.ReceivedMessages.ShouldContain(x => x.GetType() == typeof(SimpleMessage));
}
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 Then_The_Middlewares_Are_Called()
{
var handler = new InspectableHandler <SimpleMessage>();
var callRecord = new List <string>();
void Before(string id) => callRecord.Add($"Before_{id}");
void After(string id) => callRecord.Add($"After_{id}");
var outerMiddleware = new TrackingMiddleware("outer", Before, After);
var middleMiddleware = new TrackingMiddleware("middle", Before, After);
var innerMiddleware = new TrackingMiddleware("inner", Before, After);
var services = GivenJustSaying()
.AddSingleton(outerMiddleware)
.AddSingleton <IHandlerAsync <SimpleMessage> >(handler)
.ConfigureJustSaying(builder =>
builder.WithLoopbackTopic <SimpleMessage>(UniqueName,
topic => topic.WithReadConfiguration(rc =>
rc.WithMiddlewareConfiguration(
pipe =>
{
pipe.Use <TrackingMiddleware>(); // from DI
pipe.Use(() => middleMiddleware); // provide a Func<MiddlewareBase<HandleMessageContext, bool>
pipe.Use(innerMiddleware); // Existing instance
}))));
await WhenAsync(services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Act
await publisher.PublishAsync(new SimpleMessage(), cancellationToken);
await Patiently.AssertThatAsync(OutputHelper,
() => handler.ReceivedMessages.Any());
});
string.Join(Environment.NewLine, callRecord)
.ShouldMatchApproved(c => c.SubFolder("Approvals"));
}
public async Task CanPublishUsingQueueUrl()
{
IAwsClientFactory clientFactory = CreateClientFactory();
var sqsClient = clientFactory.GetSqsClient(Region);
var queueResponse = await sqsClient.CreateQueueAsync(UniqueName);
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.ConfigureJustSaying(builder =>
builder
.Subscriptions(c =>
c.ForQueueUrl <SimpleMessage>(queueResponse.QueueUrl))
.Publications(c =>
c.WithQueueUrl <SimpleMessage>(queueResponse.QueueUrl)
)
)
.AddJustSayingHandlers(new[] { handler });
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);
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
handler.ReceivedMessages.ShouldHaveSingleItem().Content.ShouldBe(content);
});
});
}
public async Task Then_The_Handler_Only_Receives_The_Message_Once()
{
// Arrange
var messageLock = new MessageLockStore();
var handler = new InspectableHandler <SimpleMessage>();
var services = GivenJustSaying()
.AddSingleton <IMessageLockAsync>(messageLock)
.ConfigureJustSaying((builder) =>
builder.WithLoopbackTopic <SimpleMessage>(UniqueName,
c => c.WithMiddlewareConfiguration(m =>
m.UseExactlyOnce <SimpleMessage>("lock-simple-message")
.UseDefaults <SimpleMessage>(handler.GetType()))))
.AddJustSayingHandlers(new[] { handler });
var message = new SimpleMessage();
string json = "";
await WhenAsync(
services,
async (publisher, listener, serviceProvider, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Act
await publisher.PublishAsync(message, cancellationToken);
await publisher.PublishAsync(message, cancellationToken);
dynamic middlewares = ((dynamic)listener.Interrogate().Data).Middleware;
json = JsonConvert.SerializeObject(middlewares, Formatting.Indented)
.Replace(UniqueName, "TestQueueName");
await Patiently.AssertThatAsync(() =>
{
handler.ReceivedMessages.Where(m => m.Id.ToString() == message.UniqueKey())
.ShouldHaveSingleItem();
});
});
json.ShouldMatchApproved(c => c.SubFolder("Approvals"));
}
public async Task Then_The_Message_Is_Handled()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
string masterKeyId = "alias/aws/sqs";
var services = GivenJustSaying()
.ConfigureJustSaying(
(builder) => builder.Publications((options) => options.WithQueue <SimpleMessage>(
(queue) => queue.WithWriteConfiguration(
(config) => config.WithQueueName(UniqueName).WithEncryption(masterKeyId)))))
.ConfigureJustSaying(
(builder) => builder.Subscriptions((options) => options.ForQueue <SimpleMessage>(
(queue) => queue.WithName(UniqueName).WithReadConfiguration(
(config) => config.WithEncryption(masterKeyId)))))
.AddSingleton <IHandlerAsync <SimpleMessage> >(handler);
string content = Guid.NewGuid().ToString();
var message = new SimpleMessage()
{
Content = content
};
await WhenAsync(
services,
async (publisher, listener, cancellationToken) =>
{
await listener.StartAsync(cancellationToken);
await publisher.StartAsync(cancellationToken);
// Act
await publisher.PublishAsync(message, cancellationToken);
// Assert
await Patiently.AssertThatAsync(OutputHelper,
() => handler.ReceivedMessages.Any(msg => msg.Content == content));
});
}
public async Task Then_The_Builder_Should_Put_User_Middlewares_In_The_Correct_Order()
{
// Arrange
var handler = new InspectableHandler <SimpleMessage>();
var outerMiddleware = new OuterTestMiddleware();
var innerMiddleware = new InnerTestMiddleware();
var afterMiddleware = new AfterTestMiddleware();
var services = GivenJustSaying()
.ConfigureJustSaying((builder) =>
builder.WithLoopbackTopic <SimpleMessage>(UniqueName,
c => c.WithMiddlewareConfiguration(m =>
{
m.Use(outerMiddleware);
m.Use(innerMiddleware);
m.UseDefaults <SimpleMessage>(handler.GetType());
m.Use(afterMiddleware);
})))
.AddJustSayingHandlers(new[] { handler });
string json = "";
await WhenAsync(
services,
(_, listener, _, _) =>
{
dynamic interrogation = listener.Interrogate();
dynamic middlewares = interrogation.Data.Middleware;
json = JsonConvert.SerializeObject(middlewares, Formatting.Indented)
.Replace(UniqueName, "TestQueueName");
return(Task.CompletedTask);
});
json.ShouldMatchApproved(c => c.SubFolder($"Approvals"));
}
public InspectableMiddleware()
{
Handler = new InspectableHandler <TMessage>();
}
