Exemple #1
0
        public async Task Test_CanEnqueue_NewTask_Serial()
        {
            Faker faker =
                new Faker();

            ManualResetEvent notificationWaitHandle =
                new ManualResetEvent(false);

            DateTimeOffset postedAt = mDataSource.LastPostedAt
                                      .AddTicks(1);

            PostgreSqlTaskQueueProducer taskQueueProducer =
                CreateTaskQueueProducer(() => postedAt);

            EventHandler <ClearForDequeueEventArgs> handleClearForDequeue = (s, e) =>
            {
                if (e.Reason == ClearForDequeReason.NewTaskPostedNotificationReceived)
                {
                    notificationWaitHandle.Set();
                }
            };

            using (PostgreSqlTaskQueueConsumer taskQueueConsumer =
                       CreateTaskQueueConsumer(() => postedAt))
            {
                taskQueueConsumer.ClearForDequeue +=
                    handleClearForDequeue;

                await taskQueueConsumer
                .StartReceivingNewTaskUpdatesAsync();

                Assert.IsTrue(taskQueueConsumer
                              .IsReceivingNewTaskUpdates);

                //Enqueue task and check result
                IQueuedTask queuedTask = await taskQueueProducer
                                         .EnqueueAsync(payload : new SampleTaskPayload(100),
                                                       source : nameof(Test_CanEnqueue_NewTask_Serial),
                                                       priority : faker.Random.Int(1, 100));

                Assert.NotNull(queuedTask);
                await Assert_ResultAddedOrUpdatedCorrectly(queuedTask);

                notificationWaitHandle.WaitOne();

                await taskQueueConsumer
                .StopReceivingNewTaskUpdatesAsync();

                Assert.IsFalse(taskQueueConsumer
                               .IsReceivingNewTaskUpdates);

                taskQueueConsumer.ClearForDequeue -=
                    handleClearForDequeue;
            }
        }
        public async Task Test_CanStartStopReceivingNewTaskNotificationUpdates()
        {
            ManualResetEvent notificationWaitHandle = new
                                                      ManualResetEvent(false);

            using (PostgreSqlTaskQueueConsumer taskQueue = CreateTaskQueue(() => mDataSource.LastPostedAt))
            {
                taskQueue.ClearForDequeue += (s, e) =>
                                             notificationWaitHandle.Set();

                await taskQueue.StartReceivingNewTaskUpdatesAsync();

                Assert.IsTrue(taskQueue.IsReceivingNewTaskUpdates);

                await SendNewTaskNotificationAsync();

                notificationWaitHandle.WaitOne();

                await taskQueue.StopReceivingNewTaskUpdatesAsync();

                Assert.IsFalse(taskQueue.IsReceivingNewTaskUpdates);
            }
        }
Exemple #3
0
        public async Task Test_CanEnqueue_NewTask_ParallelProducers(int nProducers)
        {
            Faker faker =
                new Faker();

            CountdownEvent notificationWaitHandle =
                new CountdownEvent(nProducers);

            DateTimeOffset postedAt = mDataSource.LastPostedAt
                                      .AddTicks(1);

            PostgreSqlTaskQueueProducer taskQueueProducer =
                CreateTaskQueueProducer(() => postedAt);

            EventHandler <ClearForDequeueEventArgs> handleClearForDequeue = (s, e) =>
            {
                if (e.Reason == ClearForDequeReason.NewTaskPostedNotificationReceived)
                {
                    notificationWaitHandle.Signal();
                }
            };

            Task[] producers = new Task[nProducers];

            using (PostgreSqlTaskQueueConsumer taskQueueConsumer =
                       CreateTaskQueueConsumer(() => postedAt))
            {
                taskQueueConsumer.ClearForDequeue +=
                    handleClearForDequeue;

                await taskQueueConsumer
                .StartReceivingNewTaskUpdatesAsync();

                Assert.IsTrue(taskQueueConsumer
                              .IsReceivingNewTaskUpdates);

                for (int i = 0; i < nProducers; i++)
                {
                    producers[i] = Task.Run(async() =>
                    {
                        //Enqueue task and check result
                        IQueuedTask queuedTask = await taskQueueProducer
                                                 .EnqueueAsync(payload: new SampleTaskPayload(100),
                                                               source: nameof(Test_CanEnqueue_NewTask_ParallelProducers),
                                                               priority: faker.Random.Int(1, 100));

                        Assert.NotNull(queuedTask);
                        await Assert_ResultAddedOrUpdatedCorrectly(queuedTask);
                    });
                }

                notificationWaitHandle.Wait();

                await taskQueueConsumer
                .StopReceivingNewTaskUpdatesAsync();

                Assert.IsFalse(taskQueueConsumer
                               .IsReceivingNewTaskUpdates);

                taskQueueConsumer.ClearForDequeue -=
                    handleClearForDequeue;
            }
        }