public async Task from_non_existing_stream()
{
var streamName = GetStreamName();
var eventAppearedSource = new TaskCompletionSource <ResolvedEvent>();
var connection = _fixture.Connection;
using var _ = await connection
.SubscribeToStreamAsync(streamName, false, EventAppeared, SubscriptionDropped).WithTimeout();
var testEvents = _fixture.CreateTestEvents().ToArray();
await connection.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, testEvents).WithTimeout();
var resolvedEvent = await eventAppearedSource.Task.WithTimeout();
Assert.Equal(testEvents[0].EventId, resolvedEvent.OriginalEvent.EventId);
Task EventAppeared(EventStoreSubscription s, ResolvedEvent e)
{
eventAppearedSource.TrySetResult(e);
return(Task.CompletedTask);
}
void SubscriptionDropped(EventStoreSubscription s, SubscriptionDropReason reason, Exception ex) =>
eventAppearedSource.TrySetException(ex ?? new ObjectDisposedException(nameof(s)));
}
public async Task returns_version_mismatch_with_wrong_expected_version()
{
var stream = GetStreamName();
var connection = _fixture.Connection;
var result = await connection.ConditionalAppendToStreamAsync(stream, 7, _fixture.CreateTestEvents())
.WithTimeout();
Assert.Equal(ConditionalWriteStatus.VersionMismatch, result.Status);
}
public async Task closes_after_configured_amount_of_failed_reconnections()
{
var closedSource = new TaskCompletionSource <bool>();
using var connection = _fixture.CreateConnection(
builder => builder.UseSsl(true)
.DisableServerCertificateValidation()
.LimitReconnectionsTo(1)
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(10))
.SetReconnectionDelayTo(TimeSpan.Zero)
.FailOnNoServerResponse(),
useStandardPort: true);
connection.Closed += delegate { closedSource.TrySetResult(true); };
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);
await connection.ConnectAsync().WithTimeout();
_fixture.EventStore.Stop();
await closedSource.Task.WithTimeout(TimeSpan.FromSeconds(120));
await Assert.ThrowsAsync <ObjectDisposedException>(() => connection.AppendToStreamAsync(
nameof(closes_after_configured_amount_of_failed_reconnections),
ExpectedVersion.NoStream,
_fixture.CreateTestEvents()).WithTimeout());
_fixture.EventStore.Start();
// wait for the cluster to come back
await Policy.Handle <Exception>()
.WaitAndRetryAsync(5, retryCount => TimeSpan.FromSeconds(retryCount * 2))
.ExecuteAsync(async() => {
using var newConnection =
_fixture.CreateConnection(
builder => builder
.UseSsl(true)
.DisableServerCertificateValidation()
.WithConnectionTimeoutOf(TimeSpan.FromSeconds(10))
.SetReconnectionDelayTo(TimeSpan.Zero)
.FailOnNoServerResponse(),
useStandardPort: true,
clusterMaxDiscoverAttempts: -1);
await newConnection.ConnectAsync().WithTimeout();
await newConnection.AppendToStreamAsync(GetStreamName(), ExpectedVersion.Any, _fixture.CreateTestEvents()).WithTimeout();
});
}
public async Task concurrently()
{
var streamName = GetStreamName();
var eventAppearedSource1 = new TaskCompletionSource <ResolvedEvent>();
var eventAppearedSource2 = new TaskCompletionSource <ResolvedEvent>();
var connection = _fixture.Connection;
using (await connection.SubscribeToAllAsync(false, EventAppeared1, SubscriptionDropped1).WithTimeout())
using (await connection.SubscribeToAllAsync(false, EventAppeared2, SubscriptionDropped2).WithTimeout()) {
var testEvents = _fixture.CreateTestEvents().ToArray();
await connection.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, testEvents).WithTimeout();
var resolvedEvents =
await Task.WhenAll(eventAppearedSource1.Task, eventAppearedSource2.Task).WithTimeout();
Assert.Equal(testEvents[0].EventId, resolvedEvents[0].OriginalEvent.EventId);
Assert.Equal(testEvents[0].EventId, resolvedEvents[1].OriginalEvent.EventId);
}
Task EventAppeared1(EventStoreSubscription s, ResolvedEvent e)
{
if (e.OriginalStreamId == streamName)
{
eventAppearedSource1.TrySetResult(e);
}
return(Task.CompletedTask);
}
Task EventAppeared2(EventStoreSubscription s, ResolvedEvent e)
{
if (e.OriginalStreamId == streamName)
{
eventAppearedSource2.TrySetResult(e);
}
return(Task.CompletedTask);
}
void SubscriptionDropped1(EventStoreSubscription s, SubscriptionDropReason reason, Exception ex) =>
eventAppearedSource1.TrySetException(ex ?? new ObjectDisposedException(nameof(s)));
void SubscriptionDropped2(EventStoreSubscription s, SubscriptionDropReason reason, Exception ex) =>
eventAppearedSource2.TrySetException(ex ?? new ObjectDisposedException(nameof(s)));
}
public async Task expected_version(long expectedVersion, string displayName)
{
if (GlobalEnvironment.IsLogV3)
{
return;
}
var streamName = $"{GetStreamName()}_{displayName}";
var connection = _fixture.Connection;
using var transaction = await connection.StartTransactionAsync(streamName, expectedVersion).WithTimeout();
await transaction.WriteAsync(_fixture.CreateTestEvents()).WithTimeout();
var result = await transaction.CommitAsync().WithTimeout();
Assert.Equal(0, result.NextExpectedVersion);
}
public async Task for_existing_stream(long expectedVersion, string displayName)
{
var streamName = $"{GetStreamName()}_{displayName}";
var connection = _fixture.Connection;
await connection.AppendToStreamAsync(streamName, expectedVersion, _fixture.CreateTestEvents())
.WithTimeout();
await connection.SetStreamMetadataAsync(streamName, expectedVersion, Array.Empty <byte>()).WithTimeout();
}
public async Task stream_id_filter_returns_expected_result(Func <string, Filter> getFilter,
string name)
{
var streamPrefix = $"{GetStreamName()}_{name}";
var testEvents = _fixture.CreateTestEvents(10).ToArray();
var connection = _fixture.Connection;
foreach (var e in testEvents)
{
await connection.AppendToStreamAsync($"{streamPrefix}_{Guid.NewGuid():n}", ExpectedVersion.NoStream, e);
}
var result = await connection.FilteredReadAllEventsForwardAsync(
Position.Start, 4096, false, getFilter(streamPrefix)).WithTimeout();
Assert.Equal(ReadDirection.Forward, result.ReadDirection);
Assert.Equal(testEvents.Select(x => x.EventId), result.Events
.Select(x => x.OriginalEvent.EventId));
}
public async Task for_stream_that_exists_but_event_does_not()
{
var streamName = GetStreamName();
var connection = _fixture.Connection;
await connection.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, _fixture.CreateTestEvents(2))
.WithTimeout();
var result = await connection.ReadEventAsync(streamName, 5, false).WithTimeout();
Assert.Equal(EventReadStatus.NotFound, result.Status);
Assert.Null(result.Event);
Assert.Equal(streamName, result.Stream);
Assert.Equal(5, result.EventNumber);
}
public async Task when_the_stream_exists(string suffix, int count, int metadataSize)
{
var streamName = $"{GetStreamName()}_{suffix}";
var connection = _fixture.Connection;
var testEvents = _fixture.CreateTestEvents(count, metadataSize).ToArray();
await connection.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, testEvents).WithTimeout();
var result = await connection.ReadStreamEventsForwardAsync(streamName, 0, testEvents.Length, false)
.WithTimeout();
Assert.Equal(SliceReadStatus.Success, result.Status);
Assert.True(result.IsEndOfStream);
Assert.Equal(ReadDirection.Forward, result.ReadDirection);
Assert.Equal(testEvents.Select(x => x.EventId), result.Events.Select(x => x.OriginalEvent.EventId));
}
public async Task returns_expected_result(string suffix, int count, int metadataSize)
{
var streamName = $"{GetStreamName()}_{suffix}";
var connection = _fixture.Connection;
var testEvents = _fixture.CreateTestEvents(count, metadataSize).ToArray();
var writeResult = await connection.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, testEvents)
.WithTimeout();
var result = await connection.ReadAllEventsBackwardAsync(Position.End, 4096, false).WithTimeout();
Assert.Equal(ReadDirection.Backward, result.ReadDirection);
Assert.True(result.Events.Length >= testEvents.Length);
Assert.Equal(testEvents.Select(x => x.EventId), result.Events
.Reverse()
.Where(x => x.OriginalStreamId == streamName)
.Select(x => x.OriginalEvent.EventId));
}
public async Task that_does_exist_succeeds(bool hardDelete)
{
var streamName = $"{GetStreamName()}_{hardDelete}";
var connection = _fixture.Connection;
var result = await connection
.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, _fixture.CreateTestEvents()).WithTimeout();
await connection.DeleteStreamAsync(streamName, result.NextExpectedVersion, hardDelete).WithTimeout();
}
public async Task returns_expected_result(long expectedVersion, string displayName,
bool createStream, StreamMetadataBuilder builder)
{
var isEmpty = builder == null;
var streamName = $"{GetStreamName()}_{displayName}_{createStream}_{isEmpty}";
var connection = _fixture.Connection;
if (createStream)
{
await connection.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, _fixture.CreateTestEvents())
.WithTimeout();
}
var expected = (builder ?? StreamMetadata.Build()).Build();
await connection.SetStreamMetadataAsync(streamName, expectedVersion, expected).WithTimeout();
var result = await connection.GetStreamMetadataAsync(streamName).WithTimeout();
var actual = result.StreamMetadata;
Assert.Equal(streamName, result.Stream);
Assert.False(result.IsStreamDeleted);
Assert.Equal(0, result.MetastreamVersion);
Assert.Equal(expected.MaxCount, actual.MaxCount);
Assert.Equal(expected.MaxAge, actual.MaxAge);
Assert.Equal(expected.TruncateBefore, actual.TruncateBefore);
Assert.Equal(expected.CacheControl, actual.CacheControl);
Assert.Equal(expected.Acl?.ReadRoles, actual.Acl?.ReadRoles);
Assert.Equal(expected.Acl?.WriteRoles, actual.Acl?.WriteRoles);
Assert.Equal(expected.Acl?.DeleteRoles, actual.Acl?.DeleteRoles);
Assert.Equal(expected.Acl?.MetaReadRoles, actual.Acl?.MetaReadRoles);
Assert.Equal(expected.Acl?.MetaWriteRoles, actual.Acl?.MetaWriteRoles);
Assert.Equal(expected.CustomKeys.Count(), actual.CustomKeys.Count());
foreach (var key in actual.CustomKeys)
{
Assert.True(expected.TryGetValueAsRawJsonString(key, out var value));
Assert.Equal(actual.GetValueAsRawJsonString(key), value);
}
}
public async Task expected_version(long expectedVersion, string displayName)
{
var streamName = $"{GetStreamName()}_{displayName}";
var connection = _fixture.Connection;
var result = await connection.AppendToStreamAsync(streamName, expectedVersion, _fixture.CreateTestEvents())
.WithTimeout();
Assert.Equal(0, result.NextExpectedVersion);
await connection.AppendToStreamAsync(streamName, result.NextExpectedVersion, _fixture.CreateTestEvents())
.WithTimeout();
}
