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