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 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 void throws_exception_when_handler_does_NOT_implement_expected_interface()
{
var invalidHandlerInstanceType = typeof(object);
var builder = new MessageRegistrationBuilder().WithHandlerInstanceType(invalidHandlerInstanceType);
Assert.Throws <MessageRegistrationException>(() => builder.Build());
}
public void returns_expected_message_type()
{
var expectedMessageType = "foo";
var sut = new MessageRegistrationBuilder()
.WithMessageType(expectedMessageType)
.Build();
Assert.Equal(expectedMessageType, sut.MessageType);
}
public void returns_expected_message_topic()
{
var expectedTopic = "foo";
var sut = new MessageRegistrationBuilder()
.WithTopic(expectedTopic)
.Build();
Assert.Equal(expectedTopic, sut.Topic);
}
public void throws_exception_when_handler_closes_different_message_type_than_what_its_registered_with()
{
var handlerInstanceTypeStub = typeof(IMessageHandler <object>);
var messageInstanceTypeStub = typeof(FooMessage);
var builder = new MessageRegistrationBuilder()
.WithHandlerInstanceType(handlerInstanceTypeStub)
.WithMessageInstanceType(messageInstanceTypeStub);
Assert.Throws <MessageRegistrationException>(() => builder.Build());
}
public async Task handler_exceptions_are_thrown_as_expected()
{
var transportMessageDummy = new TransportLevelMessageBuilder().Build();
var registrationDummy = new MessageRegistrationBuilder().Build();
var sut = new LocalMessageDispatcherBuilder()
.WithMessageHandlerRegistry(new MessageHandlerRegistryStub(registrationDummy))
.WithHandlerUnitOfWorkFactory(new DefaultUnitOfWorkFactory(new TypeResolverStub(new ErroneusHandler())))
.Build();
await Assert.ThrowsAsync <ExpectedException>(() => sut.Dispatch(transportMessageDummy));
}
public async Task throws_expected_exception_when_dispatching_and_unable_to_resolve_handler_instance()
{
var transportMessageStub = new TransportLevelMessageBuilder().Build();
var messageRegistrationStub = new MessageRegistrationBuilder().Build();
var sut = new LocalMessageDispatcherBuilder()
.WithMessageHandlerRegistry(new MessageHandlerRegistryStub(messageRegistrationStub))
.WithHandlerUnitOfWorkFactory(new HandlerUnitOfWorkFactoryStub(null))
.Build();
await Assert.ThrowsAsync <UnableToResolveUnitOfWorkForHandlerException>(() => sut.Dispatch(transportMessageStub));
}
public void returns_expected_message_instance_type()
{
var handlerInstanceTypeStub = typeof(FooHandler);
var expectedInstanceMessageType = typeof(FooMessage);
var sut = new MessageRegistrationBuilder()
.WithHandlerInstanceType(handlerInstanceTypeStub)
.WithMessageInstanceType(expectedInstanceMessageType)
.Build();
Assert.Equal(expectedInstanceMessageType, sut.MessageInstanceType);
}
public void returns_expected_registrations_when_registering_single_handler()
{
var sut = new MessageHandlerRegistry();
var expected = new MessageRegistrationBuilder().Build();
var result = sut.Register(
handlerInstanceType: expected.HandlerInstanceType,
messageInstanceType: expected.MessageInstanceType,
topic: expected.Topic,
messageType: expected.MessageType
);
Assert.Equal(expected, result, new MessageRegistrationComparer());
}
public async Task handler_exceptions_are_thrown_as_expected()
{
var transportMessageDummy = new TransportLevelMessageBuilder().WithType("foo").Build();
var registrationDummy = new MessageRegistrationBuilder().WithMessageType("foo").Build();
var registry = new MessageHandlerRegistry();
registry.Register(registrationDummy);
var sut = new LocalMessageDispatcherBuilder()
.WithMessageHandlerRegistry(registry)
.WithHandlerUnitOfWork(new UnitOfWorkStub(new ErroneusHandler()))
.Build();
await Assert.ThrowsAsync <ExpectedException>(() => sut.Dispatch(transportMessageDummy));
}
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 handler_is_invoked_as_expected_when_dispatching()
{
var mock = new Mock <IMessageHandler <object> >();
var transportMessageDummy = new TransportLevelMessageBuilder().Build();
var registrationDummy = new MessageRegistrationBuilder().Build();
var typeResolverStub = new TypeResolverStub(mock.Object);
var sut = new LocalMessageDispatcherBuilder()
.WithMessageHandlerRegistry(new MessageHandlerRegistryStub(registrationDummy))
.WithHandlerUnitOfWorkFactory(new DefaultUnitOfWorkFactory(typeResolverStub))
.Build();
await sut.Dispatch(transportMessageDummy);
mock.Verify(x => x.Handle(It.IsAny <object>()), Times.Once);
}
public async Task handler_is_invoked_as_expected_when_dispatching()
{
var mock = new Mock <IMessageHandler <object> >();
var transportMessageDummy = new TransportLevelMessageBuilder().WithType("foo").Build();
var registrationDummy = new MessageRegistrationBuilder().WithMessageType("foo").Build();
var registry = new MessageHandlerRegistry();
registry.Register(registrationDummy);
var sut = new LocalMessageDispatcherBuilder()
.WithMessageHandlerRegistry(registry)
.WithHandlerUnitOfWork(new UnitOfWorkStub(mock.Object))
.Build();
await sut.Dispatch(transportMessageDummy);
mock.Verify(x => x.Handle(It.IsAny <object>(), It.IsAny <MessageHandlerContext>()), Times.Once);
}
public async Task invokes_expected_handler_when_consuming()
{
var handlerMock = new Mock <IMessageHandler <FooMessage> >();
var handlerStub = handlerMock.Object;
var messageRegistrationStub = new MessageRegistrationBuilder()
.WithHandlerInstanceType(handlerStub.GetType())
.WithMessageInstanceType(typeof(FooMessage))
.WithMessageType("foo")
.Build();
var sut = new ConsumerBuilder()
.WithUnitOfWorkFactory(type => new UnitOfWorkStub(handlerStub))
.WithMessageRegistrations(messageRegistrationStub)
.Build();
await sut.ConsumeSingle(CancellationToken.None);
handlerMock.Verify(x => x.Handle(It.IsAny <FooMessage>()), Times.Once);
}
