private async Task <CommandBusResult> Execute(ICommandPipeline pipeline, ICommand cmd)
{
InMemoryCommandBus sut = GetSut(pipeline);
CommandBusResult result = await sut.EnqueueAsync(cmd);
return(result);
}
public WhenPipelineThrows()
{
var fake = A.Fake <ICommandPipeline>();
A.CallTo(() => fake.ExecuteAsync(A <ICommand> .Ignored)).Throws <InvalidOperationException>();
sut = GetSut(fake);
}
public async Task InMemoryCommandBus_Configuration_MultipleHandlers_ConfigurationOk()
{
var c = new InMemoryCommandBusConfigurationBuilder()
.AllowMultipleHandlersFor <TestMultipleHandlerFromConfig>();
var bus = new InMemoryCommandBus(c.Build());
(await bus.DispatchAsync(new TestMultipleHandlerFromConfig()).ConfigureAwait(false)).IsSuccess.Should().BeTrue();
}
public async Task InMemoryCommandBus_DispatchAsync_NoHandlerCanBeCreated()
{
var hInvoked = false;
var c = new InMemoryCommandBusConfigurationBuilder().AddHandlerWhenHandlerIsNotFound((cmd, ctx) => hInvoked = true).Build();
var bus = new InMemoryCommandBus(c);
(await bus.DispatchAsync(new TestNoCreatableHandler()).ConfigureAwait(false)).IsSuccess.Should().BeFalse();
hInvoked.Should().BeTrue();
}
public async Task DispatchRangeCommands(int nbCommands)
{
var bus = new InMemoryCommandBus();
for (int i = 0; i < nbCommands; i++)
{
await bus.DispatchAsync(new TestCommand(i, SimulateWork, JobDuration));
}
}
public async Task Dispatch_Command_SpecificResult_Should_Not_Loose_Value()
{
var bus = new InMemoryCommandBus();
var cmd = new TestResultData();
var result = await bus.DispatchAsync(cmd);
result.Should().BeOfType <Result <string> >();
}
public void Should_be_able_Send_the_Command_to_the_Bus()
{
AddProductCommand command = new AddProductCommand { Name = "Reebok Shoe", Categories = "Shoes", Id = 1 };
InMemoryCommandBus Bus = new InMemoryCommandBus();
InventoryController controller = new InventoryController(Bus);
ConfigureController(controller);
HttpResponseMessage Message = controller.Post(command);
Message.StatusCode.Should().Be(HttpStatusCode.Created);
Message.Headers.Location.ToString().Should().Be("http://localhost/api/Product/1");
Bus.Command.Should().Be(command);
}
public static IServiceCollection AddConventionBasedInMemoryCommandBus(
this IServiceCollection services, EventSourceConfiguration config)
{
services.AddSingleton <EventSourceConfiguration>(config);
services.AddSingleton <ICommandBus>(x => InMemoryCommandBus.CreateConventionCommandBus(
x.GetRequiredService <IDomainObjectRepository>(),
x.GetRequiredService <ILoggerFactory>(),
x.GetRequiredService <EventSourceConfiguration>()));
return(services);
}
public static EventSourceConfiguration SetConventionBasedInMemoryCommandBus(this EventSourceConfiguration config)
{
Precondition.For(() => config).NotNull();
Precondition.For(() => config.DomainObjectRepository).NotNull();
Precondition.For(() => config.DomainObjectAssemblies).NotNull();
config.CommandBus = InMemoryCommandBus.CreateConventionCommandBus(config.DomainObjectRepository,
config.DomainObjectAssemblies);
return(config);
}
private Task <CommandBusResult> Execute(ICommandPipeline pipeline, ICommand command)
{
InMemoryCommandBus bus = GetSut(pipeline);
bus.WithCondition(i =>
{
var temp = i as SampleCommand;
return(temp.Value == 42);
});
return(bus.EnqueueAsync(command));
}
public async Task Dispatch_Command_CriticalHandlerThrow_Should_NotCallNextHandlers()
{
HandlersData = "";
var cmd = new CriticalCommand();
var c = new InMemoryCommandBusConfigurationBuilder().AllowMultipleHandlersFor <CriticalCommand>(true).Build();
var bus = new InMemoryCommandBus(c);
await bus.DispatchAsync(cmd);
HandlersData.Should().Be("A");
}
public async Task Dispatch_Command_OneFail_Should_Returns_Failed_Result()
{
var c = new InMemoryCommandBusConfigurationBuilder()
.AllowMultipleHandlersFor <TestMultilpleCommand>()
.Build();
var bus = new InMemoryCommandBus(c);
var cmd = new TestMultilpleCommand();
var result = await bus.DispatchAsync(cmd);
result.IsSuccess.Should().BeFalse();
}
public async Task InMemoryCommandBus_DispatchAsync_Reflexion()
{
CleanRegistrationInDispatcher();
var bus = new InMemoryCommandBus();
(await bus.DispatchAsync(new TestCommand {
Data = "test_ioc"
}).ConfigureAwait(false)).IsSuccess.Should().BeTrue();
TestCommandHandler.HandlerData.Should().Be("test_ioc");
TestCommandHandler.Origin.Should().Be("reflexion");
}
public async Task InMemoryCommandBus_DispatchAsync_FromCoreDispatcher()
{
CleanRegistrationInDispatcher();
CoreDispatcher.AddHandlerToDispatcher(new TestCommandHandler("coreDispatcher"));
var bus = new InMemoryCommandBus();
(await bus.DispatchAsync(new TestCommand {
Data = "test_dispatcher"
}).ConfigureAwait(false)).IsSuccess.Should().BeTrue();
TestCommandHandler.HandlerData.Should().Be("test_dispatcher");
TestCommandHandler.Origin.Should().Be("spec_ctor");
}
internal static void ConfigureInMemoryCommandBus(Bootstrapper bootstrapper, InMemoryCommandBusConfiguration?configuration, string[] excludedCommandsDLLs, BootstrappingContext ctx)
{
InMemoryCommandBus.InitHandlersCollection(excludedCommandsDLLs);
if (ctx.IsServiceRegistered(BootstrapperServiceType.IoC))
{
bootstrapper.AddIoCRegistration(new TypeRegistration(typeof(InMemoryCommandBus), typeof(ICommandBus), typeof(InMemoryCommandBus)));
if (configuration != null)
{
bootstrapper.AddIoCRegistration(new InstanceTypeRegistration(configuration, typeof(InMemoryCommandBusConfiguration)));
}
}
bootstrapper.AddNotifications(PerformCommandChecksAccordingToBootstrapperParameters(ctx, configuration));
}
public async Task InMemoryCommandBus_Configuration_MultipleHandlers_ConfigurationOk_ShouldWait()
{
s_Order.Clear();
var c = new InMemoryCommandBusConfigurationBuilder()
.AllowMultipleHandlersFor <TestMultipleHandlerFromConfigParallel>(true);
var bus = new InMemoryCommandBus(c.Build());
(await bus.DispatchAsync(new TestMultipleHandlerFromConfigParallel()).ConfigureAwait(false)).IsSuccess.Should().BeTrue();
s_Order.Should().HaveCount(3);
s_Order.Should().Contain("One");
s_Order.Should().Contain("Two");
s_Order.Should().Contain("Three");
}
public async Task When_a_command_is_undelivered_it_can_be_retrieved_from_the_bus_before_it_is_due()
{
using (var clock = VirtualClock.Start())
{
var bus = new InMemoryCommandBus <string>(clock);
await bus.Schedule("undelivered",
dueTime : clock.Now().AddDays(2));
bus.Undelivered().Should().HaveCount(1);
bus.Undelivered().Single().Command.Should().Be("undelivered");
}
}
public async Task Dispatch_Command_With_Result_Should_Go_To_Correct_Path()
{
var bus = new InMemoryCommandBus();
var cmd = new TestResultOkCommand();
var okResult = await bus.DispatchAsync(cmd);
okResult.IsSuccess.Should().BeTrue();
var cmd2 = new TestResultFailCommand();
var failResult = await bus.DispatchAsync(cmd2);
failResult.IsSuccess.Should().BeFalse();
}
/// <summary>
/// Configure the system to use InMemory Command bus for dipsatching commands, with the provided configuration.
/// </summary>
/// <param name="bootstrapper">Bootstrapper instance.</param>
/// <param name="configurationBuilderAction">Action to apply on builder.</param>
/// <param name="excludedCommandsDLLs">DLLs name to exclude from auto-configuration into IoC
/// (IAutoRegisterType will be ineffective).</param>
/// <returns>Bootstrapper Instance.</returns>
public static Bootstrapper UseInMemoryCommandBus(this Bootstrapper bootstrapper, Action <InMemoryCommandBusConfigurationBuilder> configurationBuilderAction,
params string[] excludedCommandsDLLs)
{
if (configurationBuilderAction == null)
{
throw new ArgumentNullException(nameof(configurationBuilderAction));
}
InMemoryCommandBus.InitHandlersCollection(excludedCommandsDLLs);
var builder = new InMemoryCommandBusConfigurationBuilder();
configurationBuilderAction(builder);
return(UseInMemoryCommandBus(bootstrapper, builder.Build()));
}
public async Task InMemoryCommandBus_DispatchAsync_HandlerFromIoC()
{
var factory = new TestScopeFactory();
factory.Instances.Add(typeof(ICommandHandler <TestCommand>), new TestCommandHandler("tt"));
CleanRegistrationInDispatcher();
var bus = new InMemoryCommandBus(null, factory);
(await bus.DispatchAsync(new TestCommand {
Data = "test_ioc"
}).ConfigureAwait(false)).IsSuccess.Should().BeTrue();
TestCommandHandler.HandlerData.Should().Be("test_ioc");
TestCommandHandler.Origin.Should().Be("spec_ctor");
}
public async Task When_a_command_is_undelivered_it_can_be_retrieved_from_the_bus_after_it_is_due()
{
using (var clock = VirtualClock.Start())
{
var bus = new InMemoryCommandBus <string>(clock);
await bus.Schedule("undelivered",
1.Seconds());
await clock.AdvanceBy(3.Days());
bus.Undelivered().Should().HaveCount(1);
bus.Undelivered().Single().Command.Should().Be("undelivered");
}
}
public async Task InMemoryCommandBus_Configuration_DispatchIfClause()
{
TestIfCommandHandler.ResetData();
var cfgBuilder =
new InMemoryCommandBusConfigurationBuilder()
.DispatchOnlyIf <TestIfCommand>(e => e.Data > 1);
var b = new InMemoryCommandBus(cfgBuilder.Build());
TestIfCommandHandler.Data.Should().Be(0);
await b.DispatchAsync(new TestIfCommand { Data = 1 }).ConfigureAwait(false);
TestIfCommandHandler.Data.Should().Be(0);
await b.DispatchAsync(new TestIfCommand { Data = 10 }).ConfigureAwait(false);
TestIfCommandHandler.Data.Should().Be(10);
}
public void Init(IUnityContainer container)
{
container.RegisterType<ITextSerializer, JsonSerializer>();
var eventBus = new InMemoryEventBus();
container.RegisterInstance<IEventBus>(eventBus);
var commandBus = new InMemoryCommandBus();
container.RegisterInstance<ICommandBus>(commandBus);
container.RegisterType<IEventStore, SqlEventStore>();
foreach (var handler in container.ResolveAll<ICommandHandler>())
{
commandBus.Register(handler);
}
foreach (var handler in container.ResolveAll<IEventHandler>())
{
eventBus.Register(handler);
}
}
public async Task A_subscribed_receiver_can_select_a_handler_based_on_message_type()
{
var bus = new InMemoryCommandBus <ICommand <CommandTarget> >(Clock);
var received = new List <ICommand <CommandTarget> >();
var handler1 = CommandHandler.Create <CreateCommandTarget>(delivery => received.Add(delivery.Command));
var handler2 = CommandHandler.Create <UpdateCommandTarget>(delivery => received.Add(delivery.Command));
bus.Subscribe(handler1);
bus.Subscribe(handler2);
await bus.Schedule(new CreateCommandTarget(Guid.NewGuid().ToString()));
await Clock.AdvanceBy(1.Seconds());
received.Should()
.OnlyContain(c => c is CreateCommandTarget)
.And
.HaveCount(1);
}
/// <summary>
/// Configure the bootstrapper to use InMemory buses for dispatching commands.
/// </summary>
/// <param name="bootstrapper">Instance of boostrapper.</param>
/// <param name="configuration">Configuration to use for in memory command bus.</param>
/// <param name="excludedCommandsDLLs">DLLs name to exclude from auto-configuration into IoC
/// (IAutoRegisterType will be ineffective).</param>
public static Bootstrapper UseInMemoryCommandBus(this Bootstrapper bootstrapper, InMemoryCommandBusConfiguration configuration = null,
params string[] excludedCommandsDLLs)
{
var service = InMemoryBusesBootstrappService.Instance;
service.BootstrappAction += (ctx) =>
{
InMemoryCommandBus.InitHandlersCollection(excludedCommandsDLLs);
if (ctx.IsServiceRegistered(BootstrapperServiceType.IoC))
{
bootstrapper.AddIoCRegistration(new TypeRegistration(typeof(InMemoryCommandBus), typeof(ICommandBus), typeof(InMemoryCommandBus)));
if (configuration != null)
{
bootstrapper.AddIoCRegistration(new InstanceTypeRegistration(configuration, typeof(InMemoryCommandBusConfiguration)));
}
}
bootstrapper.AddNotifications(PerformCommandChecksAccordingToBootstrapperParameters(ctx, configuration));
};
if (!bootstrapper.RegisteredServices.Any(s => s == service))
{
bootstrapper.AddService(service);
}
return(bootstrapper);
}
public async Task DispatchACommand()
{
var bus = new InMemoryCommandBus();
await bus.DispatchAsync(new TestCommand(0, SimulateWork, JobDuration));
}
public InMemoryCommandBus GetSut(ICommandPipeline pipeline)
{
var sut = new InMemoryCommandBus(pipeline, new NoopLoggerFactory());
return(sut);
}
public InMemoryCommandBusTests()
{
TestCommandHandler.ResetTestData();
InMemoryCommandBus.InitHandlersCollection(new string[0]);
}
public InMemoryCommandBus GetSut(ICommandPipeline pipeline)
{
var sut = new InMemoryCommandBus(pipeline);
return(sut);
}
