public async Task Subscribe_HandlerThrows_DisposesReader( string topic, byte[] message, IDisposableBlockingRawMessageReader <IPollingOptions> reader, [Frozen] IPollingOptions options, [Frozen] IRawMessageHandler rawMessageHandler, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange factory.Create(topic, options).Returns(reader); var disposeEvent = new ManualResetEventSlim(); reader.When(r => r.Dispose()).Do(r => disposeEvent.Set()); reader.TryGetMessage(out var _, options) .Returns(r => { r[0] = message; return(true); }); rawMessageHandler.Handle(topic, message, Arg.Any <CancellationToken>()) .Throws <ArgumentNullException>(); // Act await sut.Subscribe(topic, rawMessageHandler, None); // Assert Assert.True(disposeEvent.Wait(1000)); }
public async Task Dispose_DisposesAllReaders( string topic, IDisposableBlockingRawMessageReader <IPollingOptions> firstReader, IDisposableBlockingRawMessageReader <IPollingOptions> secondReader, [Frozen] IPollingOptions options, IRawMessageHandler firstRawMessageHandler, IRawMessageHandler secondRawMessageHandler, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange factory.Create(topic, options).Returns(firstReader, secondReader); var firstDisposeEvent = new ManualResetEventSlim(); firstReader.When(r => r.Dispose()).Do(r => firstDisposeEvent.Set()); var secondDisposeEvent = new ManualResetEventSlim(); firstReader.When(r => r.Dispose()).Do(r => secondDisposeEvent.Set()); await sut.Subscribe(topic, firstRawMessageHandler, None); await sut.Subscribe(topic, secondRawMessageHandler, None); // Act sut.Dispose(); // Assert Assert.True(firstDisposeEvent.Wait(1000)); Assert.True(secondDisposeEvent.Wait(1000)); }
public async Task Subscribe_AfterUnsubscribing_CreatesNewReader( string topic, IDisposableBlockingRawMessageReader <IPollingOptions> reader, [Frozen] IPollingOptions options, [Frozen] IRawMessageHandler rawMessageHandler, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange factory.Create(topic, options).Returns(reader); var disposeEvent = new ManualResetEventSlim(); reader.When(r => r.Dispose()).Do(r => disposeEvent.Set()); // Act await sut.Subscribe(topic, rawMessageHandler, None); await sut.Unsubscribe(topic, rawMessageHandler, None); Assert.True(disposeEvent.Wait(1000)); // wait task complete await sut.Subscribe(topic, rawMessageHandler, None); // Assert factory.Received(2).Create(topic, options); }
public async Task Unsubscribe_DifferentTopics_DisposesSingleReader( string firstTopic, string secondTopic, IDisposableBlockingRawMessageReader <IPollingOptions> firstReader, IDisposableBlockingRawMessageReader <IPollingOptions> secondReader, [Frozen] IPollingOptions options, IRawMessageHandler firstRawMessageHandler, IRawMessageHandler secondRawMessageHandler, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange factory.Create(firstTopic, options).Returns(firstReader); factory.Create(secondTopic, options).Returns(secondReader); var disposeEvent = new ManualResetEventSlim(); firstReader.When(r => r.Dispose()).Do(r => disposeEvent.Set()); // Act await sut.Subscribe(firstTopic, firstRawMessageHandler, None); await sut.Subscribe(secondTopic, secondRawMessageHandler, None); await sut.Unsubscribe(firstTopic, firstRawMessageHandler, None); // Assert Assert.True(disposeEvent.Wait(1000)); secondReader.DidNotReceive().Dispose(); }
public async Task Subscribe_NullTopic_ThrowsArgumentNull( IRawMessageHandler rawMessageHandler, RedisRawMessageHandlerSubscriber sut) { var ex = await Assert.ThrowsAsync <ArgumentNullException>(() => sut.Subscribe(null, rawMessageHandler, None)); Assert.Equal("topic", ex.ParamName); }
public async Task Subscribe_ReaderFactoryThrows_SubscriptionFails( string topic, IRawMessageHandler rawMessageHandler, [Frozen] IPollingOptions options, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { factory.Create(topic, options).Throws(new DivideByZeroException()); await Assert.ThrowsAsync <DivideByZeroException>(() => sut.Subscribe(topic, rawMessageHandler, None)); }
public async Task Subscribe_MultipleCallsSameRawHandler_CreatesSingleReader( string topic, IRawMessageHandler rawMessageHandler, [Frozen] IPollingOptions options, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { var tasks = Enumerable.Range(1, 5).Select(_ => sut.Subscribe(topic, rawMessageHandler, None)); await Task.WhenAll(tasks); factory.Received(1).Create(topic, options); }
public async Task Subscribe_MultiplexerReturnsNoSubscription_ThrowsInvalidOperation( [Frozen] IConnectionMultiplexer connectionMultiplexer, string topic, IRawMessageHandler rawMessageHandler, RedisRawMessageHandlerSubscriber sut) { connectionMultiplexer.GetSubscriber().ReturnsNull(); var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => sut.Subscribe(topic, rawMessageHandler, None)); Assert.Equal("Redis Multiplexer returned no subscription.", ex.Message); }
public LoggerRawMessageHandler(IRawMessageHandler rawMessageHandler, ILogger logger) { if (rawMessageHandler == null) { throw new ArgumentNullException(nameof(rawMessageHandler)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } _rawMessageHandler = rawMessageHandler; _logger = logger; }
public void Unregister(IRawMessageHandler handler) { lock (handlers) { handlers.Remove(handler); foreach (var i in handler.SupportedMessages) { if (handlerCallbacks.ContainsKey(i)) { handlerCallbacks[i] -= handler.HandleMessage; } } } }
internal UdpSyslogServer( IRawMessageHandler rawMessageHandler, Func <IUdpClient> updClientFactory) { if (rawMessageHandler == null) { throw new ArgumentNullException(nameof(rawMessageHandler)); } if (updClientFactory == null) { throw new ArgumentNullException(nameof(updClientFactory)); } _rawMessageHandler = rawMessageHandler; _updClientFactory = updClientFactory; }
public void Register(IRawMessageHandler handler) { lock (handlers) { handlers.Add(handler); foreach (var i in handler.SupportedMessages) { if (!handlerCallbacks.ContainsKey(i)) { handlerCallbacks.Add(i, null); } handlerCallbacks[i] += handler.HandleMessage; } } }
public async Task Subscribe_CallbackRethrows_UnsubscribeDoesNotFailAwait( string topic, [Frozen] IPollingOptions options, [Frozen] IRawMessageHandler rawMessageHandler, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange options.ReaderStoppingCallback = (s, handler, ex) => throw ex; // Act await sut.Subscribe(topic, rawMessageHandler, None); // await doesn't throw on OperationCancelledException await sut.Unsubscribe(topic, rawMessageHandler, None); }
public async Task Subscribe_SubscribersRawMessageHandler( [Frozen] ISubscriber subscriber, string topic, byte[] message, IRawMessageHandler rawMessageHandler, RedisRawMessageHandlerSubscriber sut) { Action <RedisChannel, RedisValue> redisCallback = null; await subscriber.SubscribeAsync(topic, Arg.Do <Action <RedisChannel, RedisValue> >(action => redisCallback = action)); await sut.Subscribe(topic, rawMessageHandler, None); Assert.NotNull(redisCallback); redisCallback(topic, message); await rawMessageHandler.Received(1).Handle(topic, message, None); }
public async Task Subscribe_CallbackNull_DoesntThrow( string topic, IDisposableBlockingRawMessageReader <IPollingOptions> reader, [Frozen] IPollingOptions options, [Frozen] IRawMessageHandler rawMessageHandler, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange options.ReaderStoppingCallback = null; options.ErrorCallback = null; reader.TryGetMessage(out var _, options).Throws <DivideByZeroException>(); // Act await sut.Subscribe(topic, rawMessageHandler, None); // await doesn't throw on OperationCancelledException await sut.Unsubscribe(topic, rawMessageHandler, None); }
public async Task Subscribe_CancelledToken_CancelsSubscriptionTask( string topic, IRawMessageHandler rawMessageHandler, [Frozen] IPollingOptions options, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange var cts = new CancellationTokenSource(); cts.Cancel(); // Act var task = sut.Subscribe(topic, rawMessageHandler, cts.Token); // Assert await Assert.ThrowsAsync <TaskCanceledException>(() => task); factory.DidNotReceiveWithAnyArgs().Create(topic, options); }
public async Task Subscribe_ReaderThrows_DisposesReader( string topic, IRawMessageHandler rawMessageHandler, IDisposableBlockingRawMessageReader <IPollingOptions> reader, [Frozen] IPollingOptions options, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { factory.Create(topic, options).Returns(reader); var disposeEvent = new ManualResetEventSlim(); reader.When(r => r.Dispose()).Do(r => disposeEvent.Set()); reader.TryGetMessage(out var _, options) .Throws <ArgumentNullException>(); await sut.Subscribe(topic, rawMessageHandler, None); Assert.True(disposeEvent.Wait(1000)); }
public async Task Unsubscribe_CallbackInvoked( string topic, IDisposableBlockingRawMessageReader <IPollingOptions> reader, [Frozen] IPollingOptions options, [Frozen] IRawMessageHandler rawMessageHandler, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { // Arrange var callbackInvokedEvent = new ManualResetEventSlim(); options.ReaderStoppingCallback = (t, handler, arg3) => callbackInvokedEvent.Set(); factory.Create(topic, options).Returns(reader); // Act await sut.Subscribe(topic, rawMessageHandler, None); await sut.Unsubscribe(topic, rawMessageHandler, None); // Assert Assert.True(callbackInvokedEvent.Wait(1000)); }
public async Task Subscribe_MultipleCallsDifferentRawHandlers_CreatesSingleReader( string topic, IRawMessageHandler firstRawMessageHandler, IRawMessageHandler secondRawMessageHandler, [Frozen] IPollingOptions options, [Frozen] IBlockingRawMessageReaderFactory <IPollingOptions> factory, BlockingReaderRawMessageHandlerSubscriber <IPollingOptions> sut) { await Task.WhenAll(Subscrioptions()); factory.Received(2).Create(topic, options); IEnumerable <Task> Subscrioptions() { for (int i = 0; i < 5; i++) { yield return(sut.Subscribe(topic, firstRawMessageHandler, None)); yield return(sut.Subscribe(topic, secondRawMessageHandler, None)); } } }
public void Unregister(IRawMessageHandler handler) { lock(handlers) { handlers.Remove(handler); foreach(var i in handler.SupportedMessages) { if(handlerCallbacks.ContainsKey(i)) { handlerCallbacks[i] -= handler.HandleMessage; } } } }
public UdpSyslogServer(IRawMessageHandler rawMessageHandler) : this(rawMessageHandler, () => new UdpClientAdapter(514)) { }
public void Register(IRawMessageHandler handler) { lock(handlers) { handlers.Add(handler); foreach(var i in handler.SupportedMessages) { if(!handlerCallbacks.ContainsKey(i)) { handlerCallbacks.Add(i, null); } handlerCallbacks[i] += handler.HandleMessage; } } }