public void SetUp()
{
_fakeMonitor = Substitute.For<IMessageMonitor>();
_fakeAmazonBatchSize = 10;
_concurrencyLevel = 20;
_messageProcessingStrategy = new Throttled(_concurrencyLevel, _fakeAmazonBatchSize, _fakeMonitor);
_actionsProcessed = 0;
}
public void SimulatedListenLoop_WhenThrottlingOccurs_CallsMessageMonitor()
{
var actions = BuildFakeIncomingMessages(50);
_messageProcessingStrategy = new Throttled(20, _fakeAmazonBatchSize, _fakeMonitor);
ListenLoopExecuted(actions);
_fakeMonitor.Received().IncrementThrottlingStatistic();
}
public async Task WhenATasksIsAdded_AvailableWorkersIsDecremented()
{
var messageProcessingStrategy = new Throttled(123, _fakeMonitor);
var tcs = new TaskCompletionSource<object>();
messageProcessingStrategy.StartWorker(() => tcs.Task);
Assert.That(messageProcessingStrategy.AvailableWorkers, Is.EqualTo(122));
await AllowTasksToComplete(tcs);
}
public void ChangeMaxAllowedMessagesInFlightAtRuntime_TheChangeIsApplied()
{
var MaxAllowedMessagesInFlight = Substitute.For<Func<int>>();
MaxAllowedMessagesInFlight().Returns(100);
_messageProcessingStrategy = new Throttled(MaxAllowedMessagesInFlight, 10, _fakeMonitor);
MaxAllowedMessagesInFlight().Returns(90);
Assert.That(_messageProcessingStrategy.BlockingThreshold, Is.EqualTo(90 - 10));
}
public async Task SimulatedListenLoop_WhenThrottlingOccurs_CallsMessageMonitor(int messageCount, int capacity)
{
Assert.That(messageCount, Is.GreaterThan(capacity), "To cause throttling, message count must be over capacity");
var fakeMonitor = Substitute.For<IMessageMonitor>();
var messageProcessingStrategy = new Throttled(capacity, fakeMonitor);
var counter = new ThreadSafeCounter();
var actions = BuildFakeIncomingMessages(messageCount, counter);
await ListenLoopExecuted(actions, messageProcessingStrategy);
fakeMonitor.Received().IncrementThrottlingStatistic();
fakeMonitor.Received().HandleThrottlingTime(Arg.Any<long>());
}
public async Task AvailableWorkers_CanReachZero()
{
const int capacity = 10;
var messageProcessingStrategy = new Throttled(capacity, _fakeMonitor);
var tcs = new TaskCompletionSource<object>();
for (int i = 0; i < capacity; i++)
{
messageProcessingStrategy.StartWorker(() => tcs.Task);
}
Assert.That(messageProcessingStrategy.MaxWorkers, Is.EqualTo(capacity));
Assert.That(messageProcessingStrategy.AvailableWorkers, Is.EqualTo(0));
await AllowTasksToComplete(tcs);
}
public async Task SimulatedListenLoop_ProcessedAllMessages(int numberOfMessagesToProcess)
{
var fakeMonitor = Substitute.For<IMessageMonitor>();
var messageProcessingStrategy = new Throttled(ConcurrencyLevel, fakeMonitor);
var counter = new ThreadSafeCounter();
var watch = new Stopwatch();
watch.Start();
var actions = BuildFakeIncomingMessages(numberOfMessagesToProcess, counter);
await ListenLoopExecuted(actions, messageProcessingStrategy);
watch.Stop();
await Task.Yield();
await Task.Delay(2000);
await Task.Yield();
Assert.That(counter.Count, Is.EqualTo(numberOfMessagesToProcess));
}
public void Ctor_WhenMaxAllowedMessagesInFlightIsNearToBatchSize_BlockingThresholdIsNeverNegative(int maxAllowedMessagesInFlight, int maxBatchSize, int expectedBlockingThreshold)
{
_messageProcessingStrategy = new Throttled(maxAllowedMessagesInFlight, maxBatchSize, _fakeMonitor);
Assert.That(_messageProcessingStrategy.BlockingThreshold, Is.EqualTo(expectedBlockingThreshold));
}
public async Task SimulatedListenLoop_WhenThrottlingDoesNotOccur_DoNotCallMessageMonitor(int messageCount, int capacity)
{
Assert.That(messageCount, Is.LessThanOrEqualTo(capacity), "To avoid throttling, message count must be not be over capacity");
var fakeMonitor = Substitute.For<IMessageMonitor>();
var messageProcessingStrategy = new Throttled(capacity, fakeMonitor);
var counter = new ThreadSafeCounter();
var actions = BuildFakeIncomingMessages(messageCount, counter);
await ListenLoopExecuted(actions, messageProcessingStrategy);
fakeMonitor.DidNotReceive().IncrementThrottlingStatistic();
}
public void AvailableWorkers_StartsAtCapacity()
{
var messageProcessingStrategy = new Throttled(123, _fakeMonitor);
Assert.That(messageProcessingStrategy.AvailableWorkers, Is.EqualTo(123));
}
public async Task AvailableWorkers_IsNeverNegative()
{
const int capacity = 10;
var messageProcessingStrategy = new Throttled(capacity, _fakeMonitor);
var tcs = new TaskCompletionSource<object>();
for (int i = 0; i < capacity; i++)
{
messageProcessingStrategy.StartWorker(() => tcs.Task);
Assert.That(messageProcessingStrategy.AvailableWorkers, Is.GreaterThanOrEqualTo(0));
}
await AllowTasksToComplete(tcs);
}