public async Task expected_order_of_handler_invocation_in_unit_of_work()
{
var orderOfInvocation = new LinkedList <string>();
var dummyMessageResult = new MessageResultBuilder().WithTransportLevelMessage(new TransportLevelMessageBuilder().WithType("foo").Build()).Build();
var dummyMessageRegistration = new MessageRegistrationBuilder().WithMessageType("foo").Build();
var registry = new MessageHandlerRegistry();
registry.Register(dummyMessageRegistration);
var sut = new ConsumerBuilder()
.WithUnitOfWork(new UnitOfWorkSpy(
handlerInstance: new MessageHandlerSpy <FooMessage>(() => orderOfInvocation.AddLast("during")),
pre: () => orderOfInvocation.AddLast("before"),
post: () => orderOfInvocation.AddLast("after")
))
.WithConsumerScopeFactory(new ConsumerScopeFactoryStub(new ConsumerScopeStub(dummyMessageResult)))
.WithMessageHandlerRegistry(registry)
.Build();
await sut.ConsumeSingle(CancellationToken.None);
Assert.Equal(new[] { "before", "during", "after" }, orderOfInvocation);
}
public async Task Can_consume_message_2()
{
var dummyMessage = new DummyMessage();
var messageStub = new TransportLevelMessageBuilder()
.WithType(nameof(DummyMessage))
.WithData(dummyMessage)
.Build();
var messageResult = new MessageResultBuilder()
.WithTransportLevelMessage(messageStub)
.Build();
var services = new ServiceCollection();
services.AddScoped <Scoped>();
services.AddConsumer(options =>
{
options.WithBootstrapServers("dummyBootstrapServer");
options.WithGroupId("dummyGroupId");
options.RegisterMessageHandler <DummyMessage, DummyMessageHandler>("dummyTopic", nameof(DummyMessage));
options.WithUnitOfWork <UnitOfWork>();
options.WithTopicSubscriberScopeFactory(new TopicSubscriberScopeFactoryStub(new TopicSubscriberScopeStub(messageResult)));
});
var serviceProvider = services.BuildServiceProvider();
var consumer = serviceProvider.GetRequiredService <Consumer>();
await consumer.ConsumeSingle(CancellationToken.None);
Assert.Equal(dummyMessage, DummyMessageHandler.LastHandledMessage);
Assert.Equal(1, Scoped.Instanciated);
}
public async Task disposes_consumer_scope_when_consuming_single_message()
{
var messageResultStub = new MessageResultBuilder().WithTransportLevelMessage(new TransportLevelMessageBuilder().WithType("foo").Build()).Build();
var handlerStub = Dummy.Of <IMessageHandler <FooMessage> >();
var messageRegistrationStub = new MessageRegistrationBuilder()
.WithHandlerInstanceType(handlerStub.GetType())
.WithMessageInstanceType(typeof(FooMessage))
.WithMessageType("foo")
.Build();
var spy = new ConsumerScopeSpy(messageResultStub);
var registry = new MessageHandlerRegistry();
registry.Register(messageRegistrationStub);
var consumer = new ConsumerBuilder()
.WithConsumerScopeFactory(new ConsumerScopeFactoryStub(spy))
.WithUnitOfWork(new UnitOfWorkStub(handlerStub))
.WithMessageHandlerRegistry(registry)
.Build();
await consumer.ConsumeSingle(CancellationToken.None);
Assert.Equal(1, spy.Disposed);
}
public async Task will_not_call_commit_when_auto_commit_is_enabled()
{
var handlerStub = Dummy.Of <IMessageHandler <FooMessage> >();
var messageRegistrationStub = new MessageRegistrationBuilder()
.WithHandlerInstanceType(handlerStub.GetType())
.WithMessageInstanceType(typeof(FooMessage))
.WithMessageType("foo")
.Build();
var wasCalled = false;
var resultSpy = new MessageResultBuilder()
.WithOnCommit(() =>
{
wasCalled = true;
return(Task.CompletedTask);
})
.Build();
var topicSubscriberScopeFactoryStub = new TopicSubscriberScopeFactoryStub(new TopicSubscriberScopeStub(resultSpy));
var consumer = new ConsumerBuilder()
.WithTopicSubscriberScopeFactory(topicSubscriberScopeFactoryStub)
.WithUnitOfWorkFactory(x => new UnitOfWorkStub(handlerStub))
.WithMessageRegistrations(messageRegistrationStub)
.WithEnableAutoCommit(true)
.Build();
await consumer.ConsumeSingle(CancellationToken.None);
Assert.False(wasCalled);
}
public async Task Has_expected_number_of_creations_and_disposals_when_singleton()
{
var dummyMessage = new DummyMessage();
var messageStub = new TransportLevelMessageBuilder()
.WithType(nameof(DummyMessage))
.WithData(dummyMessage)
.Build();
var messageResult = new MessageResultBuilder()
.WithTransportLevelMessage(messageStub)
.Build();
var services = new ServiceCollection();
services.AddTransient <Repository>();
services.AddSingleton <IHostApplicationLifetime, DummyApplicationLifetime>();
services.AddTransient <DummyMessageHandler>();
services.AddLogging();
var createCount = 0;
var disposeCount = 0;
services.AddSingleton <ScopeSpy>(provider => new ScopeSpy(onCreate: () => createCount++, onDispose: () => disposeCount++));
var serviceProvider = services.BuildServiceProvider();
var consumerConfiguration = new ConsumerConfigurationBuilder()
.WithGroupId("dummy")
.WithBootstrapServers("dummy")
.RegisterMessageHandler <DummyMessage, DummyMessageHandler>("dummyTopic", nameof(DummyMessage))
.WithConsumerScopeFactory(_ => new ConsumerScopeFactoryStub(new ConsumerScopeStub(messageResult)))
.WithUnitOfWorkFactory(new ServiceProviderUnitOfWorkFactory(serviceProvider))
.Build();
var consumer = new ConsumerBuilder()
.WithMessageHandlerRegistry(consumerConfiguration.MessageHandlerRegistry)
.WithUnitOfWorkFactory(consumerConfiguration.UnitOfWorkFactory)
.WithConsumerScopeFactory(consumerConfiguration.ConsumerScopeFactory)
.WithEnableAutoCommit(consumerConfiguration.EnableAutoCommit)
.Build();
await consumer.ConsumeSingle(CancellationToken.None);
await consumer.ConsumeSingle(CancellationToken.None);
Assert.Equal(1, createCount);
Assert.Equal(0, disposeCount);
}
public async Task creates_consumer_scope_when_consuming_multiple_messages()
{
var messageResultStub = new MessageResultBuilder().WithTransportLevelMessage(new TransportLevelMessageBuilder().WithType("foo").Build()).Build();
var handlerStub = Dummy.Of <IMessageHandler <FooMessage> >();
var messageRegistrationStub = new MessageRegistrationBuilder()
.WithHandlerInstanceType(handlerStub.GetType())
.WithMessageInstanceType(typeof(FooMessage))
.WithMessageType("foo")
.Build();
using (var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(5)))
{
var loops = 0;
var subscriberScopeStub = new ConsumerScopeDecoratorWithHooks(
inner: new ConsumerScopeStub(messageResultStub),
postHook: () =>
{
loops++;
if (loops == 2)
{
cancellationTokenSource.Cancel();
}
}
);
var spy = new ConsumerScopeFactorySpy(subscriberScopeStub);
var registry = new MessageHandlerRegistry();
registry.Register(messageRegistrationStub);
var consumer = new ConsumerBuilder()
.WithConsumerScopeFactory(spy)
.WithUnitOfWork(new UnitOfWorkStub(handlerStub))
.WithMessageHandlerRegistry(registry)
.Build();
await consumer.ConsumeAll(cancellationTokenSource.Token);
Assert.Equal(2, loops);
Assert.Equal(1, spy.CreateConsumerScopeCalled);
}
}
public async Task Has_expected_number_of_creations_and_disposals_when_singleton()
{
var dummyMessage = new DummyMessage();
var messageStub = new TransportLevelMessageBuilder()
.WithType(nameof(DummyMessage))
.WithData(dummyMessage)
.Build();
var messageResult = new MessageResultBuilder()
.WithTransportLevelMessage(messageStub)
.Build();
var services = new ServiceCollection();
services.AddTransient <Repository>();
services.AddSingleton <IApplicationLifetime, DummyApplicationLifetime>();
services.AddTransient <DummyMessageHandler>();
services.AddLogging();
services.AddConsumer(options =>
{
options.WithBootstrapServers("dummyBootstrapServer");
options.WithGroupId("dummyGroupId");
options.RegisterMessageHandler <DummyMessage, DummyMessageHandler>("dummyTopic", nameof(DummyMessage));
options.WithTopicSubscriberScopeFactory(new TopicSubscriberScopeFactoryStub(new TopicSubscriberScopeStub(messageResult)));
});
services.AddSingleton <ScopeSpy>();
var serviceProvider = services.BuildServiceProvider();
var consumer = serviceProvider.GetRequiredService <Consumer>();
ScopeSpy.Reset();
await consumer.ConsumeSingle(CancellationToken.None);
await consumer.ConsumeSingle(CancellationToken.None);
Assert.Equal(1, ScopeSpy.Created);
Assert.Equal(0, ScopeSpy.Disposed);
}
public async Task Can_consume_message()
{
var dummyMessage = new DummyMessage();
var messageStub = new TransportLevelMessageBuilder()
.WithType(nameof(DummyMessage))
.WithData(dummyMessage)
.Build();
var messageResult = new MessageResultBuilder()
.WithTransportLevelMessage(messageStub)
.Build();
var services = new ServiceCollection();
services.AddLogging();
services.AddSingleton <IHostApplicationLifetime, DummyApplicationLifetime>();
services.AddConsumer(options =>
{
options.WithBootstrapServers("dummyBootstrapServer");
options.WithGroupId("dummyGroupId");
options.RegisterMessageHandler <DummyMessage, DummyMessageHandler>("dummyTopic", nameof(DummyMessage));
options.WithConsumerScopeFactory(_ => new ConsumerScopeFactoryStub(new ConsumerScopeStub(messageResult)));
});
var serviceProvider = services.BuildServiceProvider();
var consumerHostedService = serviceProvider.GetServices <IHostedService>()
.OfType <ConsumerHostedService>()
.First();
using (var cts = new CancellationTokenSource(50))
{
await consumerHostedService.ConsumeAll(cts.Token);
}
Assert.Equal(dummyMessage, DummyMessageHandler.LastHandledMessage);
}
