public async Task TheExtensionWorks()
{
var activator = new BuiltinHandlerActivator();
activator.Register(typeof(SomeHandler));
using (var scope = new FakeMessageContextScope())
{
var stringHandlers = await activator.GetHandlers("hej", scope.TransactionContext);
Assert.That(stringHandlers.Count(), Is.EqualTo(1));
}
}
public async Task CanRegisterHandler()
{
var handlerActivator = _activationCtx.CreateActivator(handlers => handlers.Register <SomeStringHandler>());
using (var scope = new FakeMessageContextScope())
{
var handlers = (await handlerActivator.GetHandlers("hej", scope.TransactionContext)).ToList();
const string message = "Expected one single SomeStringHandler instance to be returned, because that's what was registered";
Assert.That(handlers.Count, Is.EqualTo(1), message);
Assert.That(handlers[0], Is.TypeOf <SomeStringHandler>(), message);
}
}
public async Task ResolvesHandlersPolymorphically()
{
var handlerActivator = _activationCtx.CreateActivator(handlers => handlers.Register <BaseMessageHandler>());
using (var scope = new FakeMessageContextScope())
{
var handlers = (await handlerActivator.GetHandlers(new DerivedMessage(), scope.TransactionContext)).ToList();
const string message = @"Expected that a single BaseMessageHandler instance would have been returned because it implements IHandleMessages<BaseMessage> and we resolved handlers for a DerivedMessage";
Assert.That(handlers.Count, Is.EqualTo(1), message);
Assert.That(handlers[0], Is.TypeOf <BaseMessageHandler>(), message);
}
}
public async Task ResolvesHandlersPolymorphically_ConcreteCaseWithFailedMessage()
{
var handlerActivator = _activationCtx.CreateActivator(handlers => handlers.Register <SecondLevelDeliveryHandler>());
using (var scope = new FakeMessageContextScope())
{
var headers = new Dictionary <string, string>();
var body = new FailedMessage();
var wrapper = new FailedMessageWrapper <FailedMessage>(headers, body, "bla bla", new Exception[0]);
var handlers = (await handlerActivator.GetHandlers(wrapper, scope.TransactionContext)).ToList();
const string message = @"Expected that a single SecondLevelDeliveryHandler instance would have been returned because it implements IHandleMessages<IFailed<FailedMessage>> and we resolved handlers for a FailedMessageWrapper<FailedMessage>";
Assert.That(handlers.Count, Is.EqualTo(1), message);
Assert.That(handlers[0], Is.TypeOf <SecondLevelDeliveryHandler>(), message);
}
}
public void DoesNotDoubleResolveBecauseOfLazyEnumerableEvaluation()
{
var handlerActivator = _activationCtx.CreateActivator(handlers => handlers.Register <SomeHandler>());
using (var scope = new FakeMessageContextScope())
{
var handlers = handlerActivator.GetHandlers("hej", scope.TransactionContext).Result.ToList();
//context.Complete().Wait();
}
var createdInstances = SomeHandler.CreatedInstances.ToList();
Assert.That(createdInstances, Is.EqualTo(new[] { 0 }), "Expected that one single instance (with # 0) would have been created");
var disposedInstances = SomeHandler.DisposedInstances.ToList();
Assert.That(disposedInstances, Is.EqualTo(new[] { 0 }), "Expected that one single instance (with # 0) would have been disposed");
}
public async Task ResolvesHandlersPolymorphically_MultipleHandlers()
{
var handlerActivator = _activationCtx.CreateActivator(handlers => handlers
.Register <BaseMessageHandler>()
.Register <DerivedMessageHandler>());
using (var scope = new FakeMessageContextScope())
{
var handlers = (await handlerActivator.GetHandlers(new DerivedMessage(), scope.TransactionContext))
.OrderBy(h => h.GetType().Name)
.ToList();
const string message = @"Expected two instances to be returned when resolving handlers for DerivedMessage:
BaseMessageHandler (because it implements IHandleMessages<BaseMessage>), and
DerivedMessageHandler (because it implements IHandleMessages<DerivedMessage>)";
Assert.That(handlers.Count, Is.EqualTo(2), message);
Assert.That(handlers[0], Is.TypeOf <BaseMessageHandler>(), message);
Assert.That(handlers[1], Is.TypeOf <DerivedMessageHandler>(), message);
}
}
public async Task CanGetFailedMessageHandler()
{
var headers = new Dictionary <string, string> {
{ Headers.MessageId, Guid.NewGuid().ToString() }
};
var body = new SomeMessage();
var wrapper = new FailedMessageWrapper <SomeMessage>(
headers: headers,
message: body,
errorDescription: "something went bad",
exceptions: new[] { new Exception("oh noes!") }
);
var handlerActivator = _activationCtx.CreateActivator(r => r.Register <SomeMessageHandler>());
Console.WriteLine(@"
Resolving handlers for message created like this:
var wrapper = new FailedMessageWrapper<SomeMessage>(
headers: headers,
message: body,
errorDescription: ""something went bad"",
exceptions: new[] {new Exception(""oh noes!"")}
);
(this is a FailedMessageWrapper<>, which is the wrapper that will be
dispatched when 2nd level retries are enabled, and the initial message
has failed too many times)
");
using (var scope = new FakeMessageContextScope())
{
var handlers = (await handlerActivator.GetHandlers(wrapper, scope.TransactionContext)).ToList();
Assert.That(handlers.Count, Is.EqualTo(1), "Expected one single handler instance of type SomeMessageHandler");
Assert.That(handlers.First(), Is.TypeOf <SomeMessageHandler>());
}
}
