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