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;
}
}
}
