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()) { }