public void CanHaveMultipleWorkers()
{
const int workItemCount = 50;
var latch = new CountDownLatch(workItemCount);
int errorCount = 0;
int abandonCount = 0;
var queue = new InMemoryQueue <SimpleWorkItem>(retries: 1, workItemTimeoutMilliseconds: 50, retryDelayMilliseconds: 0);
Parallel.For(0, workItemCount, i => queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello",
Id = i
}));
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
bool success = latch.Wait(2000);
Assert.True(success, "Failed to receive all work items.");
Task.Delay(50).Wait();
Assert.Equal(workItemCount, queue.Completed + queue.DeadletterCount);
Assert.Equal(errorCount, queue.WorkerErrors);
Assert.Equal(abandonCount + errorCount, queue.Abandoned);
}
public void CanUseQueueWorker() {
var resetEvent = new AutoResetEvent(false);
var queue = new InMemoryQueue<SimpleWorkItem>();
queue.StartWorking(w => {
Assert.Equal("Hello", w.Value.Data);
w.CompleteAsync().Wait();
resetEvent.Set();
});
queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello"
});
Assert.Equal(1, queue.Count);
bool success = resetEvent.WaitOne(250);
Assert.Equal(0, queue.Count);
Assert.Equal(1, queue.Completed);
Assert.True(success, "Failed to receive message.");
Assert.Equal(0, queue.WorkerErrors);
}
public void CanUseQueueWorker()
{
var resetEvent = new AutoResetEvent(false);
var queue = new InMemoryQueue <SimpleWorkItem>();
queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello"
});
queue.StartWorking(w => {
Assert.Equal("Hello", w.Value.Data);
w.CompleteAsync().Wait();
resetEvent.Set();
});
bool success = resetEvent.WaitOne(250);
Assert.Equal(0, queue.Count);
Assert.Equal(1, queue.Completed);
Assert.True(success, "Failed to receive message.");
Assert.Equal(0, queue.WorkerErrors);
}
public void CanAutoCompleteWorker()
{
var resetEvent = new AutoResetEvent(false);
var queue = new InMemoryQueue <SimpleWorkItem>(workItemTimeoutMilliseconds: 100);
queue.StartWorking(w => {
Assert.Equal("Hello", w.Value.Data);
resetEvent.Set();
}, true);
queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello"
});
Assert.Equal(1, queue.Count);
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to recieve message.");
Task.Delay(25).Wait();
Assert.Equal(0, queue.Count);
Assert.Equal(1, queue.Completed);
Assert.Equal(0, queue.WorkerErrors);
}
public void CanAutoCompleteWorker() {
var resetEvent = new AutoResetEvent(false);
var queue = new InMemoryQueue<SimpleWorkItem>(workItemTimeoutMilliseconds: 100);
queue.StartWorking(w => {
Assert.Equal("Hello", w.Value.Data);
resetEvent.Set();
}, true);
queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello"
});
Assert.Equal(1, queue.Count);
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
Task.Delay(25).Wait();
Assert.Equal(0, queue.Count);
Assert.Equal(1, queue.Completed);
Assert.Equal(0, queue.WorkerErrors);
}
public void CanHaveMultipleWorkers() {
const int workItemCount = 50;
var latch = new CountDownLatch(workItemCount);
int errorCount = 0;
int abandonCount = 0;
var queue = new InMemoryQueue<SimpleWorkItem>(retries: 1, workItemTimeoutMilliseconds: 50);
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Parallel.For(0, workItemCount, i => queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello",
Id = i
}));
bool success = latch.Wait(1000);
Assert.True(success, "Failed to receive all work items.");
Task.Delay(50).Wait();
Assert.Equal(workItemCount, queue.Completed + queue.DeadletterCount);
Assert.Equal(errorCount, queue.WorkerErrors);
Assert.Equal(abandonCount + errorCount, queue.Abandoned);
}
