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>()); } }