public void handle_paging_between_events_backward() { var numberOfEmptySlicesRead = 0; var filter = Filter.EventType.Prefix("AE"); var sliceStart = Position.End; var read = new List <ResolvedEvent>(); AllEventsSlice slice; do { slice = _conn.FilteredReadAllEventsBackwardAsync(sliceStart, 50, false, filter, maxSearchWindow: 100) .GetAwaiter() .GetResult(); if (slice.Events.Length == 0) { numberOfEmptySlicesRead++; } else { read.AddRange(slice.Events); } sliceStart = slice.NextPosition; } while (!slice.IsEndOfStream); Assert.That(EventDataComparer.Equal( _testEventsA.ReverseEvents(), read.Select(x => x.Event).ToArray())); Assert.AreEqual(100, numberOfEmptySlicesRead); }
public async Task return_events_in_reversed_order_compared_to_written() { var read = await _conn.ReadAllEventsBackwardAsync(Position.End, _testEvents.Length, false); Assert.That(EventDataComparer.Equal(_testEvents.Reverse().ToArray(), read.Events.Select(x => x.Event).ToArray())); }
public void return_events_in_reversed_order_compared_to_written() { var read = _conn.ReadAllEventsBackwardAsync(_endOfEvents, _testEvents.Length, false).Result; Assert.That(EventDataComparer.Equal(_testEvents.Reverse().ToArray(), read.Events.Select(x => x.Event).ToArray())); }
public async Task return_partial_slice_if_not_enough_events() { var read = await _conn.ReadAllEventsBackwardAsync(Position.End, 30, false); Assert.That(read.Events.Length, Is.LessThan(30)); Assert.That(EventDataComparer.Equal(_testEvents.Reverse().ToArray(), read.Events.Take(_testEvents.Length).Select(x => x.Event).ToArray())); }
public async Task return_events_in_same_order_as_written() { var read = await _conn.ReadAllEventsForwardAsync(Position.Start, _testEvents.Length + 10, false); Assert.That(EventDataComparer.Equal( _testEvents.ToArray(), read.Events.Skip(read.Events.Length - _testEvents.Length).Select(x => x.Event).ToArray())); }
public void return_partial_slice_if_not_enough_events() { var read = _conn.ReadAllEventsBackwardAsync(_endOfEvents, 30, false).Result; Assert.That(read.Events.Length, Is.LessThan(30)); Assert.That(EventDataComparer.Equal(_testEvents.Reverse().ToArray(), read.Events.Take(_testEvents.Length).Select(x => x.Event).ToArray())); }
public void return_events_in_same_order_as_written() { var read = _conn.ReadAllEventsForwardAsync(_from, _testEvents.Length + 10, false).Result; Assert.That(EventDataComparer.Equal( _testEvents.ToArray(), read.Events.Skip(read.Events.Length - _testEvents.Length).Select(x => x.Event).ToArray())); }
public void return_partial_slice_if_not_enough_events() { var read = _conn.ReadAllEventsForwardAsync(_from, 30, false).Result; Assert.That(read.Events.Length, Is.LessThan(30)); Assert.That(EventDataComparer.Equal( _testEvents, read.Events.Skip(read.Events.Length - _testEvents.Length).Select(x => x.Event).ToArray())); }
public async Task return_partial_slice_if_not_enough_events() { var read = await _conn.ReadAllEventsForwardAsync(Position.Start, 40, false); Assert.That(read.Events.Length, Is.LessThan(40)); Assert.That(EventDataComparer.Equal( _testEvents, read.Events.Skip(read.Events.Length - _testEvents.Length).Select(x => x.Event).ToArray())); }
public async Task only_return_events_with_a_given_stream_prefix() { var filter = Filter.StreamId.Prefix("stream-a"); var read = await _conn.FilteredReadAllEventsBackwardAsync(Position.End, 4096, false, filter, 4096); Assert.That(EventDataComparer.Equal( _testEvents.EvenEvents().ReverseEvents(), read.Events.Select(x => x.Event).ToArray())); }
public async Task only_return_events_that_satisfy_a_given_stream_regex() { var filter = Filter.StreamId.Regex(new Regex(@"^.*m-b.*$")); var read = await _conn.FilteredReadAllEventsBackwardAsync(Position.End, 4096, false, filter, 4096); Assert.AreEqual(ReadDirection.Backward, read.ReadDirection); Assert.That(EventDataComparer.Equal( _testEvents.OddEvents().ReverseEvents(), read.Events.Select(x => x.Event).ToArray())); }
public async Task only_return_events_with_a_given_event_prefix() { var filter = Filter.EventType.Prefix("AE"); // Have to order the events as we are writing to two streams and can't guarantee ordering var read = await _conn.FilteredReadAllEventsForwardAsync(Position.Start, 1000, false, filter, 1000); Assert.That(EventDataComparer.Equal( _testEvents.Where(e => e.Type == "AEvent").OrderBy(x => x.EventId).ToArray(), read.Events.Select(x => x.Event).OrderBy(x => x.EventId).ToArray())); }
public async Task only_return_events_that_satisfy_a_given_event_regex() { var filter = Filter.EventType.Regex(new Regex(@"^.*BEv.*$")); // Have to order the events as we are writing to two streams and can't guarantee ordering var read = await _conn.FilteredReadAllEventsBackwardAsync(Position.End, 4096, false, filter, 4096); Assert.AreEqual(ReadDirection.Backward, read.ReadDirection); Assert.That(EventDataComparer.Equal( _testEvents.Where(e => e.Type == "BEvent").OrderBy(x => x.EventId).ToArray(), read.Events.Select(x => x.Event).OrderBy(x => x.EventId).ToArray())); }
public void be_able_to_read_all_one_by_one_until_end_of_stream() { var all = new List <RecordedEvent>(); var position = _from; AllEventsSlice slice; while (!(slice = _conn.ReadAllEventsForwardAsync(position, 1, false).Result).IsEndOfStream) { all.Add(slice.Events.Single().Event); position = slice.NextPosition; } Assert.That(EventDataComparer.Equal(_testEvents, all.Skip(all.Count - _testEvents.Length).ToArray())); }
public void be_able_to_read_all_one_by_one_until_end_of_stream() { var all = new List <RecordedEvent>(); var position = Position.End; AllEventsSlice slice; while (!(slice = _conn.ReadAllEventsBackward(position, 1, false)).IsEndOfStream) { all.Add(slice.Events.Single().Event); position = slice.NextPosition; } Assert.That(EventDataComparer.Equal(_testEvents.Reverse().ToArray(), all.Take(_testEvents.Length).ToArray())); }
public void be_able_to_read_events_slice_at_time() { var all = new List <RecordedEvent>(); var position = Position.End; AllEventsSlice slice; while (!(slice = _conn.ReadAllEventsBackward(position, 5, false)).IsEndOfStream) { all.AddRange(slice.Events.Select(x => x.Event)); position = slice.NextPosition; } Assert.That(EventDataComparer.Equal(_testEvents.Reverse().ToArray(), all.Take(_testEvents.Length).ToArray())); }
public void be_able_to_read_events_slice_at_time() { var all = new List <RecordedEvent>(); var position = _from; AllEventsSlice slice; while (!(slice = _conn.ReadAllEventsForwardAsync(position, 5, false).Result).IsEndOfStream) { all.AddRange(slice.Events.Select(x => x.Event)); position = slice.NextPosition; } Assert.That(EventDataComparer.Equal(_testEvents, all.Skip(all.Count - _testEvents.Length).ToArray())); }
public async Task be_able_to_read_single_event_from_arbitrary_position() { const string stream = "read_event_stream_forward_should_be_able_to_read_from_arbitrary_position"; using (var store = BuildConnection(_node)) { await store.ConnectAsync(); var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray(); var write10 = await store.AppendToStreamAsync(stream, ExpectedVersion.NoStream, testEvents); var read = await store.ReadStreamEventsForwardAsync(stream, 5, 1, resolveLinkTos : false); Assert.That(EventDataComparer.Equal(testEvents[5], read.Events.Single().Event)); } }
public void returns_all_events_including_tombstone() { AllEventsSlice read = _conn.ReadAllEventsForwardAsync(Position.Start, _testEvents.Length + 10, false).Result; Assert.That( EventDataComparer.Equal( _testEvents.ToArray(), read.Events.Skip(read.Events.Length - _testEvents.Length - 1) .Take(_testEvents.Length) .Select(x => x.Event) .ToArray())); var lastEvent = read.Events.Last().Event; Assert.AreEqual(_streamName, lastEvent.EventStreamId); Assert.AreEqual(SystemEventTypes.StreamDeleted, lastEvent.EventType); }
public async Task return_events_in_same_order_as_written() { const string stream = "read_event_stream_forward_should_return_events_in_same_order_as_written"; using (var store = BuildConnection(_node)) { await store.ConnectAsync(); var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray(); var write10 = await store.AppendToStreamAsync(stream, ExpectedVersion.NoStream, testEvents); var read = await store.ReadStreamEventsForwardAsync(stream, StreamPosition.Start, testEvents.Length, resolveLinkTos : false); Assert.That(EventDataComparer.Equal(testEvents, read.Events.Select(x => x.Event).ToArray())); } }
public void be_able_to_read_last_event() { const string stream = "read_event_stream_backward_should_be_able_to_read_last_event"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray(); var write10 = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents); Assert.DoesNotThrow(write10.Wait); var read = store.ReadStreamEventsBackwardAsync(stream, StreamPosition.End, 1, resolveLinkTos: false); Assert.DoesNotThrow(read.Wait); Assert.That(EventDataComparer.Equal(testEvents.Last(), read.Result.Events.Single().Event)); } }
public void return_events_reversed_compared_to_written() { const string stream = "read_event_stream_backward_should_return_events_reversed_compared_to_written"; using (var store = BuildConnection(_node)) { store.ConnectAsync().Wait(); var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent((x + 1).ToString())).ToArray(); var write10 = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents); Assert.DoesNotThrow(write10.Wait); var read = store.ReadStreamEventsBackwardAsync(stream, StreamPosition.End, testEvents.Length, resolveLinkTos: false); Assert.DoesNotThrow(read.Wait); Assert.That(EventDataComparer.Equal(testEvents.Reverse().ToArray(), read.Result.Events.Select(x => x.Event).ToArray())); } }
public void be_able_to_read_slice_from_arbitrary_position() { const string stream = "read_event_stream_forward_should_be_able_to_read_slice_from_arbitrary_position"; using (var store = BuildConnection(_node)) { store.ConnectAsync().Wait(); var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray(); var write10 = store.AppendToStreamAsync(stream, ExpectedVersion.NoStream, testEvents); Assert.DoesNotThrow(write10.Wait); var read = store.ReadStreamEventsForwardAsync(stream, 5, 2, resolveLinkTos: false); Assert.DoesNotThrow(read.Wait); Assert.That(EventDataComparer.Equal(testEvents.Skip(5).Take(2).ToArray(), read.Result.Events.Select(x => x.Event).ToArray())); } }
public void return_events_in_same_order_as_written() { const string stream = "read_event_stream_forward_should_return_events_in_same_order_as_written"; using (var store = TestConnection.Create(_node.TcpEndPoint)) { store.Connect(); var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray(); var write10 = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents); Assert.DoesNotThrow(write10.Wait); var read = store.ReadStreamEventsForwardAsync(stream, StreamPosition.Start, testEvents.Length, resolveLinkTos: false); Assert.DoesNotThrow(read.Wait); Assert.That(EventDataComparer.Equal(testEvents, read.Result.Events.Select(x => x.Event).ToArray())); } }
public void be_able_to_read_single_event_from_arbitrary_position() { const string stream = "read_event_stream_forward_should_be_able_to_read_from_arbitrary_position"; using (var store = TestConnection.Create(_node.TcpEndPoint)) { store.Connect(); var testEvents = Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray(); var write10 = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, testEvents); Assert.DoesNotThrow(write10.Wait); var read = store.ReadStreamEventsForwardAsync(stream, 5, 1, resolveLinkTos: false); Assert.DoesNotThrow(read.Wait); Assert.That(EventDataComparer.Equal(testEvents[5], read.Result.Events.Single().Event)); } }
public void returns_all_events_including_tombstone() { AllEventsSlice read = _conn.ReadAllEventsForwardAsync(Position.Start, _testEvents.Length + 10, false).Result; Assert.That( EventDataComparer.Equal( _testEvents.ToArray(), read.Events.Skip(read.Events.Length - _testEvents.Length - 1) .Take(_testEvents.Length) .Select(x => x.Event) .ToArray())); var lastEvent = read.Events.Last().Event; Assert.AreEqual("$$stream", lastEvent.EventStreamId); Assert.AreEqual(SystemEventTypes.StreamMetadata, lastEvent.EventType); var metadata = StreamMetadata.FromJsonBytes(lastEvent.Data); Assert.AreEqual(EventNumber.DeletedStream, metadata.TruncateBefore); }