public void Queue_should_dequeue_item_once()
{
var queue = new OutgoingQueue<int>(10);
queue.Enqueue(1);
queue.Enqueue(2);
Assert.Equal(new[] { 1 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None));
Assert.Equal(new[] { 2 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None));
}
public void Queue_should_dequeue_item_once()
{
var queue = new OutgoingQueue <int>(10);
queue.Enqueue(1);
queue.Enqueue(2);
Assert.Equal(new[] { 1 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None));
Assert.Equal(new[] { 2 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None));
}
public void Queue_should_override_old_items_if_limit_is_reached()
{
var maxCapacity = 10;
var queue = new OutgoingQueue<int>(maxCapacity);
var all = Enumerable.Range(0, maxCapacity * 2).ToArray();
foreach (var i in all)
queue.Enqueue(i);
var actual = queue.Dequeue(queue.Count, TimeSpan.Zero, CancellationToken.None);
var expected = all.Skip(all.Length - maxCapacity).ToArray();
Assert.Equal(expected, actual);
}
public bool Queue(string message)
{
if (OutgoingQueue.Count == 0)
{
SetupOutGoing(message);
}
else
{
OutgoingQueue.Enqueue(message);
}
return(true);
}
public void Queue_should_return_immediately_a_bucket_if_there_is_enough_elements_to_fill_it()
{
var maxCapacity = 1000;
var bucketSize = 500;
var queue = new OutgoingQueue<int>(maxCapacity);
for (var i = 0; i < maxCapacity; i++)
queue.Enqueue(i);
var watch = Stopwatch.StartNew();
var items = queue.Dequeue(bucketSize, TimeSpan.FromSeconds(2), CancellationToken.None);
watch.Stop();
Assert.Equal(bucketSize, items.Length);
Assert.True(watch.Elapsed < TimeSpan.FromSeconds(1), "watch.Elapsed < TimeSpan.FromSeconds(1)");
}
public void Queue_should_override_old_items_if_limit_is_reached()
{
var maxCapacity = 10;
var queue = new OutgoingQueue <int>(maxCapacity);
var all = Enumerable.Range(0, maxCapacity * 2).ToArray();
foreach (var i in all)
{
queue.Enqueue(i);
}
var actual = queue.Dequeue(queue.Count, TimeSpan.Zero, CancellationToken.None);
var expected = all.Skip(all.Length - maxCapacity).ToArray();
Assert.Equal(expected, actual);
}
public void Queue_should_return_available_items_if_timeout_reached()
{
var bucketSize = 500;
var queue = new OutgoingQueue<int>(bucketSize + 1);
var availableItemsCount = bucketSize - 1;
for (var i = 0; i < availableItemsCount; i++)
queue.Enqueue(i);
var timeout = TimeSpan.FromMilliseconds(500);
var watch = Stopwatch.StartNew();
var items = queue.Dequeue(bucketSize, timeout, CancellationToken.None);
watch.Stop();
Assert.Equal(availableItemsCount, items.Length);
Assert.True(watch.Elapsed > (timeout - AcceptableTimeDelta).Duration(), $"Expected full timeout! Elapsed time: {watch.Elapsed}");
}
public void Queue_should_return_available_items_if_cancelled()
{
var bucketSize = 500;
var queue = new OutgoingQueue<int>(bucketSize + 1);
var availableItemsCount = bucketSize - 1;
for (var i = 0; i < availableItemsCount; i++)
queue.Enqueue(i);
var timeout = TimeSpan.FromMilliseconds(500);
var watch = Stopwatch.StartNew();
var maxWaitTime = TimeSpan.FromSeconds(5);
var items = queue.Dequeue(bucketSize, maxWaitTime, new CancellationTokenSource(timeout).Token);
watch.Stop();
Assert.Equal(availableItemsCount, items.Length);
Assert.True((watch.Elapsed - timeout).Duration() < maxWaitTime, $"Expected task cancellation before {maxWaitTime}");
}
public void Queue_should_return_immediately_a_bucket_if_there_is_enough_elements_to_fill_it()
{
var maxCapacity = 1000;
var bucketSize = 500;
var queue = new OutgoingQueue <int>(maxCapacity);
for (var i = 0; i < maxCapacity; i++)
{
queue.Enqueue(i);
}
var watch = Stopwatch.StartNew();
var items = queue.Dequeue(bucketSize, TimeSpan.FromSeconds(2), CancellationToken.None);
watch.Stop();
Assert.Equal(bucketSize, items.Length);
Assert.True(watch.Elapsed < TimeSpan.FromSeconds(1), "watch.Elapsed < TimeSpan.FromSeconds(1)");
}
public void Queue_should_return_available_items_if_timeout_reached()
{
var bucketSize = 500;
var queue = new OutgoingQueue <int>(bucketSize + 1);
var availableItemsCount = bucketSize - 1;
for (var i = 0; i < availableItemsCount; i++)
{
queue.Enqueue(i);
}
var timeout = TimeSpan.FromMilliseconds(500);
var watch = Stopwatch.StartNew();
var items = queue.Dequeue(bucketSize, timeout, CancellationToken.None);
watch.Stop();
Assert.Equal(availableItemsCount, items.Length);
Assert.True(watch.Elapsed > (timeout - AcceptableTimeDelta).Duration(), $"Expected full timeout! Elapsed time: {watch.Elapsed}");
}
public void Queue_should_return_available_items_if_cancelled()
{
var bucketSize = 500;
var queue = new OutgoingQueue <int>(bucketSize + 1);
var availableItemsCount = bucketSize - 1;
for (var i = 0; i < availableItemsCount; i++)
{
queue.Enqueue(i);
}
var timeout = TimeSpan.FromMilliseconds(500);
var watch = Stopwatch.StartNew();
var maxWaitTime = TimeSpan.FromSeconds(5);
var items = queue.Dequeue(bucketSize, maxWaitTime, new CancellationTokenSource(timeout).Token);
watch.Stop();
Assert.Equal(availableItemsCount, items.Length);
Assert.True((watch.Elapsed - timeout).Duration() < maxWaitTime, $"Expected task cancellation before {maxWaitTime}");
}
public void RecordEndpointStatistics(EndpointIdentity identity, EndpointMetadata metadata, EndpointHealth stats)
{
_statsQueue.Enqueue(Tuple.Create(identity, metadata, stats));
}
public void UpdateHealth(Guid endpointId, EndpointHealth endpointHealth)
{
_outgoingQueue.Enqueue(new EndpointHealthUpdate(endpointId, endpointHealth));
}
