public static void RegisterMessageHandlers(this ContainerBuilder builder, IDictionary <string, Assembly> assemblies)
{
foreach (Type type in assemblies.Select(assembly => CommandHandlerRegistry.FindMessageHandlersFrom(assembly.Value)).SelectMany(types => types))
{
builder.RegisterType(type);
}
}
public void Can_send_event()
{
// arrange
MassTransit massTransit = null;
try
{
var container = new Container();
var handler = new TestEventHandler();
container.Register <IEventHandler <TestEvent> >(() => handler);
var eventRegistry = new EventHandlerRegistry(container);
var commandRegistry = new CommandHandlerRegistry(container);
massTransit = new MassTransit(commandRegistry, eventRegistry, container);
var eventBus = new EventBus(massTransit);
// act
eventBus.Publish(new TestEvent());
// assert
Thread.Sleep(TimeSpan.FromSeconds(2));
Assert.That(handler.NumberOfTimesRan, Is.EqualTo(1));
}
finally
{
if (massTransit != null)
{
massTransit.Dispose();
}
}
}
public void ReturnsNull_WhenAskingForUnregisteredCommandHandler()
{
var testee = new CommandHandlerRegistry();
var handler = testee.GetCommandHandler(new ValueCommand(11));
handler.Should().BeNull();
}
public void CustomMappingStrategyUsedWhenExplicitStrategyDefined()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny<Func<Type, Boolean>>())).Returns(new[] { typeof(ExplicitStrategyAggregate) });
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var handler = registry.GetHandlerFor(new FakeCommand());
Assert.NotNull(handler);
}
public void CustomMappingStrategyUsedWhenExplicitStrategyDefined()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny <Func <Type, Boolean> >())).Returns(new[] { typeof(ExplicitStrategyAggregate) });
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var handler = registry.GetHandlerFor(new FakeCommand());
Assert.NotNull(handler);
}
public void ThrowMappingExceptionIfHandlerNotFound()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny <Func <Type, Boolean> >())).Returns(new[] { typeof(AlternateImplicitStrategyAggregate) });
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var ex = Assert.Throws <MappingException>(() => registry.GetHandlerFor(new FakeCommand()));
Assert.Equal(Exceptions.CommandHandlerNotFound.FormatWith(typeof(FakeCommand)), ex.Message);
}
public void GetCommandHandlerBasedOnCommandType()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny <Func <Type, Boolean> >())).Returns(new[] { typeof(ImplicitStrategyAggregate), typeof(AlternateImplicitStrategyAggregate) });
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var handler = registry.GetHandlerFor(new FakeCommand());
Assert.Equal(typeof(ImplicitStrategyAggregate), handler.AggregateType);
}
public void CanResolveRegisteredServices()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny <Func <Type, Boolean> >())).Returns(new[] { typeof(ServicedAggregate) });
serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(new FakeService());
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var handler = registry.GetHandlerFor(new FakeCommand());
Assert.NotNull(handler);
}
public void CanGetRegisteredCommandHandler()
{
var testee = new CommandHandlerRegistry();
testee.Register(typeof(ValueCommandHandler), typeof(ValueCommand));
var handler = testee.GetCommandHandler(new ValueCommand(11));
handler.Should().BeAssignableTo <ValueCommandHandler>();
}
public void Add_Success()
{
//Arrange
_commandHandlerActivatorMock.Setup(_createExpression).
Returns(new object());
var activator = _commandHandlerActivatorMock.Object;
var registry = new CommandHandlerRegistry(activator);
var context = new CommandHandlerContext();
//Act
registry.Add(context);
//Assert
_commandHandlerActivatorMock.Verify(_createExpression);
}
public void Add_NullInput_ArgumentNullException()
{
//Arrange
var activator = _commandHandlerActivatorMock.Object;
var registry = new CommandHandlerRegistry(activator);
//Act
try
{
registry.Add(null);
//Assert
Assert.True(false, "The method was supposed to throw an ArgumentNullException.");
}
catch (ArgumentNullException ex)
{
Assert.Equal("commandHandlerContext", ex.ParamName);
}
}
public void Dispose_OnlyCalledOnce()
{
//Arrange
_commandHandlerActivatorMock.Setup(_createExpression).
Returns(new object());
_commandHandlerActivatorMock.Setup(_releaseExpression)
.Verifiable("This method should only have been called once.");
var activator = _commandHandlerActivatorMock.Object;
var registry = new CommandHandlerRegistry(activator);
var context = new CommandHandlerContext();
//Act
registry.Add(context);
registry.Dispose();
registry.Dispose();
//Assert
_commandHandlerActivatorMock.Verify(_createExpression);
_commandHandlerActivatorMock.Verify(_releaseExpression, Times.Once());
}
public static IServiceCollection AddCommandProcessor(this IServiceCollection services, Action <ICommandHandlerRegistry> action)
{
if (action == null)
{
throw new ArgumentNullException(nameof(action));
}
var queryHandlerRegistry = new CommandHandlerRegistry();
action(queryHandlerRegistry);
foreach (var registeredHandler in queryHandlerRegistry.RegisteredHandlers)
{
services.AddScoped(registeredHandler);
}
services.AddSingleton <ICommandHandlerRegistry>(queryHandlerRegistry);
services.AddHostedService <InternalCommandProcessor>();
return(services);
}
public void RegisteredServiceOnlyResolvedOncePerHandler()
{
var aggregateId = GuidStrategy.NewGuid();
typeLocator.Setup(mock => mock.GetTypes(It.IsAny <Func <Type, Boolean> >())).Returns(new[] { typeof(ServicedAggregate) });
aggregateStore.Setup(mock => mock.Get(typeof(ServicedAggregate), aggregateId)).Returns(new ServicedAggregate());
serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(new FakeService());
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
using (var context = new CommandContext(GuidStrategy.NewGuid(), HeaderCollection.Empty, new CommandEnvelope(aggregateId, new FakeCommand())))
{
var handler1 = registry.GetHandlerFor(new FakeCommand());
handler1.Handle(context);
handler1.Handle(context);
var handler2 = registry.GetHandlerFor(new FakeCommand());
handler2.Handle(context);
handler2.Handle(context);
}
serviceProvider.Verify(mock => mock.GetService(typeof(FakeService)), Times.Once());
}
public void ThrowMappingExceptionIfHandlerNotFound()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny<Func<Type, Boolean>>())).Returns(new[] { typeof(AlternateImplicitStrategyAggregate) });
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var ex = Assert.Throws<MappingException>(() => registry.GetHandlerFor(new FakeCommand()));
Assert.Equal(Exceptions.CommandHandlerNotFound.FormatWith(typeof(FakeCommand)), ex.Message);
}
public void RegisteredServiceOnlyResolvedOncePerHandler()
{
var aggregateId = GuidStrategy.NewGuid();
typeLocator.Setup(mock => mock.GetTypes(It.IsAny<Func<Type, Boolean>>())).Returns(new[] { typeof(ServicedAggregate) });
aggregateStore.Setup(mock => mock.Get(typeof(ServicedAggregate), aggregateId)).Returns(new ServicedAggregate());
serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(new FakeService());
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
using (var context = new CommandContext(GuidStrategy.NewGuid(), HeaderCollection.Empty, new CommandEnvelope(aggregateId, new FakeCommand())))
{
var handler1 = registry.GetHandlerFor(new FakeCommand());
handler1.Handle(context);
handler1.Handle(context);
var handler2 = registry.GetHandlerFor(new FakeCommand());
handler2.Handle(context);
handler2.Handle(context);
}
serviceProvider.Verify(mock => mock.GetService(typeof(FakeService)), Times.Once());
}
public void GetCommandHandlerBasedOnCommandType()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny<Func<Type, Boolean>>())).Returns(new[] { typeof(ImplicitStrategyAggregate), typeof(AlternateImplicitStrategyAggregate) });
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var handler = registry.GetHandlerFor(new FakeCommand());
Assert.Equal(typeof(ImplicitStrategyAggregate), handler.AggregateType);
}
public CommandHandlerRegistryUnitTests()
{
_commandHandlerList = new ICommandHandler[] { new CommandACommandHandler(),
new CommandACommandHandler2(), new CommandBCommandHandler() };
_target = new CommandHandlerRegistry(_commandHandlerList);
}
public void CanResolveRegisteredServices()
{
typeLocator.Setup(mock => mock.GetTypes(It.IsAny<Func<Type, Boolean>>())).Returns(new[] { typeof(ServicedAggregate) });
serviceProvider.Setup(mock => mock.GetService(typeof(FakeService))).Returns(new FakeService());
var registry = new CommandHandlerRegistry(aggregateStore.Object, typeLocator.Object, serviceProvider.Object);
var handler = registry.GetHandlerFor(new FakeCommand());
Assert.NotNull(handler);
}
private void InitializeCommandHandlers()
{
handlerRegistry = new CommandHandlerRegistry();
handlerRegistry.RegisterHandler(new CustomerCommandHandler(GetCustomerRepository));
}
