public async Task can_be_hard_deleted()
        {
            var stream = _fixture.GetStreamName();

            var writeResult =
                await _fixture.Client.AppendToStreamAsync(stream, StreamState.NoStream,
                                                          _fixture.CreateTestEvents(2));

            Assert.Equal(new StreamRevision(1), writeResult.NextExpectedStreamRevision);

            await _fixture.Client.SoftDeleteAsync(stream, new StreamRevision(1));

            await _fixture.Client.TombstoneAsync(stream, StreamState.Any);

            var ex = await Assert.ThrowsAsync <StreamDeletedException>(
                () => _fixture.Client.ReadStreamAsync(Direction.Forwards, stream, StreamPosition.Start)
                .ToArrayAsync().AsTask());

            Assert.Equal(stream, ex.Stream);

            ex = await Assert.ThrowsAsync <StreamDeletedException>(()
                                                                   => _fixture.Client.GetStreamMetadataAsync(stream));

            Assert.Equal(SystemStreams.MetastreamOf(stream), ex.Stream);

            await Assert.ThrowsAsync <StreamDeletedException>(
                () => _fixture.Client.AppendToStreamAsync(stream, StreamState.Any, _fixture.CreateTestEvents()));
        }
 private Task <IWriteResult> SetStreamMetadataAsync(string streamName, StreamState expectedState,
                                                    StreamMetadata metadata, EventStoreClientOperationOptions operationOptions,
                                                    UserCredentials?userCredentials = null, CancellationToken cancellationToken = default)
 => SetStreamMetadataInternal(metadata, new AppendReq {
     Options = new AppendReq.Types.Options {
         StreamName = SystemStreams.MetastreamOf(streamName)
     }
 }.WithAnyStreamRevision(expectedState), operationOptions, userCredentials, cancellationToken);
Beispiel #3
0
 public Task <WriteResult> SetStreamMetadataAsync(string streamName, AnyStreamRevision expectedRevision,
                                                  StreamMetadata metadata, UserCredentials userCredentials = default,
                                                  CancellationToken cancellationToken = default)
 => SetStreamMetadataInternal(metadata, new AppendReq {
     Options = new AppendReq.Types.Options {
         StreamName = SystemStreams.MetastreamOf(streamName)
     }
 }.WithAnyStreamRevision(expectedRevision), userCredentials, cancellationToken);
Beispiel #4
0
 private Task <WriteResult> SetStreamMetadataAsync(string streamName, StreamRevision expectedRevision,
                                                   StreamMetadata metadata, EventStoreClientOperationOptions operationOptions,
                                                   UserCredentials userCredentials = default, CancellationToken cancellationToken = default)
 => SetStreamMetadataInternal(metadata, new AppendReq {
     Options = new AppendReq.Types.Options {
         StreamName = SystemStreams.MetastreamOf(streamName),
         Revision   = expectedRevision
     }
 }, operationOptions, userCredentials, cancellationToken);
Beispiel #5
0
        public async Task <StreamMetadataResult> GetStreamMetadataAsync(string streamName,
                                                                        UserCredentials userCredentials = default, CancellationToken cancellationToken = default)
        {
            ResolvedEvent metadata = default;

            try {
                metadata = await ReadStreamAsync(Direction.Backwards, SystemStreams.MetastreamOf(streamName), StreamRevision.End, 1,
                                                 false,
                                                 userCredentials : userCredentials,
                                                 cancellationToken : cancellationToken).FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);
            } catch (StreamNotFoundException) {
                return(StreamMetadataResult.None(streamName));
            }

            return(metadata.Event == null
                                ? StreamMetadataResult.None(streamName)
                                : StreamMetadataResult.Create(
                       streamName,
                       metadata.OriginalEventNumber,
                       JsonSerializer.Deserialize <StreamMetadata>(metadata.Event.Data, StreamMetadataJsonSerializerOptions)));
        }
        private async Task <StreamMetadataResult> GetStreamMetadataAsync(string streamName,
                                                                         EventStoreClientOperationOptions operationOptions, UserCredentials?userCredentials = null,
                                                                         CancellationToken cancellationToken = default)
        {
            ResolvedEvent metadata;

            _log.LogDebug("Read stream metadata for {streamName}.");

            try {
                metadata = await ReadStreamAsync(Direction.Backwards, SystemStreams.MetastreamOf(streamName), StreamPosition.End, 1, operationOptions, false, userCredentials, cancellationToken)
                           .FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);
            } catch (StreamNotFoundException) {
                _log.LogWarning("Stream metadata for {streamName} not found.");
                return(StreamMetadataResult.None(streamName));
            }

            return(metadata.Event == null
                                ? StreamMetadataResult.None(streamName)
                                : StreamMetadataResult.Create(streamName, metadata.OriginalEventNumber,
                                                              JsonSerializer.Deserialize <StreamMetadata>(metadata.Event.Data.Span,
                                                                                                          StreamMetadataJsonSerializerOptions)));
        }