protected static void WriteSingleEvent(
ICheckpoint writerCheckpoint,
TFChunkWriter writer,
string eventStreamId,
long eventNumber,
ReadOnlyMemory <byte> data,
DateTime?timestamp = null,
Uuid eventId = default,
string eventType = "some-type")
{
var prepare = LogRecord.SingleWrite(writerCheckpoint.ReadNonFlushed(),
Guid.NewGuid(),
(eventId == default ? Uuid.NewUuid() : eventId).ToGuid(),
eventStreamId,
eventNumber - 1,
eventType,
data.ToArray(),
null,
timestamp);
Assert.True(writer.Write(prepare, out _));
var commit = LogRecord.Commit(
writerCheckpoint.ReadNonFlushed(), prepare.CorrelationId, prepare.LogPosition, eventNumber);
Assert.True(writer.Write(commit, out _));
}
public void InvalidContentTypeThrows()
{
var ex = Assert.Throws <ArgumentOutOfRangeException>(
() => new EventData(Uuid.NewUuid(), "-", Array.Empty <byte>(), contentType: "application/xml"));
Assert.Equal("contentType", ex.ParamName);
}
public async Task is_preserved(bool isJson, string data, string metadata)
{
var stream = GetStreamName(isJson, data, metadata);
var encoding = Encoding.UTF8;
var eventData = new EventData(
Uuid.NewUuid(),
"-",
encoding.GetBytes(data),
encoding.GetBytes(metadata),
isJson
? Constants.Metadata.ContentTypes.ApplicationJson
: Constants.Metadata.ContentTypes.ApplicationOctetStream);
await _fixture.Client.AppendToStreamAsync(stream, StreamState.Any, new[] { eventData });
var @event = await _fixture.Client
.ReadStreamAsync(Direction.Forwards, stream, StreamPosition.Start, 1, resolveLinkTos : true)
.FirstOrDefaultAsync();
Assert.Equal(isJson
? Constants.Metadata.ContentTypes.ApplicationJson
: Constants.Metadata.ContentTypes.ApplicationOctetStream, @event.Event.ContentType);
Assert.Equal(data, encoding.GetString(@event.Event.Data.ToArray()));
Assert.Equal(metadata, encoding.GetString(@event.Event.Metadata.ToArray()));
}
public void NullContentTypeThrows()
{
var ex = Assert.Throws <ArgumentNullException>(
() => new EventData(Uuid.NewUuid(), "-", Array.Empty <byte>(), contentType: null));
Assert.Equal("contentType", ex.ParamName);
}
public void NullTypeThrows()
{
var ex = Assert.Throws <ArgumentNullException>(
() => new EventData(Uuid.NewUuid(), null, Array.Empty <byte>()));
Assert.Equal("type", ex.ParamName);
}
private Task <WriteResult> SetStreamMetadataInternal(StreamMetadata metadata,
AppendReq appendReq,
UserCredentials userCredentials,
CancellationToken cancellationToken) =>
AppendToStreamInternal(appendReq, new[] {
new EventData(Uuid.NewUuid(), SystemEventTypes.StreamMetadata,
JsonSerializer.SerializeToUtf8Bytes(metadata, StreamMetadataJsonSerializerOptions)),
}, userCredentials, cancellationToken);
public static Task SetSystemSettingsAsync(
this EventStoreClient client,
SystemSettings settings,
UserCredentials?userCredentials = null, CancellationToken cancellationToken = default)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.AppendToStreamAsync(SystemStreams.SettingsStream, StreamState.Any,
new[] {
new EventData(Uuid.NewUuid(), SystemEventTypes.Settings,
JsonSerializer.SerializeToUtf8Bytes(settings, SystemSettingsJsonSerializerOptions))
}, userCredentials: userCredentials, cancellationToken: cancellationToken));
}
protected override async Task Given()
{
await Client.AppendToStreamAsync(DeletedStream, StreamState.Any, CreateTestEvents());
await Client.SetStreamMetadataAsync(DeletedStream, StreamState.Any,
new StreamMetadata(maxCount : 2));
await Client.AppendToStreamAsync(DeletedStream, StreamState.Any, CreateTestEvents());
await Client.AppendToStreamAsync(DeletedStream, StreamState.Any, CreateTestEvents());
await Client.AppendToStreamAsync(LinkedStream, StreamState.Any, new[] {
new EventData(
Uuid.NewUuid(), SystemEventTypes.LinkTo, Encoding.UTF8.GetBytes("0@" + DeletedStream),
Array.Empty <byte>(), Constants.Metadata.ContentTypes.ApplicationOctetStream)
});
}
protected static EventData CreateLinkToEvent(string originalStreamName, StreamRevision originalRevision)
=> new EventData(Uuid.NewUuid(), SystemEventTypes.LinkTo,
Helper.UTF8NoBom.GetBytes($"{originalRevision.ToInt64()}@{originalStreamName}"));
protected static EventData CreateTestEvent(int index, string type, int metadataSize)
=> new EventData(
eventId: Uuid.NewUuid(),
type: type,
data: Encoding.UTF8.GetBytes($@"{{""x"":{index}}}"),
metadata: Encoding.UTF8.GetBytes("\"" + new string('$', metadataSize) + "\""));
public void ToFormattedStringProducesExpectedResult()
{
var sut = Uuid.NewUuid();
Assert.Equal(sut.ToGuid().ToString("n"), sut.ToString("n"));
}
public void Equality()
{
var sut = Uuid.NewUuid();
Assert.Equal(Uuid.FromGuid(sut.ToGuid()), sut);
}
private async ValueTask <IWriteResult> AppendInternal(BatchAppendReq.Types.Options options,
IEnumerable <EventData> events, CancellationToken cancellationToken)
{
var batchSize = 0;
var correlationId = Uuid.NewUuid();
var correlationIdDto = correlationId.ToDto();
var complete = _pendingRequests.GetOrAdd(correlationId, new TaskCompletionSource <IWriteResult>());
foreach (var appendRequest in GetRequests())
{
await _channel.Writer.WriteAsync(appendRequest, cancellationToken).ConfigureAwait(false);
}
return(await complete.Task.ConfigureAwait(false));
IEnumerable <BatchAppendReq> GetRequests()
{
bool first = true;
var proposedMessages = new List <BatchAppendReq.Types.ProposedMessage>();
foreach (var @event in events)
{
var proposedMessage = new BatchAppendReq.Types.ProposedMessage {
Data = ByteString.CopyFrom(@event.Data.Span),
CustomMetadata = ByteString.CopyFrom(@event.Metadata.Span),
Id = @event.EventId.ToDto(),
Metadata =
{
{ Constants.Metadata.Type, @event.Type },
{ Constants.Metadata.ContentType, @event.ContentType }
}
};
proposedMessages.Add(proposedMessage);
if ((batchSize += proposedMessage.CalculateSize()) <
_settings.OperationOptions.BatchAppendSize)
{
continue;
}
yield return(new BatchAppendReq {
ProposedMessages = { proposedMessages },
CorrelationId = correlationIdDto,
Options = first ? options : null
});
first = false;
proposedMessages.Clear();
batchSize = 0;
}
yield return(new BatchAppendReq {
ProposedMessages = { proposedMessages },
IsFinal = true,
CorrelationId = correlationIdDto,
Options = first ? options : null
});
}
}
public void EqualityOperator()
{
var sut = Uuid.NewUuid();
Assert.True(Uuid.FromGuid(sut.ToGuid()) == sut);
}
public void Inequality()
{
var sut = Uuid.NewUuid();
Assert.NotEqual(Uuid.NewUuid(), sut);
}
public void MalformedContentTypeThrows()
{
Assert.Throws <FormatException>(
() => new EventData(Uuid.NewUuid(), "-", Array.Empty <byte>(), contentType: "application"));
}
protected static EventData CreateTestEvent(int index, string type)
=> new EventData(Uuid.NewUuid(), type, Encoding.UTF8.GetBytes($@"{{""x"":{index}}}"));
public void InequalityOperator()
{
var sut = Uuid.NewUuid();
Assert.True(Uuid.NewUuid() != sut);
}
