private async Task AssertMessagePublishedAndReceivedAsync <T>(
IServiceCollection services,
IHandlerAsync <T> handler,
TaskCompletionSource <object> completionSource)
where T : Message, new()
{
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using var source = new CancellationTokenSource(Timeout);
await listener.StartAsync(source.Token);
await publisher.StartAsync(source.Token);
var message = new T();
// Act
await publisher.PublishAsync(message, source.Token);
// Assert
try
{
completionSource.Task.Wait(source.Token);
}
catch (OperationCanceledException)
{
// Ignore
}
await handler.Received(1).Handle(Arg.Is <T>((p) => p.UniqueKey() == message.UniqueKey()));
}
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Kitchen subscriber running");
_ = _bus.StartAsync(stoppingToken);
return(Task.CompletedTask);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
_logger.LogInformation("Ordering API subscriber running");
await _publisher.StartAsync(stoppingToken);
await _bus.StartAsync(stoppingToken);
}
public async Task Can_Create_Messaging_Bus_Fluently_For_A_Queue()
{
// Arrange
var completionSource = new TaskCompletionSource <object>();
var handler = Substitute.For <IHandlerAsync <SimpleMessage> >();
handler.Handle(Arg.Any <SimpleMessage>())
.Returns(true)
.AndDoes((_) => completionSource.SetResult(null));
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.WithRegions("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);
completionSource.Task.Wait(source.Token);
// Assert
await handler.Received().Handle(Arg.Any <SimpleMessage>());
}
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));
}
public async Task Can_Create_Messaging_Bus_Fluently_For_A_Topic()
{
var topicName = Guid.NewGuid().ToString();
// Arrange
var services = new ServiceCollection()
.AddLogging((p) => p.AddXUnit(OutputHelper))
.AddJustSaying(
(builder) =>
{
builder
.Client((options) =>
options.WithBasicCredentials("accessKey", "secretKey")
.WithServiceUri(TestEnvironment.SimulatorUrl))
.Messaging((options) => options.WithRegion("eu-west-1"))
.Publications((options) => options.WithTopic <TopicMessage>())
.Subscriptions((options) => options.ForTopic <TopicMessage>(cfg => cfg.WithName(topicName)));
})
.AddSingleton <IMessageStore <TopicMessage>, TestMessageStore <TopicMessage> >()
.AddJustSayingHandler <TopicMessage, MessageStoringHandler <TopicMessage> >();
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using (var source = new CancellationTokenSource(TimeSpan.FromSeconds(20)))
{
// Act
await listener.StartAsync(source.Token);
await publisher.StartAsync(source.Token);
var message = new TopicMessage();
await publisher.PublishAsync(message, source.Token);
var store = serviceProvider.GetService <IMessageStore <TopicMessage> >();
await Patiently.AssertThatAsync(OutputHelper,
() => store.Messages.Any(msg => msg.Id == message.Id));
}
}
public void Can_Create_Messaging_Bus()
{
// Arrange
var services = new ServiceCollection()
.AddLogging((p) => p.AddXUnit(OutputHelper))
.AddJustSaying("eu-west-1")
.AddJustSayingHandler <QueueMessage, QueueHandler>();
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using (var source = new CancellationTokenSource(TimeSpan.FromSeconds(20)))
{
// Act
listener.StartAsync(source.Token);
}
}
public async Task Can_Create_Messaging_Bus_Fluently_For_A_Topic()
{
// Arrange
var services = new ServiceCollection()
.AddLogging((p) => p.AddXUnit(OutputHelper))
.AddJustSaying(
(builder) =>
{
builder
.Client((options) =>
options.WithBasicCredentials("accessKey", "secretKey")
.WithServiceUri(TestEnvironment.SimulatorUrl))
.Messaging((options) => options.WithRegions("eu-west-1"))
.Publications((options) => options.WithTopic <TopicMessage>())
.Subscriptions((options) => options.ForTopic <TopicMessage>());
})
.AddJustSayingHandler <TopicMessage, TopicHandler>();
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using (var source = new CancellationTokenSource(TimeSpan.FromSeconds(20)))
{
// Act
await listener.StartAsync(source.Token);
await publisher.StartAsync(source.Token);
var message = new TopicMessage();
await publisher.PublishAsync(message, source.Token);
// Assert
while (!source.IsCancellationRequested && !TopicHandler.MessageIds.Contains(message.Id))
{
await Task.Delay(TimeSpan.FromSeconds(0.2), source.Token);
}
TopicHandler.MessageIds.ShouldContain(message.Id);
}
}
public async Task Can_Create_Messaging_Bus_With_Contributors()
{
// Arrange
var services = new ServiceCollection()
.AddLogging((p) => p.AddXUnit(OutputHelper))
.AddJustSaying()
.AddSingleton <IMessageBusConfigurationContributor, AwsContributor>()
.AddSingleton <IMessageBusConfigurationContributor, MessagingContributor>()
.AddSingleton <IMessageBusConfigurationContributor, QueueContributor>()
.AddSingleton <IMessageBusConfigurationContributor, RegionContributor>()
.AddJustSayingHandler <QueueMessage, MessageStoringHandler <QueueMessage> >()
.AddSingleton <IMessageStore <QueueMessage>, TestMessageStore <QueueMessage> >()
.AddSingleton <MyMonitor>();
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using (var source = new CancellationTokenSource(TimeSpan.FromSeconds(20)))
{
// Act
await listener.StartAsync(source.Token);
await publisher.StartAsync(source.Token);
var message = new QueueMessage();
await publisher.PublishAsync(message, source.Token);
// Assert
var messageStore = serviceProvider.GetService <IMessageStore <QueueMessage> >();
await Patiently.AssertThatAsync(OutputHelper,
() =>
{
messageStore.Messages.ShouldContain(msg =>
msg.Id.Equals(message.Id));
});
}
}
public async Task Can_Create_Messaging_Bus_With_Contributors()
{
// Arrange
var services = new ServiceCollection()
.AddLogging((p) => p.AddXUnit(OutputHelper))
.AddJustSaying()
.AddSingleton <IMessageBusConfigurationContributor, AwsContributor>()
.AddSingleton <IMessageBusConfigurationContributor, MessagingContributor>()
.AddSingleton <IMessageBusConfigurationContributor, QueueContributor>()
.AddSingleton <IMessageBusConfigurationContributor, RegionContributor>()
.AddJustSayingHandler <QueueMessage, QueueHandler>()
.AddSingleton <MyMonitor>();
IServiceProvider serviceProvider = services.BuildServiceProvider();
IMessagePublisher publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
IMessagingBus listener = serviceProvider.GetRequiredService <IMessagingBus>();
using (var source = new CancellationTokenSource(TimeSpan.FromSeconds(20)))
{
// Act
await listener.StartAsync(source.Token);
await publisher.StartAsync(source.Token);
var message = new QueueMessage();
await publisher.PublishAsync(message, source.Token);
// Assert
while (!source.IsCancellationRequested && !QueueHandler.MessageIds.Contains(message.Id))
{
await Task.Delay(TimeSpan.FromSeconds(0.2), source.Token);
}
QueueHandler.MessageIds.ShouldContain(message.Id);
}
}