public NybusHost(IBusEngine busEngine, INybusConfiguration configuration, IServiceProvider serviceProvider, ILogger <NybusHost> logger)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_engine = busEngine ?? throw new ArgumentNullException(nameof(busEngine));
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
}
public async Task HandleErrorAsync_forwards_to_next_if_error_on_Event([Frozen] IBusEngine engine, DiscardErrorFilter sut, IEventContext <FirstTestEvent> context, Exception exception, Exception discardException, EventErrorDelegate <FirstTestEvent> next)
{
Mock.Get(engine).Setup(p => p.NotifyFailAsync(It.IsAny <Message>())).ThrowsAsync(discardException);
await sut.HandleErrorAsync(context, exception, next);
Mock.Get(next).Verify(p => p(context, exception));
}
public void MaxRetries_cant_be_negative(IBusEngine engine, ILogger <RetryErrorFilter> logger, int retries)
{
var options = new RetryErrorFilterOptions {
MaxRetries = -retries
};
Assert.Throws <ArgumentOutOfRangeException>(() => new RetryErrorFilter(engine, options, logger));
}
public async Task StopAsync_stops_the_engine_if_started([Frozen] IBusEngine engine, NybusHost sut)
{
await sut.StartAsync();
await sut.StopAsync();
Mock.Get(engine).Verify(p => p.StopAsync(), Times.Once);
}
public RetryErrorFilter(IBusEngine engine, RetryErrorFilterOptions options, ILogger <RetryErrorFilter> logger)
{
_engine = engine ?? throw new ArgumentNullException(nameof(engine));
_options = options ?? throw new ArgumentNullException(nameof(options));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
if (_options.MaxRetries < 0)
{
throw new ArgumentOutOfRangeException(nameof(_options.MaxRetries), "maxRetries must be greater or equal than 0");
}
}
public NybusHost BuildHost(IBusEngine engine, IServiceProvider serviceProvider, INybusConfiguration configuration)
{
var host = new NybusHost(engine, configuration, serviceProvider, _loggerFactory.CreateLogger <NybusHost>());
foreach (var subscription in _subscriptions)
{
subscription(host);
}
return(host);
}
public async Task RaiseEventAsync_forwards_given_headers([Frozen] IBusEngine engine, NybusHost sut, FirstTestEvent testEvent, Guid correlationId, string headerKey, string headerValue)
{
var headers = new Dictionary <string, string>
{
[headerKey] = headerValue
};
await sut.RaiseEventAsync(testEvent, correlationId, headers);
Mock.Get(engine).Verify(p => p.SendMessageAsync(It.Is <Message>(message => message.Headers.ContainsKey(headerKey) && message.Headers[headerKey] == headerValue)));
}
public NybusBus(IBusEngine engine, INybusOptions options)
{
if (engine == null)
{
throw new ArgumentNullException(nameof(engine));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_engine = engine;
_options = options;
_logger = _options.LoggerFactory.CreateLogger(nameof(NybusBus));
}
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 FallbackErrorFilter(IBusEngine engine)
{
_engine = engine ?? throw new ArgumentNullException(nameof(engine));
}
public async Task InvokeCommandAsync_forwards_message_to_engine([Frozen] IBusEngine engine, NybusHost sut, FirstTestCommand testCommand, Guid correlationId, IDictionary <string, string> headers)
{
await sut.InvokeCommandAsync(testCommand, correlationId, headers);
Mock.Get(engine).Verify(p => p.SendMessageAsync(It.Is <CommandMessage <FirstTestCommand> >(m => ReferenceEquals(m.Command, testCommand) && m.Headers.CorrelationId == correlationId)), Times.Once);
}
public async Task HandleErrorAsync_notifies_engine_on_Event([Frozen] IBusEngine engine, DiscardErrorFilter sut, IEventContext <FirstTestEvent> context, Exception exception, EventErrorDelegate <FirstTestEvent> next)
{
await sut.HandleErrorAsync(context, exception, next);
Mock.Get(engine).Verify(p => p.NotifyFailAsync(context.Message));
}
public DiscardErrorFilter(IBusEngine engine, ILogger <DiscardErrorFilter> logger)
{
_engine = engine ?? throw new ArgumentNullException(nameof(engine));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public void CreateErrorFilter_returns_filter([Frozen] IServiceProvider serviceProvider, RetryErrorFilterProvider sut, IConfigurationSection settings, IBusEngine engine, ILogger <RetryErrorFilter> logger, int maxRetries)
{
Mock.Get(settings.GetSection("MaxRetries")).Setup(p => p.Value).Returns(maxRetries.ToString());
Mock.Get(serviceProvider).Setup(p => p.GetService(typeof(IBusEngine))).Returns(engine);
Mock.Get(serviceProvider).Setup(p => p.GetService(typeof(ILogger <RetryErrorFilter>))).Returns(logger);
var filter = sut.CreateErrorFilter(settings);
Assert.That(filter, Is.InstanceOf <RetryErrorFilter>());
}
public async Task HandleError_increments_retry_count_if_retry_count_present([Frozen] RetryErrorFilterOptions options, [Frozen] IBusEngine engine, RetryErrorFilter sut, Exception error, NybusCommandContext <FirstTestCommand> context, CommandErrorDelegate <FirstTestCommand> next)
{
context.Message.Headers[Headers.RetryCount] = (options.MaxRetries - 2).Stringfy();
await sut.HandleErrorAsync(context, error, next);
Assert.That(context.Message.Headers.ContainsKey(Headers.RetryCount));
Assert.That(context.Message.Headers[Headers.RetryCount], Is.EqualTo((options.MaxRetries - 1).Stringfy()));
}
public void Logger_is_required(IBusEngine engine, NybusConfiguration configuration, IServiceProvider serviceProvider)
{
Assert.Throws <ArgumentNullException>(() => new NybusHost(engine, configuration, serviceProvider, null));
}
public async Task HandleError_invokes_next_if_retry_count_equal_or_greater_than_maxRetries([Frozen] RetryErrorFilterOptions options, [Frozen] IBusEngine engine, RetryErrorFilter sut, Exception error, NybusCommandContext <FirstTestCommand> context, CommandErrorDelegate <FirstTestCommand> next)
{
context.Message.Headers[Headers.RetryCount] = options.MaxRetries.Stringfy();
await sut.HandleErrorAsync(context, error, next);
Mock.Get(next).Verify(p => p(context, error));
}
public void CreateErrorFilter_returns_filter([Frozen] IServiceProvider serviceProvider, DiscardErrorFilterProvider sut, IConfigurationSection settings, IBusEngine engine, ILogger <DiscardErrorFilter> logger)
{
Mock.Get(serviceProvider).Setup(p => p.GetService(typeof(IBusEngine))).Returns(engine);
Mock.Get(serviceProvider).Setup(p => p.GetService(typeof(ILogger <DiscardErrorFilter>))).Returns(logger);
var filter = sut.CreateErrorFilter(settings);
Assert.That(filter, Is.InstanceOf <DiscardErrorFilter>());
}
public async Task RaiseEventAsync_forwards_message_to_engine([Frozen] IBusEngine engine, NybusHost sut, FirstTestEvent testEvent, Guid correlationId, IDictionary <string, string> headers)
{
await sut.RaiseEventAsync(testEvent, correlationId, headers);
Mock.Get(engine).Verify(p => p.SendMessageAsync(It.Is <EventMessage <FirstTestEvent> >(m => ReferenceEquals(m.Event, testEvent) && m.Headers.CorrelationId == correlationId)), Times.Once);
}
public void BuildHost_assembles_host_with_subscribed_event(Type handlerType, NybusHostBuilder sut, IBusEngine engine, IServiceProvider serviceProvider, NybusConfiguration configuration)
{
sut.SubscribeToEvent <FirstTestEvent>(handlerType);
var host = sut.BuildHost(engine, serviceProvider, configuration);
Assert.That(host, Is.Not.Null);
}
public void BuildHost_assembles_host(NybusHostBuilder sut, IBusEngine engine, IServiceProvider serviceProvider, NybusConfiguration configuration)
{
var host = sut.BuildHost(engine, serviceProvider, configuration);
Assert.That(host, Is.Not.Null);
}
public async Task HandleError_adds_retry_count_if_retry_count_not_present([Frozen] IBusEngine engine, RetryErrorFilter sut, Exception error, NybusCommandContext <FirstTestCommand> context, CommandErrorDelegate <FirstTestCommand> next)
{
await sut.HandleErrorAsync(context, error, next);
Assert.That(context.Message.Headers.ContainsKey(Headers.RetryCount));
}
public async Task ExecuteEventHandlerAsync_notifies_engine_on_success([Frozen] IServiceProvider serviceProvider, [Frozen] IBusEngine engine, NybusHost sut, IDispatcher dispatcher, EventMessage <FirstTestEvent> eventMessage, IServiceScopeFactory scopeFactory, IEventHandler <FirstTestEvent> handler)
{
var handlerType = handler.GetType();
var context = new NybusEventContext <FirstTestEvent>(eventMessage);
Mock.Get(serviceProvider).Setup(p => p.GetService(typeof(IServiceScopeFactory))).Returns(scopeFactory);
Mock.Get(serviceProvider).Setup(p => p.GetService(handlerType)).Returns(handler);
await sut.ExecuteEventHandlerAsync(dispatcher, context, handlerType);
Mock.Get(engine).Verify(p => p.NotifySuccessAsync(context.Message));
}
public async Task HandleError_retries_if_retry_count_less_than_maxRetries([Frozen] RetryErrorFilterOptions options, [Frozen] IBusEngine engine, RetryErrorFilter sut, Exception error, NybusCommandContext <FirstTestCommand> context, CommandErrorDelegate <FirstTestCommand> next)
{
context.Message.Headers[Headers.RetryCount] = (options.MaxRetries - 2).Stringfy();
await sut.HandleErrorAsync(context, error, next);
Mock.Get(engine).Verify(p => p.SendMessageAsync(context.CommandMessage));
}
public async Task HandleErrorAsync_notifies_engine_on_Command([Frozen] IBusEngine engine, FallbackErrorFilter sut, ICommandContext <FirstTestCommand> context, Exception exception, CommandErrorDelegate <FirstTestCommand> next)
{
await sut.HandleErrorAsync(context, exception, next);
Mock.Get(engine).Verify(p => p.NotifyFailAsync(context.Message));
}
public async Task HandleError_retries_if_retry_count_not_present([Frozen] IBusEngine engine, RetryErrorFilter sut, Exception error, NybusCommandContext <FirstTestCommand> context, CommandErrorDelegate <FirstTestCommand> next)
{
await sut.HandleErrorAsync(context, error, next);
Mock.Get(engine).Verify(p => p.SendMessageAsync(context.CommandMessage));
}
public async Task ExecuteEventHandlerAsync_executes_error_filter_on_fail([Frozen] IServiceProvider serviceProvider, [Frozen] IBusEngine engine, [Frozen] INybusConfiguration configuration, NybusHost sut, IDispatcher dispatcher, EventMessage <FirstTestEvent> eventMessage, IServiceScopeFactory scopeFactory, IEventHandler <FirstTestEvent> handler, Exception error, IErrorFilter errorFilter)
{
configuration.EventErrorFilters = new[] { errorFilter };
var handlerType = handler.GetType();
var context = new NybusEventContext <FirstTestEvent>(eventMessage);
Mock.Get(serviceProvider).Setup(p => p.GetService(typeof(IServiceScopeFactory))).Returns(scopeFactory);
Mock.Get(serviceProvider).Setup(p => p.GetService(handlerType)).Returns(handler);
Mock.Get(handler).Setup(p => p.HandleAsync(It.IsAny <IDispatcher>(), It.IsAny <IEventContext <FirstTestEvent> >())).Throws(error);
await sut.ExecuteEventHandlerAsync(dispatcher, context, handlerType);
Mock.Get(errorFilter).Verify(p => p.HandleErrorAsync(context, error, It.IsAny <EventErrorDelegate <FirstTestEvent> >()));
}
public async Task HandleError_forwards_to_next_if_retry_count_equal_or_greater_than_maxRetries([Frozen] RetryErrorFilterOptions options, [Frozen] IBusEngine engine, RetryErrorFilter sut, Exception error, NybusEventContext <FirstTestEvent> context, EventErrorDelegate <FirstTestEvent> next)
{
context.Message.Headers[Headers.RetryCount] = options.MaxRetries.Stringfy();
await sut.HandleErrorAsync(context, error, next);
Mock.Get(engine).VerifyNoOtherCalls();
Mock.Get(next).Verify(p => p(context, error));
}
public NybusBusBuilder(IBusEngine busEngine) : this(busEngine, new NybusOptions())
{
}
