public async Task Hosts_can_exchange_events(FirstTestEvent testEvent, EventReceivedAsync <FirstTestEvent> eventReceived)
{
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.SubscribeToEvent(eventReceived);
});
await sender.StartAsync();
await receiver.StartAsync();
await sender.Bus.RaiseEventAsync(testEvent);
await Task.Delay(TimeSpan.FromMilliseconds(50));
await receiver.StopAsync();
await sender.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <FirstTestEvent> >()));
}
public async Task Host_can_loopback_events(FirstTestEvent testEvent, EventReceivedAsync <FirstTestEvent> eventReceived)
{
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.SubscribeToEvent(eventReceived);
nybus.UseRabbitMqBusEngine(rabbitMq =>
{
rabbitMq.Configure(c => c.ConnectionFactory = new ConnectionFactory());
});
});
await host.StartAsync();
await host.Bus.RaiseEventAsync(testEvent);
await Task.Delay(TimeSpan.FromMilliseconds(50));
await host.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <FirstTestEvent> >()), Times.Once);
}
public void SubscribeToEvent <TEvent>(EventReceivedAsync <TEvent> eventReceived)
where TEvent : class, IEvent
{
_engine.SubscribeToEvent <TEvent>();
_errorHandlers.AddOrUpdate(typeof(TEvent), CreateEventErrorDelegate <TEvent>(), (key, item) => item);
_messagePipelines.Add(async message =>
{
if (message is EventMessage <TEvent> eventMessage)
{
var dispatcher = new NybusDispatcher(this, eventMessage);
var context = new NybusEventContext <TEvent>(eventMessage);
await eventReceived(dispatcher, context).ConfigureAwait(false);
}
});
}
public void Handler_errors_are_not_caught(IDispatcher dispatcher, IEventContext <FirstTestEvent> context, Exception error, EventReceivedAsync <FirstTestEvent> handler)
{
Mock.Get(handler).Setup(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <FirstTestEvent> >())).Throws(error);
var sut = new DelegateWrapperEventHandler <FirstTestEvent>(handler);
Assert.ThrowsAsync(error.GetType(), () => sut.HandleAsync(dispatcher, context));
}
public async Task Handler_is_executed(IDispatcher dispatcher, IEventContext <FirstTestEvent> context, EventReceivedAsync <FirstTestEvent> handler)
{
var sut = new DelegateWrapperEventHandler <FirstTestEvent>(handler);
await sut.HandleAsync(dispatcher, context);
Mock.Get(handler).Verify(p => p(dispatcher, context), Times.Once);
}
public static void SubscribeToEvent <TEvent>(this INybusConfigurator configurator, EventReceivedAsync <TEvent> eventReceived)
where TEvent : class, IEvent
{
var handler = new DelegateWrapperEventHandler <TEvent>(eventReceived);
SubscribeToEvent <TEvent, DelegateWrapperEventHandler <TEvent> >(configurator, handler);
}
public async Task Outgoing_Events_are_marked_via_MessageAttribute(FakeServer server, AttributeTestEvent testEvent, EventReceivedAsync <ThirdTestEvent> eventReceived)
{
var host = CreateNybusHost(nybus =>
{
nybus.SubscribeToEvent(eventReceived);
nybus.UseRabbitMqBusEngine(rabbitMq =>
{
rabbitMq.Configure(c => c.ConnectionFactory = server.CreateConnectionFactory());
});
});
await host.StartAsync();
await host.Bus.RaiseEventAsync(testEvent);
await host.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <ThirdTestEvent> >()), Times.Once);
}
public async Task Hosts_can_exchange_events(FakeServer server, NoNamespaceEvent testEvent, EventReceivedAsync <NoNamespaceEvent> eventReceived)
{
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.SubscribeToEvent(eventReceived);
});
await sender.StartAsync();
await receiver.StartAsync();
await sender.Bus.RaiseEventAsync(testEvent);
await receiver.StopAsync();
await sender.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <NoNamespaceEvent> >()));
}
public async Task Host_can_loopback_events(FakeServer server, SecondTestEvent testEvent, [Frozen] EventReceivedAsync <SecondTestEvent> eventReceived, SecondTestEventHandler 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.SubscribeToEvent <SecondTestEvent, SecondTestEventHandler>();
},
services =>
{
services.AddSingleton(eventReceived);
services.AddSingleton(handler);
});
await host.StartAsync();
await host.Bus.RaiseEventAsync(testEvent);
await host.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <SecondTestEvent> >()));
}
public SecondTestEventHandler(EventReceivedAsync <SecondTestEvent> eventReceived)
{
_eventReceived = eventReceived ?? throw new ArgumentNullException(nameof(eventReceived));
}
public DelegateWrapperEventHandler(EventReceivedAsync <TEvent> handler)
{
_handler = handler ?? throw new ArgumentNullException(nameof(handler));
}
public async Task Outgoing_events_are_marked_via_MessageAttribute(ServiceCollection services, AttributeTestEvent testEvent, EventReceivedAsync <ThirdTestEvent> eventReceived)
{
services.AddLogging(l => l.AddDebug());
services.AddNybus(nybus =>
{
nybus.UseInMemoryBusEngine();
nybus.SubscribeToEvent(eventReceived);
});
var serviceProvider = services.BuildServiceProvider();
var host = serviceProvider.GetRequiredService <IBusHost>();
var bus = serviceProvider.GetRequiredService <IBus>();
await host.StartAsync();
await bus.RaiseEventAsync(testEvent);
await host.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <ThirdTestEvent> >()), Times.Once);
}
public async Task Events_are_correctly_converted(ServiceCollection services, ThirdTestEvent testEvent, EventReceivedAsync <AttributeTestEvent> eventReceived)
{
services.AddLogging(l => l.AddDebug());
services.AddNybus(nybus =>
{
nybus.UseInMemoryBusEngine();
nybus.SubscribeToEvent(eventReceived);
});
var serviceProvider = services.BuildServiceProvider();
var host = serviceProvider.GetRequiredService <IBusHost>();
var bus = serviceProvider.GetRequiredService <IBus>();
await host.StartAsync();
await bus.RaiseEventAsync(testEvent);
await host.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.Is <IEventContext <AttributeTestEvent> >(e => string.Equals(e.Event.Message, testEvent.Message))), Times.Once);
}
public async Task Null_messages_delivered_from_engine_are_discarded([Frozen] IBusEngine engine, NybusHost sut, EventMessage <FirstTestEvent> testMessage, EventReceivedAsync <FirstTestEvent> receivedMessage)
{
var subject = new Subject <Message>();
Mock.Get(engine).Setup(p => p.StartAsync()).ReturnsAsync(subject);
sut.SubscribeToEvent(receivedMessage);
await sut.StartAsync();
subject.OnNext(null);
await sut.StopAsync();
Mock.Get(receivedMessage).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <FirstTestEvent> >()), Times.Never);
}
public async Task Handler_is_executed_when_eventMessages_are_processed([Frozen] IBusEngine engine, NybusHost sut, EventMessage <FirstTestEvent> testMessage, EventReceivedAsync <FirstTestEvent> receivedMessage)
{
var subject = new Subject <Message>();
Mock.Get(engine).Setup(p => p.StartAsync()).ReturnsAsync(subject);
sut.SubscribeToEvent(receivedMessage);
await sut.StartAsync();
subject.OnNext(testMessage);
await sut.StopAsync();
Mock.Get(receivedMessage).Verify(p => p(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <FirstTestEvent> >()), Times.Once);
}
public async Task Host_can_loopback_events(ServiceCollection services, SecondTestEvent testEvent, EventReceivedAsync <SecondTestEvent> eventReceived, string headerKey, string headerValue)
{
services.AddLogging(l => l.AddDebug());
services.AddSingleton(eventReceived);
services.AddSingleton <IEventHandler <SecondTestEvent>, SecondTestEventHandler>();
services.AddNybus(nybus =>
{
nybus.UseInMemoryBusEngine();
nybus.SubscribeToEvent <SecondTestEvent>();
});
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.RaiseEventAsync(testEvent, headers);
await host.StopAsync();
Mock.Get(eventReceived).Verify(p => p(It.IsAny <IDispatcher>(), It.Is <IEventContext <SecondTestEvent> >(c => c.Message.Headers.ContainsKey(headerKey) && c.Message.Headers[headerKey] == headerValue)));
}
