public void sequence_0em1_0em1_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_sequence_0em1_0em1_idempotent";
using (var store = BuildConnection(_node)) {
store.ConnectAsync().Wait();
var events = Enumerable.Range(0, 1).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var writer = new StreamWriter(store, stream, -1);
Assert.DoesNotThrow(() => writer.Append(events).Then(events.First(), -1));
var total = EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length));
}
}
public void sequence_0em1_1e0_2e1_3e2_4e3_5e4_0e5_non_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_sequence_0em1_1e0_2e1_3e2_4e3_5e4_0e5_non_idempotent";
using (var store = TestConnection.Create(_node.TcpEndPoint))
{
store.Connect();
var events = Enumerable.Range(0, 6).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var writer = new StreamWriter(store, stream, -1);
Assert.DoesNotThrow(() => writer.Append(events).Then(events.First(), 5));
var total = EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length + 1));
}
}
public async Task sequence_S_0em1_1em1_E_S_1any_E_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_sequence_S_0em1_1em1_E_S_1any_E_idempotent";
using (var store = BuildConnection(_node)) {
await store.ConnectAsync();
var events = Enumerable.Range(0, 2).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
await store.AppendToStreamAsync(stream, -1, events);
await store.AppendToStreamAsync(stream, ExpectedVersion.Any, events[1]);
var total = await EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length));
}
}
public void sequence_0em1_1e0_2e1_3e2_4e3_5e4_0e5_non_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_using_transaction_sequence_0em1_1e0_2e1_3e2_4e3_5e4_0e5_non_idempotent";
using (var store = BuildConnection())
{
store.ConnectAsync().Wait();
var events = Enumerable.Range(0, 6).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var writer = new TransactionalWriter(store, stream);
Assert.AreEqual(5, writer.StartTransaction(-1).Write(events).Commit().NextExpectedVersion);
Assert.AreEqual(6, writer.StartTransaction(5).Write(events.First()).Commit().NextExpectedVersion);
var total = EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length + 1));
}
}
public void sequence_0em1_1e0_2e1_1any_1any_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_using_transaction_sequence_0em1_1e0_2e1_1any_1any_idempotent";
using (var store = TestConnection.Create(_node.TcpEndPoint))
{
store.ConnectAsync().Wait();
var events = Enumerable.Range(0, 3).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var writer = new TransactionalWriter(store, stream);
Assert.AreEqual(2, writer.StartTransaction(-1).Write(events).Commit().NextExpectedVersion);
Assert.AreEqual(1, writer.StartTransaction(ExpectedVersion.Any).Write(events[1]).Write(events[1]).Commit().NextExpectedVersion);
var total = EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length));
}
}
public void sequence_0em1_0em1_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_using_transaction_sequence_0em1_0em1_idempotent";
using (var store = TestConnection.Create(_node.TcpEndPoint))
{
store.Connect();
var events = Enumerable.Range(0, 1).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var writer = new TransactionalWriter(store, stream);
Assert.DoesNotThrow(() => writer.StartTransaction(-1).Write(events).Commit());
Assert.DoesNotThrow(() => writer.StartTransaction(-1).Write(events.First()).Commit());
var total = EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length));
}
}
public void sequence_S_0em1_1em1_E_S_1e0_E_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_sequence_S_0em1_1em1_E_S_1e0_E_idempotent";
using (var store = BuildConnection(_node)) {
store.ConnectAsync().Wait();
var events = Enumerable.Range(0, 2).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var append = store.AppendToStreamAsync(stream, -1, events);
Assert.DoesNotThrow(append.Wait);
var app2 = store.AppendToStreamAsync(stream, 0, new[] { events[1] });
Assert.DoesNotThrow(app2.Wait);
var total = EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length));
}
}
public async Task sequence_0em1_0em1_idempotent()
{
const string stream =
"appending_to_implicitly_created_stream_using_transaction_sequence_0em1_0em1_idempotent";
using (var store = BuildConnection(_node)) {
await store.ConnectAsync();
var events = Enumerable.Range(0, 1).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var writer = new TransactionalWriter(store, stream);
Assert.AreEqual(0, (await(await(await writer.StartTransaction(-1)).Write(events)).Commit()).NextExpectedVersion);
Assert.AreEqual(0, (await(await(await writer.StartTransaction(-1)).Write(events.First())).Commit()).NextExpectedVersion);
var total = await EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length));
}
}
public async Task sequence_0em1_0any_idempotent()
{
const string stream = "appending_to_implicitly_created_stream_sequence_0em1_0any_idempotent";
using (var store = BuildConnection(_node)) {
await store.ConnectAsync();
var events = Enumerable.Range(0, 1).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var writer = new StreamWriter(store, stream, -1);
var tail = await writer.Append(events);
await tail.Then(events.First(), ExpectedVersion.Any);
var total = await EventsStream.Count(store, stream);
Assert.That(total, Is.EqualTo(events.Length));
}
}
public async Task detect_existing_streams_flush()
{
void CreateNode()
{
_node = new MiniNode <TLogFormat, TStreamId>(
pathname: PathName,
dbPath: Path.Combine(PathName, "mini-node-db"),
inMemDb: false,
streamExistenceFilterSize: 10_000,
streamExistenceFilterCheckpointIntervalMs: 100,
streamExistenceFilterCheckpointDelayMs: 0);
}
CreateNode();
await _node.Start();
// GIVEN some streams
var normal = "detect_existing_streams_normal";
var meta = "detect_existing_streams_meta";
var committed = "detect_existing_streams_commited_transaction";
var uncommitted = "detect_existing_streams_uncommited_transaction";
EventData[] GenEvents() => Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent(Guid.NewGuid())).ToArray();
var eventsByStream = new Dictionary <string, EventData[]>()
{
{ normal, GenEvents() },
{ committed, GenEvents() },
{ uncommitted, GenEvents() },
};
var uncommittedTransId = 0L;
using (var store = BuildConnection(_node)) {
await store.ConnectAsync();
// normal
Assert.AreEqual(9, await store
.Apply(x => x.AppendToStreamAsync(normal, ExpectedVersion.NoStream, eventsByStream[normal]))
.Apply(x => x.NextExpectedVersion));
// meta
Assert.AreEqual(0, await store
.Apply(x => x.SetStreamMetadataAsync("meta", ExpectedVersion.NoStream, StreamMetadata.Create(maxCount: 5)))
.Apply(x => x.NextExpectedVersion));
if (LogFormatHelper <TLogFormat, TStreamId> .IsV2)
{
// committed
Assert.AreEqual(9, await new TransactionalWriter(store, committed)
.Apply(x => x.StartTransaction(-1))
.Apply(x => x.Write(eventsByStream[committed]))
.Apply(x => x.Commit())
.Apply(x => x.NextExpectedVersion));
// uncommitted
uncommittedTransId = await new TransactionalWriter(store, uncommitted)
.Apply(x => x.StartTransaction(-1))
.Apply(x => x.Write(eventsByStream[committed]))
.Apply(x => x.TransactionId);
}
// append an event to another stream because the last event is always going to get reinitialised
Assert.AreEqual(0, await store
.Apply(x => x.AppendToStreamAsync("another-stream", ExpectedVersion.NoStream, TestEvent.NewTestEvent(Guid.NewGuid())))
.Apply(x => x.NextExpectedVersion));
}
// WHEN flush and restart
await Task.Delay(500);
await _node.Shutdown(keepDb : true);
CreateNode();
await _node.Start();
// THEN the streams all exist
using (var store = BuildConnection(_node)) {
await store.ConnectAsync();
// normal
Assert.AreEqual(10, await store
.Apply(x => x.AppendToStreamAsync(normal, 9, TestEvent.NewTestEvent(Guid.NewGuid())))
.Apply(x => x.NextExpectedVersion));
Assert.AreEqual(
eventsByStream[normal].Length + 1,
await EventsStream.Count(store, normal));
// meta
Assert.AreEqual(1, await store
.Apply(x => x.SetStreamMetadataAsync("meta", 0, StreamMetadata.Create(maxCount: 6)))
.Apply(x => x.NextExpectedVersion));
Assert.AreEqual(0, await EventsStream.Count(store, meta));
if (LogFormatHelper <TLogFormat, TStreamId> .IsV2)
{
// committed
Assert.AreEqual(10, await store
.Apply(x => x.AppendToStreamAsync(committed, 9, TestEvent.NewTestEvent(Guid.NewGuid())))
.Apply(x => x.NextExpectedVersion));
Assert.AreEqual(
eventsByStream[committed].Length + 1,
await EventsStream.Count(store, committed));
// uncommitted
Assert.AreEqual(9, await new TransactionalWriter(store, uncommitted)
.Apply(x => x.ContinueTransaction(uncommittedTransId))
.Apply(x => x.Commit())
.Apply(x => x.NextExpectedVersion));
Assert.AreEqual(
eventsByStream[uncommitted].Length,
await EventsStream.Count(store, uncommitted));
}
}
}
