public void ShouldThrowWhenCancelled()
{
// Given
IMessageHandlerResolver resolver = CreateSingleMessageHandlerResolver(registration =>
{
registration.Register <TestMessage>((message, cancellationToken) =>
{
return(Task.Delay(TimeSpan.FromSeconds(5), cancellationToken));
});
});
MessageDelegator messageDelegator = CreateMessageDelegator(resolver);
Func <Task> action = async() =>
{
// Cancels after 1 second.
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1)))
{
// When
await messageDelegator.SendAsync <TestMessage>(new TestMessage(), cts.Token);
}
};
// Then
action.ShouldThrow <OperationCanceledException>();
}
public void ShouldThrowWhenNullIsProvided()
{
// Given
IMessageHandlerResolver resolver = CreateSingleMessageHandlerResolver();
MessageDelegator messageDelegator = CreateMessageDelegator(resolver);
Func <Task> action = () =>
{
// When
return(messageDelegator.SendAsync <TestMessage>(null));
};
// Then
action.ShouldThrow <ArgumentNullException>();
}
public void ShouldPropagateExceptionFromHandler()
{
// Given
IMessageHandlerResolver resolver = CreateSingleMessageHandlerResolver(registration =>
{
registration.Register <TestMessage>((message, cancellationToken) =>
{
return(Task.FromException(new Exception("This exception is expected.")));
});
});
MessageDelegator messageDelegator = CreateMessageDelegator(resolver);
Func <Task> action = () =>
{
// When
return(messageDelegator.SendAsync <TestMessage>(new TestMessage()));
};
// Then
action.ShouldThrow <Exception>();
}
public async Task ShouldSendMessageToASingleMessageHandler()
{
// Given
bool messageHandlerWasInvoked = false;
IMessageHandlerResolver resolver = CreateSingleMessageHandlerResolver(registration =>
{
registration.Register <TestMessage>((message, ct) =>
{
messageHandlerWasInvoked = true;
return(Task.CompletedTask);
});
});
MessageDelegator messageDelegator = CreateMessageDelegator(resolver);
// When
await messageDelegator.SendAsync(new TestMessage());
// Then
messageHandlerWasInvoked.Should().BeTrue();
}
public async Task ShouldSendMessageToMultipleMessageHandlers()
{
// Given
int expectedNumberOfHandlers = 10;
int actualMessageHandlerInvocationCount = 0;
IMessageHandlerResolver resolver = CreateMultiMessageHandlerResolver(registration =>
{
// Register 10 handlers.
for (int i = 0; i < expectedNumberOfHandlers; i++)
{
registration.Register <TestMessage>((message, ct) => { actualMessageHandlerInvocationCount++; return(Task.CompletedTask); });
}
});
MessageDelegator messageDelegator = CreateMessageDelegator(resolver);
// When
await messageDelegator.SendAsync(new TestMessage());
// Then
actualMessageHandlerInvocationCount.Should().Be(expectedNumberOfHandlers);
}
