Example #1
0
        public async Task honor_max_queue_size()
        {
            var cts                    = new CancellationTokenSource(10000);
            var maxQueueSize           = 2;
            var mockQueueAwaiter       = new Mock <IQueueAwaiter>();
            var queue                  = new ResolutionQueue(mockQueueAwaiter.Object, maxQueueSize);
            var streamEvent1           = new ResolutionStreamEvent(null, new StreamEvent(null, 0, null, null, new byte[] { }));
            var streamEvent2           = new ResolutionStreamEvent(null, new StreamEvent(null, 0, null, null, new byte[] { }));
            var streamEvent3           = new ResolutionStreamEvent(null, new StreamEvent(null, 0, null, null, new byte[] { }));
            var enqueueuSignalSetCount = 0;
            var awaitingDequeueSignal  = new ManualResetEventSlim(true);
            var mockDequeueSignal      = new ManualResetEventSlim(false);

            mockQueueAwaiter.Setup(x => x.SetEnqueueSignal()).Callback(() => enqueueuSignalSetCount++);
            mockQueueAwaiter.Setup(x => x.AwaitDequeueSignalAsync()).Callback(() => awaitingDequeueSignal.Set()).Returns(mockDequeueSignal.WaitHandle.AsTask());

            await queue.EnqueueWithWaitAsync(streamEvent1, cts.Token);

            await queue.EnqueueWithWaitAsync(streamEvent2, cts.Token);

            var enqueueTask = queue.EnqueueWithWaitAsync(streamEvent3, cts.Token);

            await Task.WhenAny(new[] { awaitingDequeueSignal.WaitHandle.AsTask(), cts.Token.WaitHandle.AsTask() });

            if (cts.Token.IsCancellationRequested)
            {
                throw new TimeoutException();
            }

            Assert.Equal(2, enqueueuSignalSetCount);
            Assert.Equal(maxQueueSize, queue.QueueCount);

            ResolutionStreamEvent se1;

            queue.TryDequeue(out se1);
            Assert.Equal(maxQueueSize - 1, queue.QueueCount);

            mockDequeueSignal.Set();

            await Task.WhenAny(new[] { enqueueTask, cts.Token.WaitHandle.AsTask() });

            if (cts.Token.IsCancellationRequested)
            {
                throw new TimeoutException();
            }

            Assert.Equal(maxQueueSize, queue.QueueCount);
        }
Example #2
0
        public async Task enqueue_and_dequeue_single_item()
        {
            var cts              = new CancellationTokenSource(10000);
            var maxQueueSize     = 1;
            var mockQueueAwaiter = new Mock <IQueueAwaiter>();
            var queue            = new ResolutionQueue(mockQueueAwaiter.Object, maxQueueSize);
            var streamEvent      = new ResolutionStreamEvent(null, new StreamEvent(null, 0, null, null, new byte[] { }));

            await queue.EnqueueWithWaitAsync(streamEvent, cts.Token);

            ResolutionStreamEvent dequeuedStreamEvent;

            var tryResult = queue.TryDequeue(out dequeuedStreamEvent);

            Assert.True(tryResult);
            Assert.Equal(streamEvent, dequeuedStreamEvent);
        }
        public async Task resolve_stream_event_with_link_and_send_to_sorting_manager()
        {
            var cts                 = new CancellationTokenSource(10000);
            var mockResolver        = new Mock <IBusinessEventResolver>();
            var mockQueue           = new Mock <IResolutionQueue>();
            var mockSortingManager  = new Mock <ISortingManager>();
            var manager             = new ResolutionManager(NullStandardLogger.Instance, mockResolver.Object, null, mockQueue.Object, mockSortingManager.Object);
            var regionId            = "r";
            var streamId            = "str";
            var position            = 1;
            var subStreamId         = "sub";
            var subPosition         = 20;
            var eventType           = "x";
            var data                = new byte[] { };
            var streamEvent         = new ResolutionStreamEvent(regionId, new StreamEvent(subStreamId, subPosition, new StreamEventLink(streamId, position), eventType, data));
            var streamEventDequeued = false;
            var mockBusinessEvent   = new Mock <IBusinessEvent>();

            mockResolver.Setup(x => x.CanResolve(eventType)).Returns(true);
            mockResolver.Setup(x => x.Resolve(eventType, data)).Returns(mockBusinessEvent.Object);
            mockQueue.Setup(x => x.TryDequeue(out streamEvent)).Returns(!streamEventDequeued).Callback(() => streamEventDequeued = true);
            mockSortingManager
            .Setup(x => x.ReceiveSubscriberEventAsync(It.IsAny <SubscriberEvent>(), It.IsAny <CancellationToken>()))
            .Callback(() => cts.Cancel())
            .Returns(Task.CompletedTask);

            await manager.ManageAsync(cts.Token);

            mockSortingManager.Verify(x => x.ReceiveSubscriberEventAsync(
                                          It.Is <SubscriberEvent>(e =>
                                                                  e.RegionId == regionId &&
                                                                  e.StreamId == streamId && e.Position == position &&
                                                                  e.SubscriptionStreamId == subStreamId && e.SubscriptionPosition == subPosition &&
                                                                  e.EventType == eventType &&
                                                                  e.ResolvedEvent == mockBusinessEvent.Object
                                                                  ),
                                          cts.Token
                                          ));
        }
Example #4
0
        public async Task set_queue_signals()
        {
            var cts              = new CancellationTokenSource(10000);
            var maxQueueSize     = 1;
            var mockQueueAwaiter = new Mock <IQueueAwaiter>();
            var queue            = new ResolutionQueue(mockQueueAwaiter.Object, maxQueueSize);
            var streamEvent      = new ResolutionStreamEvent(null, new StreamEvent(null, 0, null, null, new byte[] { }));

            ResolutionStreamEvent se1;

            queue.TryDequeue(out se1);

            mockQueueAwaiter.VerifyNoOtherCalls();

            await queue.EnqueueWithWaitAsync(streamEvent, cts.Token);

            mockQueueAwaiter.Verify(x => x.SetEnqueueSignal());
            mockQueueAwaiter.VerifyNoOtherCalls();

            ResolutionStreamEvent se2;

            queue.TryDequeue(out se2);
            mockQueueAwaiter.Verify(x => x.SetDequeueSignal());
        }