예제 #1
0
        public async Task OnWorkSucceededAsync_Sync()
        {
            var dispatchResult = new QueueDispatchResult()
            {
                EnqueuedEventsAsyncProcessed = new List <IAsyncEventQueueRecord>()
                {
                },
                EnqueuedEventsSyncProcessed = new List <IAsyncEventQueueRecord>()
                {
                    new FakeAsyncEventQueueRecord()
                    {
                        EventId = Guid.NewGuid(), EventMessage = messages[0], Id = Guid.NewGuid(), QueueName = "queue2", SequenceNumber = 1
                    }
                }
            };

            asyncEventQueueDispatcher.DispatchToQueuesAsync(null, null, null).ReturnsForAnyArgs(dispatchResult);

            await sut.HandleAsync(messages[0], CancellationToken.None);

            await sut.OnWorkSucceededAsync(unitOfWork);

            asyncEventProcessor.DidNotReceiveWithAnyArgs().EnqueueForAsyncProcessingAsync(null, null);

            asyncEventProcessor.Received(1).ProcessSynchronously(
                Arg.Is <IReadOnlyCollection <IAsyncEventQueueRecord> >(x =>
                                                                       x.SequenceEqual(dispatchResult.EnqueuedEventsSyncProcessed)));
        }
예제 #2
0
        public async Task OnWorkSucceededAsync_Dispatches()
        {
            var dispatchResult = new QueueDispatchResult()
            {
                EnqueuedEventsAsyncProcessed = new List <IAsyncEventQueueRecord>()
                {
                },
                EnqueuedEventsSyncProcessed = new List <IAsyncEventQueueRecord>()
                {
                }
            };

            asyncEventQueueDispatcher.DispatchToQueuesAsync(null, null, null).ReturnsForAnyArgs(dispatchResult);

            IEnumerable <IEventMessage> dispatchedEvents = new List <IEventMessage>();

            asyncEventQueueDispatcher.WhenForAnyArgs(x => x.DispatchToQueuesAsync(null, null, null))
            .Do(ci =>
            {
                dispatchedEvents = ci.ArgAt <IEnumerable <IEventMessage> >(0).ToList();
            });

            await sut.HandleAsync(messages[0], CancellationToken.None);

            await sut.HandleAsync(messages[1], CancellationToken.None);

            await sut.OnWorkSucceededAsync(unitOfWork);

            asyncEventQueueDispatcher.Received(1).DispatchToQueuesAsync(Arg.Any <IEnumerable <IEventMessage> >(), null, null);
            dispatchedEvents.Should().BeEquivalentTo(messages);
            asyncEventProcessor.DidNotReceiveWithAnyArgs().EnqueueForAsyncProcessingAsync(null, null);
            asyncEventProcessor.DidNotReceiveWithAnyArgs().ProcessSynchronously(null);
        }
        public async Task DispatchToQueuesAsync_ReturnsEventRecords()
        {
            asyncEventQueueManager.CommitAsync().Returns(new List <IAsyncEventQueueRecord>()
            {
                new FakeAsyncEventQueueRecord()
                {
                    EventId = Guid.NewGuid(), EventMessage = eventMessages[0],
                    Id      = Guid.NewGuid(), QueueName = "queue2", SequenceNumber = 1
                },
                new FakeAsyncEventQueueRecord()
                {
                    EventId = Guid.NewGuid(), EventMessage = eventMessages[1],
                    Id      = Guid.NewGuid(), QueueName = "queue3", SequenceNumber = 1
                }
            });

            QueueDispatchResult result = await sut.DispatchToQueuesAsync(eventMessages, "eventSource", "checkpoint");

            result.EnqueuedEventsAsyncProcessed.Should().HaveCount(1);
            result.EnqueuedEventsAsyncProcessed.Should().Contain(x => x.EventMessage == eventMessages[1] &&
                                                                 x.QueueName == "queue3");
            result.EnqueuedEventsSyncProcessed.Should().HaveCount(1);
            result.EnqueuedEventsSyncProcessed.Should().Contain(x => x.EventMessage == eventMessages[0] &&
                                                                x.QueueName == "queue2");
        }