public async Task Host_can_loopback_commands(SecondTestCommand testCommand, CommandReceivedAsync <SecondTestCommand> commandReceived, string headerKey, string headerValue) { var host = TestUtils.CreateNybusHost(nybus => { nybus.SubscribeToCommand(commandReceived); nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(c => c.ConnectionFactory = new ConnectionFactory()); }); }, services => { services.AddSingleton(commandReceived); services.AddSingleton <ICommandHandler <SecondTestCommand>, SecondTestCommandHandler>(); }); await host.StartAsync(); var headers = new Dictionary <string, string> { [headerKey] = headerValue }; await host.Bus.InvokeCommandAsync(testCommand, headers); await Task.Delay(TimeSpan.FromMilliseconds(50)); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.Is <ICommandContext <SecondTestCommand> >(c => c.Message.Headers.ContainsKey(headerKey) && c.Message.Headers[headerKey] == headerValue))); }
public async Task Host_can_loopback_commands(SecondTestCommand testCommand, CommandReceivedAsync <SecondTestCommand> commandReceived) { var host = TestUtils.CreateNybusHost(nybus => { nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(configuration => configuration.ConnectionFactory = new ConnectionFactory()); }); nybus.SubscribeToCommand <SecondTestCommand>(); }, services => { services.AddSingleton(commandReceived); services.AddSingleton <ICommandHandler <SecondTestCommand>, SecondTestCommandHandler>(); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await Task.Delay(TimeSpan.FromMilliseconds(50)); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <SecondTestCommand> >())); }
public async Task Hosts_can_exchange_commands(FirstTestCommand testCommand, CommandReceivedAsync <FirstTestCommand> commandReceived) { var sender = CreateNybusHost(nybus => { nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(configuration => configuration.ConnectionFactory = new ConnectionFactory()); }); }); var receiver = CreateNybusHost(nybus => { nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(configuration => configuration.ConnectionFactory = new ConnectionFactory()); }); nybus.SubscribeToCommand(commandReceived); }); await sender.StartAsync(); await receiver.StartAsync(); await sender.Bus.InvokeCommandAsync(testCommand); await Task.Delay(TimeSpan.FromMilliseconds(50)); await receiver.StopAsync(); await sender.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >())); }
public async Task Host_can_loopback_commands(FirstTestCommand testCommand, CommandReceivedAsync <FirstTestCommand> commandReceived) { var settings = new Dictionary <string, string> { ["Nybus:ErrorPolicy:ProviderName"] = "retry", ["Nybus:ErrorPolicy:MaxRetries"] = "5", }; var configurationBuilder = new ConfigurationBuilder().AddInMemoryCollection(settings); var configuration = configurationBuilder.Build(); var host = CreateNybusHost(nybus => { nybus.UseConfiguration(configuration); nybus.SubscribeToCommand(commandReceived); nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(c => c.ConnectionFactory = new ConnectionFactory()); }); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await Task.Delay(TimeSpan.FromMilliseconds(50)); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >()), Times.Once); }
public void SubscribeToCommand <TCommand>(CommandReceivedAsync <TCommand> commandReceived) where TCommand : class, ICommand { _engine.SubscribeToCommand <TCommand>(); _errorHandlers.AddOrUpdate(typeof(TCommand), CreateCommandErrorDelegate <TCommand>(), (key, item) => item); _messagePipelines.Add(async message => { if (message is CommandMessage <TCommand> commandMessage) { var dispatcher = new NybusDispatcher(this, commandMessage); var context = new NybusCommandContext <TCommand>(commandMessage); await commandReceived(dispatcher, context).ConfigureAwait(false); } }); }
public async Task Issue90(CommandReceivedAsync <FirstTestCommand> commandReceived, Exception exception, FirstTestCommand testCommand) { const int maxRetries = 5; Mock.Get(commandReceived) .Setup(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >())) .Throws(exception); var builder = new ConfigurationBuilder(); builder.AddInMemoryCollection(new Dictionary <string, string> { ["Nybus:CommandErrorFilters:0:type"] = "retry", ["Nybus:CommandErrorFilters:0:maxRetries"] = maxRetries.Stringfy() }); var configuration = builder.Build(); var host = TestUtils.CreateNybusHost(nybus => { nybus.SubscribeToCommand(commandReceived); nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(c => c.ConnectionFactory = new ConnectionFactory()); }); nybus.UseConfiguration(configuration); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await Task.Delay(TimeSpan.FromMilliseconds(50)); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >()), Times.Exactly(maxRetries)); }
public void SubscribeToCommand_registers_delegate_handler_type(TestNybusConfigurator nybus, IServiceCollection services, CommandReceivedAsync <FirstTestCommand> testHandler) { NybusConfiguratorExtensions.SubscribeToCommand(nybus, testHandler); nybus.ApplyServiceConfigurations(services); Mock.Get(services).Verify(p => p.Add(It.Is <ServiceDescriptor>(sd => sd.ServiceType == typeof(DelegateWrapperCommandHandler <FirstTestCommand>)))); }
public void SubscribeToCommand_registers_delegate_handler_for_command(TestNybusConfigurator nybus, ISubscriptionBuilder subscriptionBuilder, CommandReceivedAsync <FirstTestCommand> testHandler) { NybusConfiguratorExtensions.SubscribeToCommand(nybus, testHandler); nybus.ApplySubscriptions(subscriptionBuilder); Mock.Get(subscriptionBuilder).Verify(p => p.SubscribeToCommand <FirstTestCommand>(typeof(DelegateWrapperCommandHandler <FirstTestCommand>))); }
public async Task Host_can_loopback_commands(FakeServer server, FirstTestCommand testCommand, CommandReceivedAsync <FirstTestCommand> commandReceived) { var host = CreateNybusHost(nybus => { nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory()); }); nybus.SubscribeToCommand(commandReceived); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >())); }
public async Task Handler_is_executed_when_commandMessages_are_processed([Frozen] IBusEngine engine, NybusHost sut, CommandMessage <FirstTestCommand> testMessage, CommandReceivedAsync <FirstTestCommand> receivedMessage) { var subject = new Subject <Message>(); Mock.Get(engine).Setup(p => p.StartAsync()).ReturnsAsync(subject); sut.SubscribeToCommand(receivedMessage); await sut.StartAsync(); subject.OnNext(testMessage); await sut.StopAsync(); Mock.Get(receivedMessage).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >()), Times.Once); }
public async Task Commands_are_correctly_converted(ThirdTestCommand testCommand, CommandReceivedAsync <AttributeTestCommand> commandReceived) { var host = TestUtils.CreateNybusHost(nybus => { nybus.SubscribeToCommand(commandReceived); nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(c => c.ConnectionFactory = new ConnectionFactory()); }); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await Task.Delay(TimeSpan.FromMilliseconds(50)); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.Is <ICommandContext <AttributeTestCommand> >(c => string.Equals(c.Command.Message, testCommand.Message))), Times.Once); }
public void Handler_errors_are_not_caught(IDispatcher dispatcher, ICommandContext <FirstTestCommand> context, Exception error, CommandReceivedAsync <FirstTestCommand> handler) { Mock.Get(handler).Setup(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >())).Throws(error); var sut = new DelegateWrapperCommandHandler <FirstTestCommand>(handler); Assert.ThrowsAsync(error.GetType(), () => sut.HandleAsync(dispatcher, context)); }
public async Task Hosts_can_exchange_commands(FakeServer server, NoNamespaceCommand testCommand, CommandReceivedAsync <NoNamespaceCommand> commandReceived) { var sender = CreateNybusHost(nybus => { nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory()); }); }); var receiver = CreateNybusHost(nybus => { nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory()); }); nybus.SubscribeToCommand(commandReceived); }); await sender.StartAsync(); await receiver.StartAsync(); await sender.Bus.InvokeCommandAsync(testCommand); await receiver.StopAsync(); await sender.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <NoNamespaceCommand> >())); }
public async Task Host_can_loopback_commands(FakeServer server, SecondTestCommand testCommand, [Frozen] CommandReceivedAsync <SecondTestCommand> commandReceived, SecondTestCommandHandler handler) { var settings = new Dictionary <string, string> { ["Nybus:ErrorPolicy:ProviderName"] = "retry", ["Nybus:ErrorPolicy:MaxRetries"] = "5", }; var configurationBuilder = new ConfigurationBuilder().AddInMemoryCollection(settings); var configuration = configurationBuilder.Build(); var host = CreateNybusHost(nybus => { nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(c => c.ConnectionFactory = server.CreateConnectionFactory()); }); nybus.UseConfiguration(configuration); nybus.SubscribeToCommand <SecondTestCommand, SecondTestCommandHandler>(); }, services => { services.AddSingleton(commandReceived); services.AddSingleton(handler); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <SecondTestCommand> >())); }
public async Task Outgoing_commands_are_marked_via_MessageAttribute(ServiceCollection services, AttributeTestCommand testCommand, CommandReceivedAsync <ThirdTestCommand> commandReceived) { services.AddLogging(l => l.AddDebug()); services.AddNybus(nybus => { nybus.UseInMemoryBusEngine(); nybus.SubscribeToCommand(commandReceived); }); var serviceProvider = services.BuildServiceProvider(); var host = serviceProvider.GetRequiredService <IBusHost>(); var bus = serviceProvider.GetRequiredService <IBus>(); await host.StartAsync(); await bus.InvokeCommandAsync(testCommand); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <ThirdTestCommand> >()), Times.Once); }
public async Task Null_messages_delivered_from_engine_are_discarded([Frozen] IBusEngine engine, NybusHost sut, CommandMessage <FirstTestCommand> testMessage, CommandReceivedAsync <FirstTestCommand> receivedMessage) { var subject = new Subject <Message>(); Mock.Get(engine).Setup(p => p.StartAsync()).ReturnsAsync(subject); sut.SubscribeToCommand(receivedMessage); await sut.StartAsync(); subject.OnNext(null); await sut.StopAsync(); Mock.Get(receivedMessage).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <FirstTestCommand> >()), Times.Never); }
public async Task Host_can_loopback_commands(ServiceCollection services, SecondTestCommand testCommand, CommandReceivedAsync <SecondTestCommand> commandReceived) { var settings = new Dictionary <string, string> { ["Nybus:ErrorPolicy:ProviderName"] = "retry", ["Nybus:ErrorPolicy:MaxRetries"] = "5", }; var configurationBuilder = new ConfigurationBuilder().AddInMemoryCollection(settings); var configuration = configurationBuilder.Build(); services.AddLogging(l => l.AddDebug()); services.AddSingleton(commandReceived); services.AddSingleton <ICommandHandler <SecondTestCommand>, SecondTestCommandHandler>(); services.AddNybus(nybus => { nybus.UseInMemoryBusEngine(); nybus.UseConfiguration(configuration); nybus.SubscribeToCommand <SecondTestCommand>(); }); var serviceProvider = services.BuildServiceProvider(); var host = serviceProvider.GetRequiredService <IBusHost>(); var bus = serviceProvider.GetRequiredService <IBus>(); await host.StartAsync(); await bus.InvokeCommandAsync(testCommand); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <SecondTestCommand> >())); }
public async Task Handler_is_executed(IDispatcher dispatcher, ICommandContext <FirstTestCommand> context, CommandReceivedAsync <FirstTestCommand> handler) { var sut = new DelegateWrapperCommandHandler <FirstTestCommand>(handler); await sut.HandleAsync(dispatcher, context); Mock.Get(handler).Verify(p => p(dispatcher, context), Times.Once); }
public async Task Host_can_loopback_commands(ServiceCollection services, NoNamespaceCommand testCommand, CommandReceivedAsync <NoNamespaceCommand> commandReceived) { services.AddLogging(l => l.AddDebug()); services.AddNybus(nybus => { nybus.UseInMemoryBusEngine(); nybus.SubscribeToCommand(commandReceived); }); var serviceProvider = services.BuildServiceProvider(); var host = serviceProvider.GetRequiredService <IBusHost>(); var bus = serviceProvider.GetRequiredService <IBus>(); await host.StartAsync(); await bus.InvokeCommandAsync(testCommand); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <NoNamespaceCommand> >()), Times.Once); }
public async Task Host_can_loopback_commands(FakeServer server, SecondTestCommand testCommand, [Frozen] CommandReceivedAsync <SecondTestCommand> commandReceived, SecondTestCommandHandler handler) { var host = CreateNybusHost(nybus => { nybus.SubscribeToCommand(commandReceived); nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(c => c.ConnectionFactory = server.CreateConnectionFactory()); }); nybus.SubscribeToCommand <SecondTestCommand, SecondTestCommandHandler>(); }, services => { services.AddSingleton(commandReceived); services.AddSingleton(handler); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <SecondTestCommand> >())); }
public DelegateWrapperCommandHandler(CommandReceivedAsync <TCommand> handler) { _handler = handler ?? throw new ArgumentNullException(nameof(handler)); }
public async Task Outgoing_commands_are_marked_via_MessageAttribute(FakeServer server, AttributeTestCommand testCommand, CommandReceivedAsync <ThirdTestCommand> commandReceived) { var host = CreateNybusHost(nybus => { nybus.SubscribeToCommand(commandReceived); nybus.UseRabbitMqBusEngine(rabbitMq => { rabbitMq.Configure(c => c.ConnectionFactory = server.CreateConnectionFactory()); }); }); await host.StartAsync(); await host.Bus.InvokeCommandAsync(testCommand); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <ICommandContext <ThirdTestCommand> >()), Times.Once); }
public SecondTestCommandHandler(CommandReceivedAsync <SecondTestCommand> commandReceived) { _commandReceived = commandReceived ?? throw new ArgumentNullException(nameof(commandReceived)); }
public static void SubscribeToCommand <TCommand>(this INybusConfigurator configurator, CommandReceivedAsync <TCommand> commandReceived) where TCommand : class, ICommand { var handler = new DelegateWrapperCommandHandler <TCommand>(commandReceived); SubscribeToCommand <TCommand, DelegateWrapperCommandHandler <TCommand> >(configurator, handler); }
public async Task Host_can_loopback_commands(ServiceCollection services, SecondTestCommand testCommand, CommandReceivedAsync <SecondTestCommand> commandReceived, string headerKey, string headerValue) { services.AddLogging(l => l.AddDebug()); services.AddSingleton(commandReceived); services.AddSingleton <ICommandHandler <SecondTestCommand>, SecondTestCommandHandler>(); services.AddNybus(nybus => { nybus.UseInMemoryBusEngine(); nybus.SubscribeToCommand <SecondTestCommand>(); }); var serviceProvider = services.BuildServiceProvider(); var host = serviceProvider.GetRequiredService <IBusHost>(); var bus = serviceProvider.GetRequiredService <IBus>(); await host.StartAsync(); var headers = new Dictionary <string, string> { [headerKey] = headerValue }; await bus.InvokeCommandAsync(testCommand, headers); await host.StopAsync(); Mock.Get(commandReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.Is <ICommandContext <SecondTestCommand> >(c => c.Message.Headers.ContainsKey(headerKey) && c.Message.Headers[headerKey] == headerValue))); }