public void write_to_loop_async()
{
var stopwatch = new Stopwatch();
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
using (var connection = new EventStoreConnection(endpoint))
{
const int itemsCount = 1000;
stopwatch.Start();
var tasks = new Task[itemsCount];
for (var i = 0; i < itemsCount; ++i)
{
var ev = new TestEvent("Some data async");
tasks[i] = connection.AppendToStreamAsync("test", -2, new[] { ev });
}
Task.WaitAll(tasks);
stopwatch.Stop();
Debug.WriteLine("Completed {0} event with speed {1} e/sec",
itemsCount,
itemsCount / stopwatch.Elapsed.TotalSeconds);
}
}
public void should_append_with_correct_exp_ver_to_existing_stream()
{
const string stream = "should_append_with_correct_exp_ver_to_existing_stream";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = store.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, new[] { new TestEvent() });
Assert.DoesNotThrow(append.Wait);
}
}
public void should_create_stream_with_no_stream_exp_ver_on_first_write_if_does_not_exist()
{
const string stream = "should_create_stream_with_no_stream_exp_ver_on_first_write_if_does_not_exist";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var append = store.AppendToStreamAsync(stream, ExpectedVersion.NoStream, new[] {new TestEvent()});
Assert.DoesNotThrow(append.Wait);
var read = store.ReadEventStreamForwardAsync(stream, 0, 2);
Assert.DoesNotThrow(read.Wait);
Assert.That(read.Result.Events.Length, Is.EqualTo(2));
}
}
public void can_append_multiple_events_at_once()
{
const string stream = "can_append_multiple_events_at_once";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = store.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var events = Enumerable.Range(0, 100).Select(i => new TestEvent(i.ToString(), i.ToString()));
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, events);
Assert.DoesNotThrow(append.Wait);
}
}
public void write_to()
{
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
using (var connection = new EventStoreConnection(endpoint))
{
var ev = new TestEvent("Some data");
var task = connection.AppendToStreamAsync("test", -2, new[] { ev });
task.Wait();
var result = task.Result;
Assert.IsTrue(result.IsSuccessful, "Written Successfully");
}
}
public void write_to_and_delete()
{
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
using (var connection = new EventStoreConnection(endpoint))
{
var ev = new TestEvent("Some data");
var stream = string.Format("test-delete-{0}", Guid.NewGuid());
var appendTask = connection.AppendToStreamAsync(stream, -2, new[] { ev });
appendTask.Wait();
Assert.IsTrue(appendTask.Result.IsSuccessful, "Failed to append data to stream.");
var data = connection.ReadEventStream(stream, 0, int.MaxValue);
var lastEventVersion = data.Events[data.Events.Length - 1].EventNumber;
var deleteTask = connection.DeleteStreamAsync(stream, lastEventVersion);
deleteTask.Wait();
Assert.IsTrue(deleteTask.Result.IsSuccessful, "Failed to delete stream.");
}
}
public void should_commit_when_writing_with_exp_ver_any_even_while_somene_is_writing_in_parallel()
{
const string stream = "should_commit_when_writing_with_exp_ver_any_even_while_somene_is_writing_in_parallel";
var transWritesCompleted = new AutoResetEvent(false);
var writesToSameStreamCompleted = new AutoResetEvent(false);
var totalTranWrites = 500;
var totalPlainWrites = 500;
//excplicitly creating stream
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
store.CreateStream(stream, new byte[0]);
//500 events during transaction
ThreadPool.QueueUserWorkItem(_ =>
{
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var transaction = store.StartTransaction(stream, ExpectedVersion.Any);
var writes = new List<Task>();
for (int i = 0; i < totalTranWrites; i++)
{
if (i % 10 == 0)
writes.RemoveAll(write => write.IsCompleted);
writes.Add(store.TransactionalWriteAsync(transaction.TransactionId,
transaction.Stream,
new[] { new TestEvent((i + 1).ToString(), "trans write") }));
}
Task.WaitAll(writes.ToArray());
store.CommitTransaction(transaction.TransactionId, transaction.Stream);
transWritesCompleted.Set();
}
});
//500 events to same stream in parallel
ThreadPool.QueueUserWorkItem(_ =>
{
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var writes = new List<Task>();
for (int i = 0; i < totalPlainWrites; i++)
{
if (i % 10 == 0)
writes.RemoveAll(write => write.IsCompleted);
writes.Add(store.AppendToStreamAsync(stream,
ExpectedVersion.Any,
new[] {new TestEvent((i + 1).ToString(), "plain write")}));
}
Task.WaitAll(writes.ToArray());
writesToSameStreamCompleted.Set();
}
});
transWritesCompleted.WaitOne();
writesToSameStreamCompleted.WaitOne();
//check all written
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var slice = store.ReadEventStreamForward(stream, 0, totalTranWrites + totalPlainWrites + 1);
Assert.That(slice.Events.Length, Is.EqualTo(totalTranWrites + totalPlainWrites + 1));
Assert.That(slice.Events.Count(ent => Encoding.UTF8.GetString(ent.Metadata) == "trans write"), Is.EqualTo(totalTranWrites));
Assert.That(slice.Events.Count(ent => Encoding.UTF8.GetString(ent.Metadata) == "plain write"), Is.EqualTo(totalPlainWrites));
}
}
public void should_not_fail_to_commit_if_started_with_wrong_ver_but_committing_with_correct_ver()
{
const string stream = "should_not_fail_to_commit_if_started_with_wrong_ver_but_committing_with_correct_ver";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
store.CreateStream(stream, new byte[0]);
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var start = store.StartTransactionAsync(stream, 1);
Assert.DoesNotThrow(start.Wait);
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, new[] { new TestEvent() });
Assert.DoesNotThrow(append.Wait);
var write = store.TransactionalWriteAsync(start.Result.TransactionId, start.Result.Stream, new[] { new TestEvent() });
Assert.DoesNotThrow(write.Wait);
var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream);
Assert.DoesNotThrow(commit.Wait);
}
}
public void should_fail_to_commit_if_started_with_correct_ver_but_committing_with_bad()
{
const string stream = "should_fail_to_commit_if_started_with_correct_ver_but_committing_with_bad";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
store.CreateStream(stream, new byte[0]);
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var start = store.StartTransactionAsync(stream, ExpectedVersion.EmptyStream);
Assert.DoesNotThrow(start.Wait);
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, new[] {new TestEvent()});
Assert.DoesNotThrow(append.Wait);
var write = store.TransactionalWriteAsync(start.Result.TransactionId, start.Result.Stream, new[] { new TestEvent() });
Assert.DoesNotThrow(write.Wait);
var commit = store.CommitTransactionAsync(start.Result.TransactionId, start.Result.Stream);
Assert.That(() => commit.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>());
}
}
public static Task AppendToStreamAsync(string stream, int expectedVersion, IEnumerable <IEvent> events)
{
return(_connection.AppendToStreamAsync(stream, expectedVersion, events));
}
public void write_to()
{
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
using (var connection = new EventStoreConnection(endpoint))
{
var ev = new TestEvent("Some data");
var task = connection.AppendToStreamAsync("test", -2, new[] { ev });
task.Wait();
var result = task.Result;
Debug.Assert(result.IsSuccessful, "Written Successfully");
}
}
public void write_to_loop_async()
{
var stopwatch = new Stopwatch();
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
using (var connection = new EventStoreConnection(endpoint))
{
const int itemsCount = 1000;
stopwatch.Start();
var tasks = new Task[itemsCount];
for (var i = 0; i < itemsCount; ++i)
{
var ev = new TestEvent("Some data async");
tasks[i] = connection.AppendToStreamAsync("test", -2, new[] { ev });
}
Task.WaitAll(tasks);
stopwatch.Stop();
Debug.WriteLine("Completed {0} event with speed {1} e/sec",
itemsCount,
itemsCount / stopwatch.Elapsed.TotalSeconds);
}
}
//[Test]
//public void write_sync_null_failure()
//{
// var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
// using (var connection = new EventStoreConnection(endpoint))
// {
// var ev = new TestEvent("Some data");
// var task = connection.AppendToStreamAsync("test", -2, new[] { ev });
// task.Wait();
// var result = task.Result;
// Assert.IsTrue(result.IsSuccessful, "Written Successfully");
// }
//}
public void write_to_and_delete() {
var endpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 1113);
using (var connection = new EventStoreConnection(endpoint))
{
var ev = new TestEvent("Some data");
var stream = string.Format("test-delete-{0}", Guid.NewGuid());
var appendTask = connection.AppendToStreamAsync(stream, -2, new[] { ev });
appendTask.Wait();
Debug.Assert(appendTask.Result.IsSuccessful, "Failed to append data to stream.");
var data = connection.ReadEventStream(stream, 0, int.MaxValue);
var lastEventVersion = data.Events[data.Events.Length - 1].EventNumber;
var deleteTask = connection.DeleteStreamAsync(stream, lastEventVersion);
deleteTask.Wait();
Debug.Assert(deleteTask.Result.IsSuccessful, "Failed to delete stream.");
}
}
public void should_fail_appending_with_wrong_exp_ver_to_existing_stream()
{
const string stream = "should_fail_appending_with_wrong_exp_ver_to_existing_stream";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var create = store.CreateStreamAsync(stream, new byte[0]);
Assert.DoesNotThrow(create.Wait);
var append = store.AppendToStreamAsync(stream, 1, new[] { new TestEvent() });
Assert.That(() => append.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>());
}
}
public void should_fail_to_create_stream_with_wrong_exp_ver_on_first_write_if_does_not_exist()
{
const string stream = "should_fail_to_create_stream_with_wrong_exp_ver_on_first_write_if_does_not_exist";
using (var store = new EventStoreConnection(MiniNode.Instance.TcpEndPoint))
{
var append = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, new[] { new TestEvent() });
Assert.That(() => append.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>());
}
}
