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