Beispiel #1
0
        public void be_able_to_read_events_slice_at_time()
        {
            const string stream = "read_all_events_backward_should_be_able_to_read_events_slice_at_time";

            using (var store = EventStoreConnection.Create())
            {
                store.Connect(Node.TcpEndPoint);
                var create = store.CreateStreamAsync(stream, false, new byte[0]);
                Assert.DoesNotThrow(create.Wait);

                var testEvents = Enumerable.Range(0, 10).Select(x => new TestEvent((x + 1).ToString())).ToArray();

                var write = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write.Wait);

                var            all      = new List <RecordedEvent>();
                var            position = Position.End;
                AllEventsSlice slice;

                while ((slice = store.ReadAllEventsBackward(position, 5)).Events.Any())
                {
                    all.AddRange(slice.Events);
                    position = slice.Position;
                }

                Assert.That(TestEventsComparer.Equal(testEvents.Reverse().ToArray(), all.Take(testEvents.Length).ToArray()));
            }
        }
Beispiel #2
0
        public void return_events_in_same_order_as_written()
        {
            const string stream = "read_all_events_forward_should_return_events_in_same_order_as_written";

            using (var store = EventStoreConnection.Create())
            {
                store.Connect(Node.TcpEndPoint);
                var testEvents = Enumerable.Range(0, 5).Select(x => new TestEvent((x + 1).ToString())).ToArray();

                var create1 = store.CreateStreamAsync(stream + 1, false, new byte[0]);
                Assert.DoesNotThrow(create1.Wait);

                var write5to1 = store.AppendToStreamAsync(stream + 1, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write5to1.Wait);

                var create2 = store.CreateStreamAsync(stream + 2, false, new byte[0]);
                Assert.DoesNotThrow(create2.Wait);

                var write5to2 = store.AppendToStreamAsync(stream + 2, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write5to2.Wait);

                var read = store.ReadAllEventsForwardAsync(Position.Start, testEvents.Length * 2 + 2);
                Assert.DoesNotThrow(read.Wait);

                Assert.That(TestEventsComparer.Equal(testEvents.Concat(testEvents).ToArray(),
                                                     read.Result.Events.Skip(1).Take(testEvents.Length).Concat(read.Result.Events.Skip(testEvents.Length + 2).Take(testEvents.Length)).ToArray()));
            }
        }
Beispiel #3
0
        public void be_able_to_read_all_one_by_one_and_return_empty_slice_at_last()
        {
            const string stream = "read_all_events_forward_should_be_able_to_read_all_one_by_one_and_return_empty_slice_at_last";

            using (var store = EventStoreConnection.Create())
            {
                store.Connect(Node.TcpEndPoint);
                var create = store.CreateStreamAsync(stream, false, new byte[0]);
                Assert.DoesNotThrow(create.Wait);

                var testEvents = Enumerable.Range(0, 5).Select(x => new TestEvent((x + 1).ToString())).ToArray();

                var write = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write.Wait);

                var            all      = new List <RecordedEvent>();
                var            position = Position.Start;
                AllEventsSlice slice;

                while ((slice = store.ReadAllEventsForward(position, 1)).Events.Any())
                {
                    all.Add(slice.Events.Single());
                    position = slice.Position;
                }

                Assert.That(TestEventsComparer.Equal(testEvents, all.Skip(1).ToArray()));
            }
        }
Beispiel #4
0
        public void recover_from_dropped_subscription_state_using_last_known_position()
        {
            const string stream = "read_all_events_forward_should_recover_from_dropped_subscription_state_using_last_known_position";

            using (var store = EventStoreConnection.Create())
            {
                store.Connect(Node.TcpEndPoint);
                var      catched           = new List <RecordedEvent>();
                Position lastKnonwPosition = null;
                var      dropped           = new AutoResetEvent(false);

                var create = store.CreateStreamAsync(stream, false, new byte[0]);
                Assert.DoesNotThrow(create.Wait);

                store.SubscribeAsync(stream,
                                     (@event, position) =>
                {
                    catched.Add(@event);
                    lastKnonwPosition = position;
                },
                                     () => dropped.Set());


                var testEvents = Enumerable.Range(1, 5).Select(x => new TestEvent(x.ToString())).ToArray();

                var write = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents);
                Assert.That(write.Wait(Timeout));

                store.UnsubscribeAsync(stream);
                Assert.That(dropped.WaitOne(Timeout));

                var write2 = store.AppendToStreamAsync(stream, testEvents.Length, testEvents);
                Assert.That(write2.Wait(Timeout));

                var missed = store.ReadAllEventsForwardAsync(lastKnonwPosition, int.MaxValue);
                Assert.That(missed.Wait(Timeout));

                var expected = testEvents.Concat(testEvents).ToArray();
                var actual   = catched.Concat(missed.Result.Events.Skip(1)).ToArray();//skip 1 because readallforward is inclusive
                Assert.That(TestEventsComparer.Equal(expected, actual));
            }
        }
Beispiel #5
0
        public void return_events_in_reversed_order_compared_to_written()
        {
            const string stream = "read_all_events_backward_should_return_events_in_reversed_order_compared_to_written";

            using (var store = EventStoreConnection.Create())
            {
                store.Connect(Node.TcpEndPoint);
                var testEvents = Enumerable.Range(0, 5).Select(x => new TestEvent((x + 1).ToString())).ToArray();

                var create = store.CreateStreamAsync(stream, false, new byte[0]);
                Assert.DoesNotThrow(create.Wait);

                var write = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents);
                Assert.DoesNotThrow(write.Wait);

                var read = store.ReadAllEventsBackwardAsync(Position.End, testEvents.Length + 1);
                Assert.DoesNotThrow(read.Wait);

                Assert.That(TestEventsComparer.Equal(testEvents.Reverse().ToArray(), read.Result.Events.Take(testEvents.Length).ToArray()));
            }
        }