public void Test_TryGet_FromEmptyBuffer(int capacity) { using (StandardTaskBuffer buffer = new StandardTaskBuffer(capacity)) { Assert.IsNull(buffer.TryGetNextTask()); } }
public void Test_CanGet_FromNonEmptyBuffer(int capacity) { using (StandardTaskBuffer buffer = new StandardTaskBuffer(capacity)) { //Add some items int actualItemNumber = ProduceItemNumber(capacity); List <IQueuedTaskToken> addedTasks = new List <IQueuedTaskToken>(); for (int i = 0; i < actualItemNumber; i++) { addedTasks.Add(new MockQueuedTaskToken(Guid.NewGuid())); buffer.TryAddNewTask(addedTasks[i]); } for (int i = 0; i < actualItemNumber; i++) { IQueuedTaskToken queuedTaskToken = buffer.TryGetNextTask(); Assert.NotNull(queuedTaskToken); Assert.IsTrue(addedTasks.Any(t => t.DequeuedTask.Id == queuedTaskToken.DequeuedTask.Id)); } Assert.IsFalse(buffer.IsFull); Assert.IsFalse(buffer.IsCompleted); } }
public async Task Test_CanPoll(int bufferCapacity, int numberOfTasks) { TaskProcessingOptions processingOpts = TestOptions.GetDefaultTaskProcessingOptions(); using (StandardTaskBuffer taskBuffer = new StandardTaskBuffer(bufferCapacity)) using (MockTaskQueueConsumer taskQueue = new MockTaskQueueConsumer(numberOfTasks, new UtcNowTimestampProvider())) using (StandardTaskPoller poller = new StandardTaskPoller(processingOpts, taskQueue, taskBuffer)) { TestBufferConsumer consumer = new TestBufferConsumer(taskBuffer); await poller.StartAsync(); //Poller is filling up the buffer. //We need to check the buffer to see whether // the poller produced the appropriate data consumer.ConsumeBuffer(); taskQueue.WaitForQueueToBeDepleted(); await poller.StopAync(); consumer.WaitForBufferToBeConsumed(); Assert.IsFalse(taskBuffer.HasTasks); Assert.IsTrue(taskBuffer.IsCompleted); consumer.AssertMatchesProducedTasks(taskQueue .DequeuedTasksHistory); } }
public void Test_DefaultTaskBuffer_InitialStateIsCorrect(int capacity) { using (StandardTaskBuffer buffer = new StandardTaskBuffer(capacity)) { Assert.IsFalse(buffer.HasTasks); Assert.IsFalse(buffer.IsFull); Assert.AreEqual(capacity, buffer.Capacity); Assert.IsFalse(buffer.IsCompleted); } }
public void Test_CanRaiseItemAdditionEvents() { bool handlerCalled = false; using (StandardTaskBuffer buffer = new StandardTaskBuffer(10)) { buffer.QueuedTaskAdded += (s, e) => handlerCalled = true; buffer.TryAddNewTask(new MockQueuedTaskToken(Guid.NewGuid())); } Assert.IsTrue(handlerCalled); }
public void Test_CanAdd_NonFullBuffer(int capacity) { using (StandardTaskBuffer buffer = new StandardTaskBuffer(capacity)) { for (int i = 0; i < buffer.Capacity; i++) { Assert.IsTrue(buffer.TryAddNewTask(new MockQueuedTaskToken(Guid.NewGuid()))); } Assert.AreEqual(buffer.Capacity, buffer.Count); Assert.IsTrue(buffer.IsFull); Assert.IsFalse(buffer.IsCompleted); } }
public void Test_TryAdd_ToFullBuffer(int capacity) { using (StandardTaskBuffer buffer = new StandardTaskBuffer(capacity)) { //Fill buffer for (int i = 0; i < buffer.Capacity; i++) { buffer.TryAddNewTask(new MockQueuedTaskToken(Guid.NewGuid())); } //Now attempt to add one more Assert.IsFalse(buffer.TryAddNewTask(new MockQueuedTaskToken(Guid.NewGuid()))); } }
public async Task Test_CanStartStop() { TaskProcessingOptions processingOpts = TestOptions.GetDefaultTaskProcessingOptions(); using (StandardTaskBuffer taskBuffer = new StandardTaskBuffer(100)) using (MockTaskQueueConsumer taskQueue = new MockTaskQueueConsumer(0, new UtcNowTimestampProvider())) using (StandardTaskPoller poller = new StandardTaskPoller(processingOpts, taskQueue, taskBuffer)) { await poller.StartAsync(); Assert.IsTrue(poller.IsRunning); Assert.IsTrue(taskQueue.IsReceivingNewTaskUpdates); await poller.StopAync(); Assert.IsFalse(poller.IsRunning); Assert.IsFalse(taskQueue.IsReceivingNewTaskUpdates); } }
public void Test_CanCompleteAdding(int capacity) { using (StandardTaskBuffer buffer = new StandardTaskBuffer(capacity)) { int actualItemNumber = ProduceItemNumber(capacity); for (int i = 0; i < actualItemNumber; i++) { Assert.IsTrue(buffer.TryAddNewTask(new MockQueuedTaskToken(Guid.NewGuid()))); } //Complete adding buffer.CompleteAdding(); if (buffer.Count > 0) { Assert.IsFalse(buffer.IsCompleted); } else { Assert.IsTrue(buffer.IsCompleted); } //We can no longer add items Assert.IsFalse(buffer.TryAddNewTask(new MockQueuedTaskToken(Guid.NewGuid()))); //We must be able to retrieve the other items for (int i = 0; i < actualItemNumber; i++) { Assert.NotNull(buffer.TryGetNextTask()); } //Now it must be marked as completed Assert.IsTrue(buffer.IsCompleted); } }
public void Test_ConsumerProducerScenario(int nProducers, int nConsumers) { Task coordinator; Task[] allProducers = new Task[nProducers]; Task[] allConsumers = new Task[nConsumers]; int expectedTotal = 0; ConcurrentBag <IQueuedTaskToken> processedTasks = new ConcurrentBag <IQueuedTaskToken>(); using (StandardTaskBuffer buffer = new StandardTaskBuffer(10)) { for (int iProducer = 0; iProducer < nProducers; iProducer++) { allProducers[iProducer] = Task.Run(() => { //Generate a number of items to produce // and add that to the expected total int nItems = new Random().Next(1, 100); Interlocked.Add(ref expectedTotal, nItems); while (nItems > 0) { bool isAdded = buffer.TryAddNewTask(new MockQueuedTaskToken(Guid.NewGuid())); if (isAdded) { nItems--; } else { Task.Delay(10).Wait(); } } }); } for (int iConsumer = 0; iConsumer < nConsumers; iConsumer++) { allConsumers[iConsumer] = Task.Run(() => { //Consumers run until the buffer is completed: // - marked as completed with respect to additons // AND // - has no more items while (!buffer.IsCompleted) { IQueuedTaskToken queuedTaskToken = buffer.TryGetNextTask(); if (queuedTaskToken != null) { processedTasks.Add(queuedTaskToken); } else { Task.Delay(10).Wait(); } } }); } coordinator = Task.Run(() => { //The coordinator waits for all producers // to finish and then marks buffer // addition operations as being completed Task.WaitAll(allProducers); buffer.CompleteAdding(); }); //Wait for all threads to stop Task.WaitAll(coordinator); Task.WaitAll(allConsumers); //Check that: // a) we have the exact number of items we added // b) there are no items that have been processed two times Assert.AreEqual(expectedTotal, processedTasks.Count); foreach (IQueuedTaskToken queuedTaskToken in processedTasks) { Assert.AreEqual(1, processedTasks.Count(t => t.DequeuedTask.Id == queuedTaskToken.DequeuedTask.Id)); } } }
public async Task Test_CanWork(int bufferCapacity, int workerCount, int numberOfTasks) { ConcurrentBag <IQueuedTaskToken> processedTaskTokens = new ConcurrentBag <IQueuedTaskToken>(); TaskProcessingOptions processingOpts = TestOptions.GetDefaultTaskProcessingOptions(); Mock <IExecutionPerformanceMonitor> executionPerformanceMonitorMock = new Mock <IExecutionPerformanceMonitor>(); Mock <ITaskQueueProducer> producerMock = new Mock <ITaskQueueProducer>(MockBehavior.Loose); Mock <ITaskResultQueue> resultQueueMock = new Mock <ITaskResultQueue>(MockBehavior.Loose); List <StandardTaskWorker> workers = new List <StandardTaskWorker>(); executionPerformanceMonitorMock.Setup(m => m.ReportExecutionTimeAsync( It.IsIn(mPayloadTypes.Select(t => t.FullName).ToArray()), It.IsAny <long>(), It.IsAny <int>())); resultQueueMock.Setup(rq => rq.PostResultAsync(It.IsAny <IQueuedTaskToken>())) .Callback <IQueuedTaskToken>(t => processedTaskTokens.Add(t)); //TODO: must also test that, for failed tasks that can be re-posted, // the tasks is actually reposted using (StandardTaskBuffer taskBuffer = new StandardTaskBuffer(bufferCapacity)) { TestBufferProducer producer = new TestBufferProducer(taskBuffer, mPayloadTypes); for (int i = 0; i < workerCount; i++) { workers.Add(new StandardTaskWorker(processingOpts, taskBuffer, CreateTaskExecutorRegistry(), executionPerformanceMonitorMock.Object, producerMock.Object, resultQueueMock.Object)); } foreach (StandardTaskWorker w in workers) { await w.StartAsync(); } await producer.ProduceTasksAsync(numberOfTasks); while (!taskBuffer.IsCompleted) { await Task.Delay(50); } await Task.Delay(250); foreach (StandardTaskWorker w in workers) { await w.StopAync(); } foreach (StandardTaskWorker w in workers) { w.Dispose(); } producer.AssertMatchesProcessedTasks(processedTaskTokens); executionPerformanceMonitorMock.VerifyAll(); } }