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