public void multiple_idempotent_writes() { const string stream = "multiple_idempotent_writes"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); var events = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() }; Assert.AreEqual(3, store.AppendToStreamAsync(stream, ExpectedVersion.Any, events).Result.NextExpectedVersion); Assert.AreEqual(3, store.AppendToStreamAsync(stream, ExpectedVersion.Any, events).Result.NextExpectedVersion); } }
public void setting_metadata_for_existing_stream_works() { _connection.AppendToStreamAsync(_stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Wait(); var metadataBytes = Guid.NewGuid().ToByteArray(); _connection.SetStreamMetadataAsync(_stream, ExpectedVersion.EmptyStream, metadataBytes).Wait(); var meta = _connection.GetStreamMetadataAsRawBytesAsync(_stream).Result; Assert.AreEqual(_stream, meta.Stream); Assert.AreEqual(false, meta.IsStreamDeleted); Assert.AreEqual(0, meta.MetastreamVersion); Assert.AreEqual(metadataBytes, meta.StreamMetadata); }
public void soft_deleted_stream_returns_no_stream_and_no_events_on_read() { const string stream = "soft_deleted_stream_returns_no_stream_and_no_events_on_read"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); _conn.DeleteStreamAsync(stream, 1).Wait(); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.StreamNotFound, res.Status); Assert.AreEqual(0, res.Events.Length); Assert.AreEqual(1, res.LastEventNumber); }
public async Task append_to_stream_should_fail_with_not_supported_exception() { const string stream = "append_to_stream_should_fail_with_not_supported_exception"; await AssertEx.ThrowsAsync <OperationNotSupportedException>( () => _conn.AppendToStreamAsync(stream, ExpectedVersion.Any, TestEvent.NewTestEvent())); }
public void soft_deleted_stream_allows_recreation_only_for_first_write() { const string stream = "soft_deleted_stream_allows_recreation_only_for_first_write"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); _conn.DeleteStreamAsync(stream, 1).Wait(); var events = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() }; Assert.AreEqual(4, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, events).Result.NextExpectedVersion); Assert.That(() => _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent()).Wait(), Throws.Exception.InstanceOf <AggregateException>() .With.InnerException.InstanceOf <WrongExpectedVersionException>()); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(4, res.LastEventNumber); Assert.AreEqual(3, res.Events.Length); Assert.AreEqual(events.Select(x => x.EventId), res.Events.Select(x => x.OriginalEvent.EventId)); Assert.AreEqual(new[] { 2, 3, 4 }, res.Events.Select(x => x.OriginalEvent.EventNumber)); var meta = _conn.GetStreamMetadataAsync(stream).Result; Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore); Assert.AreEqual(1, meta.MetastreamVersion); }
public void setting_json_metadata_on_nonempty_soft_deleted_stream_recreates_stream_not_overriding_metadata() { const string stream = "setting_json_metadata_on_nonempty_soft_deleted_stream_recreates_stream_not_overriding_metadata"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); _conn.DeleteStreamAsync(stream, 1, hardDelete: false).Wait(); Assert.AreEqual(1, _conn.SetStreamMetadataAsync(stream, 0, StreamMetadata.Build().SetMaxCount(100) .SetDeleteRole("some-role") .SetCustomProperty("key1", true) .SetCustomProperty("key2", 17) .SetCustomProperty("key3", "some value")).Result.NextExpectedVersion); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(1, res.LastEventNumber); Assert.AreEqual(0, res.Events.Length); var meta = _conn.GetStreamMetadataAsync(stream).Result; Assert.AreEqual(2, meta.MetastreamVersion); Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore); Assert.AreEqual(100, meta.StreamMetadata.MaxCount); Assert.AreEqual("some-role", meta.StreamMetadata.Acl.DeleteRole); Assert.AreEqual(true, meta.StreamMetadata.GetValue <bool>("key1")); Assert.AreEqual(17, meta.StreamMetadata.GetValue <int>("key2")); Assert.AreEqual("some value", meta.StreamMetadata.GetValue <string>("key3")); }
public void should_append_with_stream_exists_exp_ver_if_metadata_stream_exists() { const string stream = "should_append_with_stream_exists_exp_ver_if_metadata_stream_exists"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); store.SetStreamMetadataAsync(stream, ExpectedVersion.Any, new StreamMetadata(10, null, null, null, null)).Wait(); var append = store.AppendToStreamAsync(stream, ExpectedVersion.StreamExists, new[] { TestEvent.NewTestEvent() }); Assert.DoesNotThrow(append.Wait); } }
public void soft_deleted_stream_when_recreated_preserves_metadata_except_truncatebefore() { const string stream = "soft_deleted_stream_when_recreated_preserves_metadata_except_truncatebefore"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); Assert.AreEqual(0, _conn.SetStreamMetadataAsync(stream, ExpectedVersion.NoStream, StreamMetadata.Build().SetTruncateBefore(long.MaxValue) .SetMaxCount(100) .SetDeleteRole("some-role") .SetCustomProperty("key1", true) .SetCustomProperty("key2", 17) .SetCustomProperty("key3", "some value")).Result.NextExpectedVersion); var events = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() }; Assert.AreEqual(4, _conn.AppendToStreamAsync(stream, 1, events).Result.NextExpectedVersion); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(4, res.LastEventNumber); Assert.AreEqual(3, res.Events.Length); Assert.AreEqual(events.Select(x => x.EventId), res.Events.Select(x => x.OriginalEvent.EventId)); Assert.AreEqual(new[] { 2, 3, 4 }, res.Events.Select(x => x.OriginalEvent.EventNumber)); var meta = _conn.GetStreamMetadataAsync(stream).Result; Assert.AreEqual(1, meta.MetastreamVersion); Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore); Assert.AreEqual(100, meta.StreamMetadata.MaxCount); Assert.AreEqual("some-role", meta.StreamMetadata.Acl.DeleteRole); Assert.AreEqual(true, meta.StreamMetadata.GetValue <bool>("key1")); Assert.AreEqual(17, meta.StreamMetadata.GetValue <int>("key2")); Assert.AreEqual("some value", meta.StreamMetadata.GetValue <string>("key3")); }
public void should_append_with_stream_exists_exp_ver_to_existing_stream() { const string stream = "should_append_with_stream_exists_exp_ver_to_existing_stream"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, TestEvent.NewTestEvent()).Wait(); var append = store.AppendToStreamAsync(stream, ExpectedVersion.StreamExists, new[] { TestEvent.NewTestEvent() }); Assert.DoesNotThrow(append.Wait); } }
public void should_append_with_stream_exists_exp_ver_to_stream_with_multiple_events() { const string stream = "should_append_with_stream_exists_exp_ver_to_stream_with_multiple_events"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); for(var i = 0; i < 5; i++) { store.AppendToStreamAsync(stream, ExpectedVersion.Any, TestEvent.NewTestEvent()).Wait(); } var append = store.AppendToStreamAsync(stream, ExpectedVersion.StreamExists, new[] { TestEvent.NewTestEvent() }); Assert.DoesNotThrow(append.Wait); } }
public void should_append_with_any_exp_ver_to_existing_stream() { const string stream = "should_append_with_any_exp_ver_to_existing_stream"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); Assert.AreEqual(0, store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, TestEvent.NewTestEvent()).Result.NextExpectedVersion); Assert.AreEqual(1, store.AppendToStreamAsync(stream, ExpectedVersion.Any, TestEvent.NewTestEvent()).Result.NextExpectedVersion); } }
public void should_fail_writing_with_any_exp_ver_to_deleted_stream() { const string stream = "should_fail_writing_with_any_exp_ver_to_deleted_stream"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); try { store.DeleteStreamAsync(stream, ExpectedVersion.EmptyStream, hardDelete: true).Wait(); } catch (Exception exc) { Console.WriteLine(exc); Assert.Fail(); } var append = store.AppendToStreamAsync(stream, ExpectedVersion.Any, new[] { TestEvent.NewTestEvent() }); Assert.That(() => append.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<StreamDeletedException>()); } }
public void should_return_log_position_when_writing() { const string stream = "should_return_log_position_when_writing"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); var result = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, TestEvent.NewTestEvent()).Result; Assert.IsTrue(0 < result.LogPosition.PreparePosition); Assert.IsTrue(0 < result.LogPosition.CommitPosition); } }
public void should_close_connection_after_configured_amount_of_failed_reconnections() { var closed = new ManualResetEventSlim(); var settings = ConnectionSettings.Create() .EnableVerboseLogging() .LimitReconnectionsTo(1) .WithConnectionTimeoutOf(TimeSpan.FromSeconds(10)) .SetReconnectionDelayTo(TimeSpan.FromMilliseconds(0)) .FailOnNoServerResponse(); if (_tcpType == TcpType.Ssl) { settings.UseSslConnection("ES", false); } using (var connection = EventStoreConnection.Create(settings, TestNode.BlackHole.ToESTcpUri())) { connection.Closed += (s, e) => closed.Set(); connection.Connected += (s, e) => Console.WriteLine("EventStoreConnection '{0}': connected to [{1}]...", e.Connection.ConnectionName, e.RemoteEndPoint); connection.Reconnecting += (s, e) => Console.WriteLine("EventStoreConnection '{0}': reconnecting...", e.Connection.ConnectionName); connection.Disconnected += (s, e) => Console.WriteLine("EventStoreConnection '{0}': disconnected from [{1}]...", e.Connection.ConnectionName, e.RemoteEndPoint); connection.ErrorOccurred += (s, e) => Console.WriteLine("EventStoreConnection '{0}': error = {1}", e.Connection.ConnectionName, e.Exception); connection.ConnectAsync().Wait(); if (!closed.Wait(TimeSpan.FromSeconds(120))) // TCP connection timeout might be even 60 seconds { Assert.Fail("Connection timeout took too long."); } Assert.That(() => connection.AppendToStreamAsync("stream", ExpectedVersion.EmptyStream, TestEvent.NewTestEvent()).Wait(), Throws.Exception.InstanceOf <AggregateException>() .With.InnerException.InstanceOf <InvalidOperationException>()); } }
public void should_fail_appending_with_stream_exists_exp_ver_and_stream_does_not_exist() { const string stream = "should_fail_appending_with_stream_exists_exp_ver_and_stream_does_not_exist"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); var append = store.AppendToStreamAsync(stream, ExpectedVersion.StreamExists, new[] { TestEvent.NewTestEvent() }); Assert.That(() => append.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<WrongExpectedVersionException>()); } }
public void should_return_log_position_when_writing() { const string stream = "delete_should_return_log_position_when_writing"; using (var connection = BuildConnection()) { connection.ConnectAsync().Wait(); var result = connection.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, TestEvent.NewTestEvent()).Result; var delete = connection.DeleteStreamAsync(stream, 1, hardDelete: true).Result; Assert.IsTrue(0 < result.LogPosition.PreparePosition); Assert.IsTrue(0 < result.LogPosition.CommitPosition); } }
public void should_fail_appending_with_stream_exists_exp_ver_to_soft_deleted_stream() { const string stream = "should_fail_appending_with_stream_exists_exp_ver_to_soft_deleted_stream"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); var delete = store.DeleteStreamAsync(stream, ExpectedVersion.EmptyStream, hardDelete: false); Assert.DoesNotThrow(delete.Wait); var append = store.AppendToStreamAsync(stream, ExpectedVersion.StreamExists, new[] { TestEvent.NewTestEvent() }); Assert.That(() => append.Wait(), Throws.Exception.TypeOf<AggregateException>().With.InnerException.TypeOf<StreamDeletedException>()); } }
public void soft_deleted_stream_can_be_hard_deleted() { const string stream = "soft_deleted_stream_can_be_deleted"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); _conn.DeleteStreamAsync(stream, 1).Wait(); _conn.DeleteStreamAsync(stream, ExpectedVersion.Any, hardDelete: true).Wait(); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.StreamDeleted, res.Status); var meta = _conn.GetStreamMetadataAsync(stream).Result; Assert.AreEqual(true, meta.IsStreamDeleted); Assert.That(() => _conn.AppendToStreamAsync(stream, ExpectedVersion.Any, TestEvent.NewTestEvent()).Wait(), Throws.Exception.InstanceOf <AggregateException>() .With.InnerException.InstanceOf <StreamDeletedException>()); }
public void returns_success_status_when_conditionally_appending_with_matching_version() { const string stream = "returns_success_status_when_conditionally_appending_with_matching_version"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); var result = store.ConditionalAppendToStreamAsync(stream, ExpectedVersion.Any, new[] { TestEvent.NewTestEvent() }).Result; Assert.AreEqual(ConditionalWriteStatus.Succeeded, result.Status); Assert.IsNotNull(result.LogPosition); Assert.IsNotNull(result.NextExpectedVersion); } }
public void soft_deleted_stream_appends_both_writes_when_expver_any() { const string stream = "soft_deleted_stream_appends_both_concurrent_writes_when_expver_any"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); _conn.DeleteStreamAsync(stream, 1).Wait(); var events1 = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() }; var events2 = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent() }; Assert.AreEqual(4, _conn.AppendToStreamAsync(stream, ExpectedVersion.Any, events1).Result.NextExpectedVersion); Assert.AreEqual(6, _conn.AppendToStreamAsync(stream, ExpectedVersion.Any, events2).Result.NextExpectedVersion); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(6, res.LastEventNumber); Assert.AreEqual(5, res.Events.Length); Assert.AreEqual(events1.Concat(events2).Select(x => x.EventId), res.Events.Select(x => x.OriginalEvent.EventId)); Assert.AreEqual(new[] { 2, 3, 4, 5, 6 }, res.Events.Select(x => x.OriginalEvent.EventNumber)); var meta = _conn.GetStreamMetadataAsync(stream).Result; Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore); Assert.AreEqual(1, meta.MetastreamVersion); }
public void returns_failure_status_when_conditionally_appending_to_a_deleted_stream() { const string stream = "returns_failure_status_when_conditionally_appending_to_a_deleted_stream"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); store.AppendToStreamAsync(stream, ExpectedVersion.Any, TestEvent.NewTestEvent()).Wait(); store.DeleteStreamAsync(stream, ExpectedVersion.Any, true).Wait(); var result = store.ConditionalAppendToStreamAsync(stream, ExpectedVersion.Any, new[] { TestEvent.NewTestEvent() }).Result; Assert.AreEqual(ConditionalWriteStatus.StreamDeleted, result.Status); } }
public void setting_nonjson_metadata_on_nonempty_soft_deleted_stream_recreates_stream_keeping_original_metadata() { const string stream = "setting_nonjson_metadata_on_nonempty_soft_deleted_stream_recreates_stream_overriding_metadata"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); _conn.DeleteStreamAsync(stream, 1, hardDelete: false).Wait(); Assert.AreEqual(1, _conn.SetStreamMetadataAsync(stream, 0, new byte[256]).Result.NextExpectedVersion); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(1, res.LastEventNumber); Assert.AreEqual(2, res.Events.Length); Assert.AreEqual(new[] { 0, 1 }, res.Events.Select(x => x.OriginalEventNumber).ToArray()); var meta = _conn.GetStreamMetadataAsRawBytesAsync(stream).Result; Assert.AreEqual(1, meta.MetastreamVersion); Assert.AreEqual(new byte[256], meta.StreamMetadata); }
public void should_create_stream_with_any_exp_ver_on_first_write_if_does_not_exist() { const string stream = "should_create_stream_with_any_exp_ver_on_first_write_if_does_not_exist"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); Assert.AreEqual(0, store.AppendToStreamAsync(stream, ExpectedVersion.Any, TestEvent.NewTestEvent()).Result.NextExpectedVersion); var read = store.ReadStreamEventsForwardAsync(stream, 0, 2, resolveLinkTos: false); Assert.DoesNotThrow(read.Wait); Assert.That(read.Result.Events.Length, Is.EqualTo(1)); } }
public void soft_deleted_stream_allows_recreation_when_expver_no_stream() { const string stream = "soft_deleted_stream_allows_recreation_when_expver_no_stream"; Assert.AreEqual(1, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).Result.NextExpectedVersion); _conn.DeleteStreamAsync(stream, 1).Wait(); var events = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() }; Assert.AreEqual(4, _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, events).Result.NextExpectedVersion); var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result; Assert.AreEqual(SliceReadStatus.Success, res.Status); Assert.AreEqual(4, res.LastEventNumber); Assert.AreEqual(3, res.Events.Length); Assert.AreEqual(events.Select(x => x.EventId), res.Events.Select(x => x.OriginalEvent.EventId)); Assert.AreEqual(new[] { 2, 3, 4 }, res.Events.Select(x => x.OriginalEvent.EventNumber)); var meta = _conn.GetStreamMetadataAsync(stream).Result; Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore); Assert.AreEqual(1, meta.MetastreamVersion); }
public void return_empty_slice_when_called_on_non_existing_range() { const string stream = "read_event_stream_forward_should_return_empty_slice_when_called_on_non_existing_range"; using (var store = BuildConnection()) { store.ConnectAsync().Wait(); var write10 = store.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, Enumerable.Range(0, 10).Select(x => TestEvent.NewTestEvent((x + 1).ToString(CultureInfo.InvariantCulture)))); Assert.DoesNotThrow(write10.Wait); var read = store.ReadStreamEventsForwardAsync(stream, 11, 5, resolveLinkTos: false); Assert.DoesNotThrow(read.Wait); Assert.That(read.Result.Events.Length, Is.EqualTo(0)); } }