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())); } }
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())); } }
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())); } }
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)); } }
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())); } }