Beispiel #1
0
        public void when_live_processing_and_disconnected_reconnect_keeps_events_ordered()
        {
            int callCount = 0;

            _connection.HandleReadStreamEventsForwardAsync((stream, start, max) =>
            {
                callCount++;

                var taskCompletionSource = new TaskCompletionSource <StreamEventsSlice>();
                if (callCount == 1)
                {
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count: 0, isEnd: true));
                }
                else if (callCount == 2)
                {
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count: 0, isEnd: true));
                }

                return(taskCompletionSource.Task);
            });

            VolatileEventStoreSubscription volatileEventStoreSubscription = null;
            Action <EventStoreSubscription, SubscriptionDropReason, Exception> innerSubscriptionDrop = null;

            _connection.HandleSubscribeToStreamAsync((stream, raise, drop) =>
            {
                innerSubscriptionDrop          = drop;
                var taskCompletionSource       = new TaskCompletionSource <EventStoreSubscription>();
                volatileEventStoreSubscription = CreateVolatileSubscription(raise, drop, null);
                taskCompletionSource.SetResult(volatileEventStoreSubscription);
                return(taskCompletionSource.Task);
            });

            Assert.That(_subscription.StartAsync().Wait(TimeoutMs));
            Assert.That(_raisedEvents.Count, Is.EqualTo(0));

            Assert.That(innerSubscriptionDrop, Is.Not.Null);
            innerSubscriptionDrop(volatileEventStoreSubscription, SubscriptionDropReason.ConnectionClosed, null);

            Assert.That(_dropEvent.Wait(TimeoutMs));
            _dropEvent.Reset();

            var waitForOutOfOrderEvent = new ManualResetEventSlim();

            callCount = 0;
            _connection.HandleReadStreamEventsForwardAsync((stream, start, max) =>
            {
                callCount++;

                var taskCompletionSource = new TaskCompletionSource <StreamEventsSlice>();
                if (callCount == 1)
                {
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count: 0, isEnd: true));
                }
                else if (callCount == 2)
                {
                    Assert.That(waitForOutOfOrderEvent.Wait(TimeoutMs));
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count: 1, isEnd: true));
                }

                return(taskCompletionSource.Task);
            });

            var event1 = new ClientMessage.ResolvedEvent(new ClientMessage.EventRecord(StreamId, 1, Guid.NewGuid().ToByteArray(), null, 0, 0, null, null, null, null), null, 0, 0);

            _connection.HandleSubscribeToStreamAsync((stream, raise, drop) =>
            {
                var taskCompletionSource = new TaskCompletionSource <EventStoreSubscription>();
                VolatileEventStoreSubscription volatileEventStoreSubscription2 = CreateVolatileSubscription(raise, drop, null);
                taskCompletionSource.SetResult(volatileEventStoreSubscription);

                raise(volatileEventStoreSubscription2, new ResolvedEvent(event1));

                return(taskCompletionSource.Task);
            });


            var reconnectTask = Task.Factory.StartNew(() =>
            {
                _connection.OnConnected(new ClientConnectionEventArgs(_connection, new IPEndPoint(IPAddress.Any, 1)));
            }, TaskCreationOptions.AttachedToParent);

            Assert.That(_raisedEventEvent.Wait(100), Is.False);

            waitForOutOfOrderEvent.Set();

            Assert.That(_raisedEventEvent.Wait(TimeoutMs));

            Assert.That(_raisedEvents[0].OriginalEventNumber, Is.EqualTo(0));
            Assert.That(_raisedEvents[1].OriginalEventNumber, Is.EqualTo(1));

            Assert.That(reconnectTask.Wait(TimeoutMs));
        }
        public void when_live_processing_and_disconnected_reconnect_keeps_events_ordered()
        {
            int callCount = 0;
            _connection.HandleReadStreamEventsForwardAsync((stream, start, max) =>
            {
                callCount++;

                var taskCompletionSource = new TaskCompletionSource<StreamEventsSlice>();
                if (callCount == 1)
                {
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count: 0, isEnd: true));
                }
                else if (callCount == 2)
                {
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count: 0, isEnd: true));
                }

                return taskCompletionSource.Task;
            });

            VolatileEventStoreSubscription volatileEventStoreSubscription = null;
            Action<EventStoreSubscription, SubscriptionDropReason, Exception> innerSubscriptionDrop = null;
            _connection.HandleSubscribeToStreamAsync((stream, raise, drop) =>
            {
                innerSubscriptionDrop = drop;
                var taskCompletionSource = new TaskCompletionSource<EventStoreSubscription>();
                volatileEventStoreSubscription = CreateVolatileSubscription(raise, drop, null);
                taskCompletionSource.SetResult(volatileEventStoreSubscription);
                return taskCompletionSource.Task;
            });

            Assert.That(_subscription.Start().Wait(TimeoutMs));
            Assert.That(_raisedEvents.Count, Is.EqualTo(0));

            Assert.That(innerSubscriptionDrop, Is.Not.Null);
            innerSubscriptionDrop(volatileEventStoreSubscription, SubscriptionDropReason.ConnectionClosed, null);

            Assert.That(_dropEvent.Wait(TimeoutMs));
            _dropEvent.Reset();

            var waitForOutOfOrderEvent = new ManualResetEventSlim();
            callCount = 0;
            _connection.HandleReadStreamEventsForwardAsync((stream, start, max) =>
            {
                callCount++;

                var taskCompletionSource = new TaskCompletionSource<StreamEventsSlice>();
                if (callCount == 1)
                {
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count:0, isEnd: true));
                }
                else if (callCount == 2)
                {
                    Assert.That(waitForOutOfOrderEvent.Wait(TimeoutMs));
                    taskCompletionSource.SetResult(CreateStreamEventsSlice(fromEvent: 0, count: 1, isEnd: true));
                }

                return taskCompletionSource.Task;
            });

            var event1 = new ClientMessage.ResolvedEvent(new ClientMessage.EventRecord(StreamId, 1, Guid.NewGuid().ToByteArray(), null, 0, 0, null, null, null, null), null, 0, 0);
            
            _connection.HandleSubscribeToStreamAsync((stream, raise, drop) =>
            {
                var taskCompletionSource = new TaskCompletionSource<EventStoreSubscription>();
                VolatileEventStoreSubscription volatileEventStoreSubscription2 = CreateVolatileSubscription(raise, drop, null);
                taskCompletionSource.SetResult(volatileEventStoreSubscription);

                raise(volatileEventStoreSubscription2, new ResolvedEvent(event1));
                
                return taskCompletionSource.Task;
            });


            var reconnectTask = Task.Factory.StartNew(() =>
            {
                _connection.OnConnected(new ClientConnectionEventArgs(_connection, new IPEndPoint(IPAddress.Any, 1)));

            }, TaskCreationOptions.AttachedToParent);

            Assert.That(_raisedEventEvent.Wait(100), Is.False);

            waitForOutOfOrderEvent.Set();

            Assert.That(_raisedEventEvent.Wait(TimeoutMs));

            Assert.That(_raisedEvents[0].OriginalEventNumber, Is.EqualTo(0));
            Assert.That(_raisedEvents[1].OriginalEventNumber, Is.EqualTo(1));

            Assert.That(reconnectTask.Wait(TimeoutMs));
        }