public async Task PushAsync_Messages_RelayedToMatchingStreams()
{
var provider = new MessageStreamProvider <IMessage>();
List <IEvent>? eventsList = null;
List <TestEventOne>?testEventOnesList = null;
var eventsStream = provider.CreateStream <IEvent>();
var testEventOneStream = provider.CreateStream <TestEventOne>();
var task1 = Task.Run(() => eventsList = eventsStream.ToList());
var task2 = Task.Run(() => testEventOnesList = testEventOneStream.ToList());
await provider.PushAsync(new TestEventOne());
await provider.PushAsync(new TestEventTwo());
await provider.PushAsync(new TestCommandOne(), false);
await provider.CompleteAsync(); // Implicitly tests that the Complete call is also propagated
await Task.WhenAll(task1, task2);
eventsList.Should().BeEquivalentTo(new TestEventOne(), new TestEventTwo());
testEventOnesList.Should().BeEquivalentTo(new TestEventOne());
}
public async Task Publish_MessageStreamProvider_MessagesNotAutomaticallyEnumerated()
{
var receivedEnumeratedStreams = 0;
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IReadOnlyCollection <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedEnumeratedStreams);
})
.AddDelegateSubscriber(
(List <TestEventOne> list) => { Interlocked.Increment(ref receivedEnumeratedStreams); })));
var streamProvider = new MessageStreamProvider <IEvent>();
await streamPublisher.PublishAsync(streamProvider);
await streamProvider.PushAsync(new TestEventOne(), false);
await streamProvider.PushAsync(new TestEventTwo(), false);
await streamProvider.CompleteAsync();
await AsyncTestingUtil.WaitAsync(() => receivedEnumeratedStreams >= 1, TimeSpan.FromMilliseconds(500));
receivedEnumeratedStreams.Should().Be(0);
}
public async Task Publish_MessageStreamProvider_MessagesNotAutomaticallyEnumerated()
{
var receivedEnumeratedStreams = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AsObservable()
.AddDelegateSubscriber(
(IReadOnlyCollection <IEvent> _) =>
{
Interlocked.Increment(ref receivedEnumeratedStreams);
})
.AddDelegateSubscriber(
(List <TestEventOne> _) => { Interlocked.Increment(ref receivedEnumeratedStreams); }));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var streamProvider = new MessageStreamProvider <IEvent>();
await streamPublisher.PublishAsync(streamProvider);
await streamProvider.PushAsync(new TestEventOne(), false);
await streamProvider.PushAsync(new TestEventTwo(), false);
await streamProvider.CompleteAsync();
await AsyncTestingUtil.WaitAsync(
() => receivedEnumeratedStreams >= 1,
TimeSpan.FromMilliseconds(500));
receivedEnumeratedStreams.Should().Be(0);
}
public async Task CompleteAsync_WhileAsyncEnumeratingStreams_EnumerationCompleted()
{
int?count = null;
var provider = new MessageStreamProvider <int>();
var stream = provider.CreateStream <int>();
var enumerationTask = Task.Run(
async() =>
{
count = await stream.CountAsync();
});
await provider.PushAsync(1);
await provider.PushAsync(2);
await provider.PushAsync(3);
count.Should().BeNull();
await provider.CompleteAsync();
await enumerationTask;
count.Should().Be(3);
}
public async Task CopyTo_MessageStreamCopied()
{
var streamProvider = new MessageStreamProvider <IRawInboundEnvelope>();
var chunkStream = new ChunkStream(streamProvider.CreateStream <IRawInboundEnvelope>());
var output = new MemoryStream(Encoding.UTF8.GetBytes("some junk-"));
var copyTask = Task.Run(() => chunkStream.CopyTo(output));
await streamProvider.PushAsync(
new RawInboundEnvelope(
Encoding.UTF8.GetBytes("Silver"),
null,
TestConsumerEndpoint.GetDefault(),
"test",
new TestOffset()));
await streamProvider.PushAsync(
new RawInboundEnvelope(
Encoding.UTF8.GetBytes("back"),
null,
TestConsumerEndpoint.GetDefault(),
"test",
new TestOffset()));
await streamProvider.CompleteAsync();
await copyTask;
chunkStream.Close();
Encoding.UTF8.GetString(output.ToArray()).Should().Be("Silverback");
}
public async Task Subscribe_StreamPushedAndCompleted_SubscribeReturned()
{
int count = 0;
var subscribeTask = Task.Run(() => _observable.Subscribe(_ => count++));
await _streamProvider.PushAsync(1);
await _streamProvider.PushAsync(2);
await _streamProvider.PushAsync(3);
await _streamProvider.CompleteAsync();
await subscribeTask;
count.Should().Be(3);
}
public async Task PushAsync_Envelopes_RelayedToStream()
{
var provider = new MessageStreamProvider <TestEnvelope>();
var stream = provider.CreateStream <TestEnvelope>();
List <TestEnvelope>?envelopes = null;
var task = Task.Run(() => envelopes = stream.ToList());
await provider.PushAsync(new TestEnvelope(new TestEventOne()));
await provider.PushAsync(new TestEnvelope(new TestEventTwo()));
await provider.PushAsync(new TestEnvelope(new TestCommandOne()));
await provider.CompleteAsync(); // Implicitly tests that the Complete call is also propagated
await task;
envelopes.Should().HaveCount(3);
}
/// <summary>
/// Marks the sequence as complete, meaning no more messages will be pushed.
/// </summary>
/// <param name="cancellationToken">
/// A <see cref="CancellationToken" /> used to cancel the operation.
/// </param>
/// <returns>
/// A <see cref="Task" /> representing the asynchronous operation.
/// </returns>
protected virtual async Task CompleteAsync(CancellationToken cancellationToken = default)
{
if (!IsPending)
{
return;
}
_logger.LogTrace(
IntegrationEventIds.LowLevelTracing,
"Completing {sequenceType} '{sequenceId}' (length {sequenceLength})...",
GetType().Name,
SequenceId,
Length);
IsComplete = true;
IsCompleting = false;
_timeoutCancellationTokenSource?.Cancel();
await Context.SequenceStore.RemoveAsync(SequenceId).ConfigureAwait(false);
await _streamProvider.CompleteAsync(cancellationToken).ConfigureAwait(false);
}
public async Task CreateLazyStream_PushingMessages_StreamCreatedWhenMatchingMessagePushed()
{
var provider = new MessageStreamProvider <IEvent>();
var lazyStream = provider.CreateLazyStream <TestEventTwo>();
List <TestEventTwo> receivedTwos = new();
Task.Run(
async() =>
{
await lazyStream.WaitUntilCreatedAsync();
foreach (var message in lazyStream.Stream !)
{
receivedTwos.Add(message);
}
}).FireAndForget();
var createStreamTask = lazyStream.WaitUntilCreatedAsync();
await provider.PushAsync(new TestEventOne(), false);
await provider.PushAsync(new TestEventOne(), false);
createStreamTask.Status.Should().NotBe(TaskStatus.RanToCompletion);
lazyStream.Stream.Should().BeNull();
await provider.PushAsync(new TestEventTwo());
createStreamTask.Status.Should().Be(TaskStatus.RanToCompletion);
lazyStream.Stream.Should().BeOfType <MessageStreamEnumerable <TestEventTwo> >();
await provider.PushAsync(new TestEventTwo());
receivedTwos.Should().HaveCount(2);
await provider.CompleteAsync();
}
