public void ThrowExceptionIfNoHandlersRegistered() { var builder = new ContainerBuilder(); builder.RegisterType<SecondTestCommandHandler>().As<ICommandHandler<SecondTestCommand>>(); container = builder.Build(); sut = new ContainerCommandHandlerResolver(container); sut.ResolveCommandHandler<ICommandHandler<TestCommand>>(); }
public void OneCommandHandlerIsResolved() { var builder = new ContainerBuilder(); builder.RegisterType<TestCommandHandler>().As<ICommandHandler<TestCommand>>(); builder.RegisterType<SecondTestCommandHandler>().As<ICommandHandler<SecondTestCommand>>(); container = builder.Build(); sut = new ContainerCommandHandlerResolver(container); ICommandHandler<TestCommand> commandHandler = sut.ResolveCommandHandler<ICommandHandler<TestCommand>>(); Assert.IsInstanceOfType(commandHandler, typeof(TestCommandHandler)); }
public async Task Should_Invoke_Registered_Command_Handler_With_Composite_Resolver() { var commandHandler = new TestCommandHandler(_outputHelper); var container = new Container(); container.Register <ICommandHandler <DoSomethingCommand> >(() => commandHandler, Lifestyle.Singleton); container.Register <ICommandAsyncHandler <DoSomethingWithCancellationCommand> >(() => commandHandler, Lifestyle.Singleton); var containerAdapter = new SimpleInjectorContainerAdapter(container); var containerAsyncHandlerResolver = new ContainerCommandAsyncHandlerResolver(containerAdapter); var containerHandlerResolver = new ContainerCommandHandlerResolver(containerAdapter); Func <Exception, bool> exceptionHandler = (ex) => { var exception = ex as NoCommandHandlerResolvedException; if (exception != null) { _outputHelper.WriteLine($"Ignoring encountered exception while trying to resolve command handler for {exception.CommandType.Name}..."); // Notify as handled if no command handler is resolved from other resolvers. return(true); } return(false); }; var compositeResolver = new CompositeCommandHandlerResolver(new List <ICommandHandlerResolver>() { containerAsyncHandlerResolver, containerHandlerResolver }, exceptionHandler); // Pass in an exception handler. var dispatcher = new CommandDispatcher(compositeResolver); // Composite resolver await dispatcher.DispatchAsync(new DoSomethingCommand()); await dispatcher.DispatchAsync(new DoSomethingWithCancellationCommand()); Assert.Equal(2, commandHandler.HandledCommands.Count); Assert.Contains(commandHandler.HandledCommands, c => c is DoSomethingCommand); Assert.Contains(commandHandler.HandledCommands, c => c is DoSomethingWithCancellationCommand); }
public void Should_Register_All_Command_Handlers() { var container = new Container(); container.Register <ICommandHandler <DoSomethingCommand> >(() => new TestCommandHandler(_testOutputHelper), Lifestyle.Singleton); var containerAdapter = new SimpleInjectorContainerAdapter(container); var resolver = new ContainerCommandHandlerResolver(containerAdapter); CommandHandlerDelegate commandHandlerDelegate = resolver.ResolveCommandHandler <DoSomethingCommand>(); // Delegate should invoke the actual command handler - TestCommandHandler. commandHandlerDelegate.Invoke(new DoSomethingCommand()); // Get instance from container to see if it was invoked. var registeredCommandHandler = (TestCommandHandler)container.GetInstance <ICommandHandler <DoSomethingCommand> >(); Assert.Equal(1, registeredCommandHandler.HandledCommands.Count); Assert.Contains(registeredCommandHandler.HandledCommands, c => c is DoSomethingCommand); }
public void ShouldResolveCommandHandlerFromCompositeResolver() { var commandHandler = new TestCommandHandler(_outputHelper); var container = new Container(); container.RegisterSingleton <ICommandHandler <TestCommand> >(commandHandler); container.RegisterSingleton <ICommandAsyncHandler <CancellableTestCommand> >(commandHandler); // Exception handler will log and ignore exception. Func <Exception, bool> exceptionHandler = (ex) => { if (ex != null) { _outputHelper.WriteLine($"Ignoring encountered exception while trying to resolve command handler: {ex.Message}"); // Notify as handled if no command handler is resolved from other resolvers. return(true); } return(false); }; var containerAdapter = new SimpleInjectorContainerAdapter(container); var containerAsyncHandlerResolver = new ContainerCommandAsyncHandlerResolver(containerAdapter, exceptionHandler); var containerHandlerResolver = new ContainerCommandHandlerResolver(containerAdapter, exceptionHandler); CompositeMessageHandlerResolver compositeResolver = CompositeMessageHandlerResolver.Compose( containerAsyncHandlerResolver, containerHandlerResolver); MessageHandlerDelegate testCommandHandlerDelegate = compositeResolver.ResolveMessageHandler(typeof(TestCommand)); MessageHandlerDelegate cancellableTestCommandHandlerDelegate = compositeResolver.ResolveMessageHandler(typeof(CancellableTestCommand)); testCommandHandlerDelegate?.Invoke(new TestCommand()); cancellableTestCommandHandlerDelegate?.Invoke(new CancellableTestCommand()); commandHandler.HandledCommands.Should().HaveCount(2); commandHandler.HasHandledCommand <TestCommand>().Should().BeTrue(); commandHandler.HasHandledCommand <CancellableTestCommand>().Should().BeTrue(); }