public async Task Should_start_new_queue_reader_when_lock_is_released()
{
//arrange
var lockManager = new Mock <ISingletonLockManager>();
lockManager.SetupSequence(x => x.TryLockAsync(It.IsAny <string>(), TimeSpan.FromSeconds(60), CancellationToken.None))
.ReturnsAsync(Mock.Of <ISingletonLockHandle>())
.ReturnsAsync((ISingletonLockHandle)null)
.ReturnsAsync(Mock.Of <ISingletonLockHandle>());
var underlyingReader = new Mock <IChannelReceiver>();
underlyingReader.Setup(x => x.Settings).Returns(new Mock <IProcessingSettings>().Object);
var singletonChannelReceiver = new SingletonChannelReceiver(underlyingReader.Object, lockManager.Object, Mock.Of <ILog>())
{
TimerIntervalMs = 1000
};
//act
await singletonChannelReceiver.StartAsync(CancellationToken.None);
await singletonChannelReceiver.StartAsync(CancellationToken.None);
await Task.Delay(1500);
//assert
underlyingReader.Verify(x => x.StartAsync(CancellationToken.None), Times.Exactly(2));
}
public async Task Should_restart_queue_reader_when_lock_is_lost()
{
//arrange
var handle = new Mock <ISingletonLockHandle>();
var lockManager = new Mock <ISingletonLockManager>();
lockManager.Setup(x => x.TryLockAsync(It.IsAny <string>(), TimeSpan.FromSeconds(60), CancellationToken.None))
.ReturnsAsync(handle.Object);
handle.SetupSequence(x => x.RenewAsync(It.IsAny <ILog>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(true)
.Throws(new Exception())
.ReturnsAsync(true);
var underlyingReceiver = new Mock <IChannelReceiver>();
underlyingReceiver.Setup(x => x.Settings).Returns(new Mock <IProcessingSettings>().Object);
var singletonChannelReceiver = new SingletonChannelReceiver(underlyingReceiver.Object, lockManager.Object, Mock.Of <ILog>())
{
TimerInterval = TimeSpan.FromSeconds(1),
LockRefreshInterval = TimeSpan.FromSeconds(1)
};
//act
await singletonChannelReceiver.StartAsync(CancellationToken.None);
await Task.Delay(2000);
//assert
underlyingReceiver.Verify(x => x.StartAsync(It.IsAny <CancellationToken>()), Times.Exactly(2));
}
private IChannelReceiver GetQueueReaderStarter(IChannelReceiver channelReceiver, Type type)
{
if (typeof(ISingletonProcessor).IsAssignableFrom(type))
{
if (_configuration.SingletonLockManager == null)
{
throw new SingletonLockManagerMissingException();
}
ConsoleWriter.WriteLine($"Setting {type.Name} in Singleton mode");
var singletonStarter = new SingletonChannelReceiver(channelReceiver, _configuration.SingletonLockManager, _configuration.Log);
return(singletonStarter);
}
return(channelReceiver);
}
private IChannelReceiver WrapSingletonReceiver(IChannelReceiver channelReceiver, Type type)
{
if (typeof(ISingletonProcessor).IsAssignableFrom(type))
{
if (_configuration.SingletonLockManager == null)
{
throw new SingletonLockManagerMissingException("There is no ISingletonLockManager specified, you cannot use the ISingletonProcessor directive without one");
}
ConsoleWriter.WriteLine($"Setting {type.Name} in Singleton mode");
var singletonStarter = new SingletonChannelReceiver(channelReceiver, _configuration.SingletonLockManager, _configuration.Log);
return(singletonStarter);
}
return(channelReceiver);
}
public void Should_override_singleton_impacted_settings()
{
//arrange
var lockManager = new Mock <ISingletonLockManager>();
var underlyingReader = new Mock <IChannelReceiver>();
underlyingReader.Setup(x => x.Settings).Returns(new SingletonHorrificSettings());
//act
var starter = new SingletonChannelReceiver(underlyingReader.Object, lockManager.Object, Mock.Of <ILog>())
{
TimerIntervalMs = 1000
};
//assert
starter.Settings.PrefetchCount.Should().Be(0);
starter.Settings.MaxConcurrentCalls.Should().Be(1);
starter.Settings.MessageLockTimeout.Should().Be(TimeSpan.MaxValue);
starter.Settings.DeadLetterDeliveryLimit.Should().Be(1);
}
