public async Task Abort_WhileAsyncEnumeratingStreams_EnumerationAborted()
{
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();
provider.Abort();
await AsyncTestingUtil.WaitAsync(() => enumerationTask.IsCompleted);
count.Should().BeNull();
enumerationTask.Status.Should().Be(TaskStatus.Canceled);
}
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 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 Publish_MessageStreamProvidePlusBehavior_StreamedMessagesReceived()
{
var receivedStreams = 0;
var receivedEvents = 0;
var testBehavior = new TestBehavior();
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedEvents);
}
}),
new IBehavior[] { testBehavior }));
var streamProvider = new MessageStreamProvider <IEvent>();
await streamPublisher.PublishAsync(streamProvider);
await streamProvider.PushAsync(new TestEventOne());
await streamProvider.PushAsync(new TestEventTwo());
await AsyncTestingUtil.WaitAsync(() => receivedEvents >= 2);
receivedStreams.Should().Be(1);
receivedEvents.Should().Be(2);
}
public async Task Publish_MessageStreamProviderOfEnvelopes_OnlyAutoUnwrapMessagesReceived()
{
var receivedEvents = new List <IEvent>();
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AsObservable()
.AddDelegateSubscriber(
(IMessageStreamObservable <IEvent> observable) =>
{
observable.Subscribe(message => receivedEvents.Add(message));
}));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var streamProvider = new MessageStreamProvider <IEnvelope>();
await streamPublisher.PublishAsync(streamProvider);
await streamProvider.PushAsync(new TestEnvelope(new TestEventOne(), false), false);
await streamProvider.PushAsync(new TestEnvelope(new TestEventTwo()));
await AsyncTestingUtil.WaitAsync(() => receivedEvents.Count >= 1);
receivedEvents.Should().HaveCount(1);
receivedEvents[0].Should().BeOfType <TestEventTwo>();
}
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 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 Publish_MessageStreamProvidePlusBehavior_MessagesReceived()
{
var receivedStreams = 0;
var receivedEvents = 0;
var testBehavior = new TestBehavior();
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedEvents);
}
})
.AddSingletonBehavior(testBehavior));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var streamProvider = new MessageStreamProvider <IEvent>();
await streamPublisher.PublishAsync(streamProvider);
await streamProvider.PushAsync(new TestEventOne());
await streamProvider.PushAsync(new TestEventTwo());
await AsyncTestingUtil.WaitAsync(() => receivedEvents >= 2);
receivedStreams.Should().Be(1);
receivedEvents.Should().Be(2);
}
public async Task Publish_StreamProviderOfEnvelopes_OnlyMatchingUnwrappedMessagesReceived()
{
var receivedStreamsOfOnes = 0;
var receivedTestEventOnes = 0;
var receivedStreamsOfTwos = 0;
var receivedTestEventTwos = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddDelegateSubscriber(
(IMessageStreamEnumerable <TestEventOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreamsOfOnes);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedTestEventOnes);
}
})
.AddDelegateSubscriber(
(IMessageStreamEnumerable <TestEventTwo> enumerable) =>
{
Interlocked.Increment(ref receivedStreamsOfTwos);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedTestEventTwos);
}
}));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var stream = new MessageStreamProvider <IEnvelope>();
await streamPublisher.PublishAsync(stream);
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await AsyncTestingUtil.WaitAsync(() => receivedTestEventTwos >= 2);
receivedStreamsOfOnes.Should().Be(0);
receivedTestEventOnes.Should().Be(0);
receivedStreamsOfTwos.Should().Be(1);
receivedTestEventTwos.Should().Be(2);
await stream.PushAsync(new TestEnvelope(new TestEventOne()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await stream.PushAsync(new TestEnvelope(new TestEventOne()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await AsyncTestingUtil.WaitAsync(() => receivedTestEventTwos >= 4);
receivedStreamsOfOnes.Should().Be(1);
receivedTestEventOnes.Should().Be(2);
receivedStreamsOfTwos.Should().Be(1);
receivedTestEventTwos.Should().Be(4);
}
public async Task Publish_MessageStreamProviderOfEnvelopes_OnlyAutoUnwrapMessagesReceived()
{
var receivedEvents = new List <IEvent>();
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
foreach (var envelope in enumerable)
{
receivedEvents.Add(envelope);
}
})));
var streamProvider = new MessageStreamProvider <IEnvelope>();
await streamPublisher.PublishAsync(streamProvider);
await streamProvider.PushAsync(new TestEnvelope(new TestEventOne(), false), false);
await streamProvider.PushAsync(new TestEnvelope(new TestEventTwo()));
await AsyncTestingUtil.WaitAsync(() => receivedEvents.Count >= 1);
receivedEvents.Should().HaveCount(1);
receivedEvents[0].Should().BeOfType <TestEventTwo>();
}
public async Task PushAsync_WhileAsyncEnumeratingStream_BackpressureIsHandled()
{
var provider = new MessageStreamProvider <int>();
var stream = provider.CreateStream <int>();
var enumerator = stream.GetAsyncEnumerator();
var pushTask1 = provider.PushAsync(1);
var pushTask2 = provider.PushAsync(2);
var pushTask3 = provider.PushAsync(3);
await enumerator.MoveNextAsync();
await Task.Delay(100);
pushTask1.IsCompleted.Should().BeFalse();
await enumerator.MoveNextAsync();
await AsyncTestingUtil.WaitAsync(() => pushTask1.IsCompleted);
pushTask1.IsCompleted.Should().BeTrue();
await Task.Delay(100);
pushTask2.IsCompleted.Should().BeFalse();
pushTask3.IsCompleted.Should().BeFalse();
await enumerator.MoveNextAsync();
await AsyncTestingUtil.WaitAsync(() => pushTask2.IsCompleted);
pushTask2.IsCompleted.Should().BeTrue();
pushTask3.IsCompleted.Should().BeFalse();
}
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 void CreateStream_CalledTwiceForSameType_NewInstanceReturned()
{
var provider = new MessageStreamProvider <IMessage>();
var stream1 = provider.CreateStream <IEvent>();
var stream2 = provider.CreateStream <IEvent>();
stream2.Should().NotBeSameAs(stream1);
}
public async Task Publish_MessageStreamProviderOfEnvelopes_OnlyMatchingUnwrappedMessagesReceived()
{
var receivedStreamsOfOnes = 0;
var receivedTestEventOnes = 0;
var receivedStreamsOfTwos = 0;
var receivedTestEventTwos = 0;
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IMessageStreamEnumerable <TestEventOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreamsOfOnes);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedTestEventOnes);
}
})
.AddDelegateSubscriber(
(IMessageStreamEnumerable <TestEventTwo> enumerable) =>
{
Interlocked.Increment(ref receivedStreamsOfTwos);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedTestEventTwos);
}
})));
var stream = new MessageStreamProvider <IEnvelope>();
await streamPublisher.PublishAsync(stream);
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await AsyncTestingUtil.WaitAsync(() => receivedTestEventTwos >= 2);
receivedStreamsOfOnes.Should().Be(0);
receivedTestEventOnes.Should().Be(0);
receivedStreamsOfTwos.Should().Be(1);
receivedTestEventTwos.Should().Be(2);
await stream.PushAsync(new TestEnvelope(new TestEventOne()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await stream.PushAsync(new TestEnvelope(new TestEventOne()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await AsyncTestingUtil.WaitAsync(() => receivedTestEventTwos >= 4);
receivedStreamsOfOnes.Should().Be(1);
receivedTestEventOnes.Should().Be(2);
receivedStreamsOfTwos.Should().Be(1);
receivedTestEventTwos.Should().Be(4);
}
public void CreateStream_GenericAndNonGenericVersions_EquivalentInstanceReturned()
{
var provider = new MessageStreamProvider <IMessage>();
var stream1 = provider.CreateStream <IEvent>();
var stream2 = provider.CreateStream(typeof(IEvent));
stream2.Should().BeOfType(stream1.GetType());
}
public async Task Publish_MessageStreamProvider_OnlyRequiredStreamsPublished()
{
var receivedStreams = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AsObservable()
.AddDelegateSubscriber(
(IMessageStreamObservable <IEvent> observable) =>
{
Interlocked.Increment(ref receivedStreams);
observable.Subscribe(_ => { });
})
.AddDelegateSubscriber(
(IMessageStreamObservable <TestEventOne> observable) =>
{
Interlocked.Increment(ref receivedStreams);
observable.Subscribe(_ => { });
})
.AddDelegateSubscriber(
(IMessageStreamObservable <TestCommandOne> observable) =>
{
Interlocked.Increment(ref receivedStreams);
observable.Subscribe(_ => { });
}));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var streamProvider1 = new MessageStreamProvider <IEvent>();
var streamProvider2 = new MessageStreamProvider <IEvent>();
await Task.Delay(100);
receivedStreams.Should().Be(0);
streamPublisher.Publish(streamProvider1);
await streamPublisher.PublishAsync(streamProvider2);
await streamProvider1.PushAsync(new TestEventTwo());
await Task.Delay(100);
receivedStreams.Should().Be(1);
await streamProvider1.PushAsync(new TestEventOne());
await AsyncTestingUtil.WaitAsync(() => receivedStreams >= 2);
receivedStreams.Should().Be(2);
await streamProvider2.PushAsync(new TestEventOne());
await AsyncTestingUtil.WaitAsync(() => receivedStreams >= 4);
receivedStreams.Should().Be(4);
}
public async Task Publish_MessageStreamProvider_OnlyRequiredStreamsPublished()
{
var receivedStreams = 0;
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
var dummy = enumerable.ToList();
})
.AddDelegateSubscriber(
(IMessageStreamEnumerable <TestEventOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
var dummy = enumerable.ToList();
})
.AddDelegateSubscriber(
(IMessageStreamEnumerable <TestCommandOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
var dummy = enumerable.ToList();
})));
var streamProvider1 = new MessageStreamProvider <IEvent>();
var streamProvider2 = new MessageStreamProvider <IEvent>();
await Task.Delay(100);
receivedStreams.Should().Be(0);
streamPublisher.Publish(streamProvider1);
await streamPublisher.PublishAsync(streamProvider2);
await streamProvider1.PushAsync(new TestEventTwo());
await Task.Delay(100);
receivedStreams.Should().Be(1);
await streamProvider1.PushAsync(new TestEventOne());
await AsyncTestingUtil.WaitAsync(() => receivedStreams >= 2);
receivedStreams.Should().Be(2);
await streamProvider2.PushAsync(new TestEventOne());
await AsyncTestingUtil.WaitAsync(() => receivedStreams >= 4);
receivedStreams.Should().Be(4);
}
public async Task PushAsync_EnvelopeWithoutMatchingStream_ExceptionThrown()
{
var provider = new MessageStreamProvider <IEnvelope>();
var stream = provider.CreateStream <TestEventOne>();
Task.Run(() => stream.ToList()).FireAndForget();
await provider.PushAsync(new TestEnvelope(new TestEventOne()));
Func <Task> act = () => provider.PushAsync(new TestEnvelope(new TestEventTwo()));
act.Should().Throw <UnhandledMessageException>();
}
public async Task PushAsync_MessageWithoutMatchingStreamDisablingException_NoExceptionThrown()
{
var provider = new MessageStreamProvider <IMessage>();
var stream = provider.CreateStream <TestEventOne>();
Task.Run(() => stream.ToList()).FireAndForget();
await provider.PushAsync(new TestEventOne());
Func <Task> act = () => provider.PushAsync(new TestEventTwo(), false);
act.Should().NotThrow();
}
public async Task Publish_StreamProviderSubscribedAsEnumerable_MessagesReceived()
{
var receivedStreams = 0;
var receivedEvents = 0;
var receivedTestEventOnes = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddDelegateSubscriber(
(IEnumerable <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedEvents);
}
})
.AddDelegateSubscriber(
(IEnumerable <TestEventOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedTestEventOnes);
}
}));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var streamProvider1 = new MessageStreamProvider <IEvent>();
var streamProvider2 = new MessageStreamProvider <IEvent>();
streamPublisher.Publish(streamProvider1);
await streamPublisher.PublishAsync(streamProvider2);
await streamProvider1.PushAsync(new TestEventOne());
await streamProvider2.PushAsync(new TestEventOne());
await streamProvider1.PushAsync(new TestEventTwo());
await streamProvider2.PushAsync(new TestEventTwo());
await AsyncTestingUtil.WaitAsync(() => receivedEvents >= 4 && receivedTestEventOnes >= 2);
receivedStreams.Should().Be(4);
receivedEvents.Should().Be(4);
receivedTestEventOnes.Should().Be(2);
}
public async Task PushAsync_WhileAsyncEnumeratingMultipleStreams_BackpressureIsHandled()
{
var provider = new MessageStreamProvider <int>();
var stream1 = provider.CreateStream <int>();
var stream2 = provider.CreateStream <int>();
var enumerator1 = stream1.GetAsyncEnumerator();
var enumerator2 = stream2.GetAsyncEnumerator();
var pushTask1 = provider.PushAsync(1);
var pushTask2 = provider.PushAsync(2);
provider.PushAsync(3).FireAndForget();
await enumerator1.MoveNextAsync();
await enumerator2.MoveNextAsync();
await Task.Delay(100);
pushTask1.IsCompleted.Should().BeFalse();
await enumerator1.MoveNextAsync();
await Task.Delay(100);
pushTask1.IsCompleted.Should().BeFalse();
await enumerator2.MoveNextAsync();
await AsyncTestingUtil.WaitAsync(() => pushTask1.IsCompleted);
pushTask1.IsCompleted.Should().BeTrue();
await Task.Delay(100);
pushTask2.IsCompleted.Should().BeFalse();
await enumerator1.MoveNextAsync();
await Task.Delay(100);
pushTask2.IsCompleted.Should().BeFalse();
await enumerator2.MoveNextAsync();
await AsyncTestingUtil.WaitAsync(() => pushTask2.IsCompleted);
pushTask2.IsCompleted.Should().BeTrue();
}
public async Task Publish_MessageStreamProvider_StreamedMessagesReceived()
{
var receivedStreams = 0;
var receivedEvents = 0;
var receivedTestEventOnes = 0;
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedEvents);
}
})
.AddDelegateSubscriber(
async(IMessageStreamEnumerable <TestEventOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
await foreach (var dummy in enumerable)
{
Interlocked.Increment(ref receivedTestEventOnes);
}
})));
var streamProvider1 = new MessageStreamProvider <IEvent>();
var streamProvider2 = new MessageStreamProvider <IEvent>();
streamPublisher.Publish(streamProvider1);
await streamPublisher.PublishAsync(streamProvider2);
await streamProvider1.PushAsync(new TestEventOne());
await streamProvider2.PushAsync(new TestEventOne());
await streamProvider1.PushAsync(new TestEventTwo());
await streamProvider2.PushAsync(new TestEventTwo());
await AsyncTestingUtil.WaitAsync(() => receivedEvents >= 4 && receivedTestEventOnes >= 2);
receivedStreams.Should().Be(4);
receivedEvents.Should().Be(4);
receivedTestEventOnes.Should().Be(2);
}
public async Task Publish_StreamProvider_ProcessExceptionRethrown()
{
var receivedStreams = 0;
var received = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
foreach (var dummy in enumerable)
{
if (Interlocked.Increment(ref received) >= 3)
{
throw new TestException();
}
}
})
.AddDelegateSubscriber(
async(IMessageStreamEnumerable <TestEventOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
await foreach (var dummy in enumerable)
{
Interlocked.Increment(ref received);
}
}));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var streamProvider = new MessageStreamProvider <IEvent>();
var tasks = streamPublisher.Publish(streamProvider);
streamProvider.PushAsync(new TestEventOne()).FireAndForget();
streamProvider.PushAsync(new TestEventOne()).FireAndForget();
streamProvider.PushAsync(new TestEventOne()).FireAndForget();
await AsyncTestingUtil.WaitAsync(() => received >= 5);
Func <Task> act = async() => await await Task.WhenAny(tasks);
await act.Should().ThrowAsync <TargetInvocationException>();
}
public async Task PublishAsync_MessageStreamProviderAbortedAfterException_AllPendingTasksCompleted()
{
var received = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AsObservable()
.AddDelegateSubscriber(
(IMessageStreamObservable <IEvent> observable) =>
{
observable.Subscribe(
_ =>
{
if (Interlocked.Increment(ref received) >= 3)
{
throw new TestException();
}
});
})
.AddDelegateSubscriber(
(IMessageStreamObservable <TestEventOne> observable) =>
{
observable.Subscribe(_ => { });
}));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var streamProvider = new MessageStreamProvider <IEvent>();
var tasks = await streamPublisher.PublishAsync(streamProvider);
streamProvider.PushAsync(new TestEventOne()).FireAndForget();
streamProvider.PushAsync(new TestEventOne()).FireAndForget();
streamProvider.PushAsync(new TestEventOne()).FireAndForget();
var whenAnyTask = await Task.WhenAny(tasks);
whenAnyTask.Status.Should().Be(TaskStatus.Faulted);
streamProvider.Abort();
await AsyncTestingUtil.WaitAsync(() => tasks.All(task => task.IsCompleted));
tasks.All(task => task.IsCompleted).Should().BeTrue();
}
public async Task PublishAsync_MessageStreamProviderAbortedAfterException_AllPendingTasksCompleted()
{
var received = 0;
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
foreach (var dummy in enumerable)
{
if (Interlocked.Increment(ref received) >= 3)
{
throw new TestException();
}
}
})
.AddDelegateSubscriber(
async(IMessageStreamEnumerable <TestEventOne> enumerable) =>
{
await foreach (var dummy in enumerable)
{
}
})));
var streamProvider = new MessageStreamProvider <IEvent>();
var tasks = await streamPublisher.PublishAsync(streamProvider);
streamProvider.PushAsync(new TestEventOne()).RunWithoutBlocking();
streamProvider.PushAsync(new TestEventOne()).RunWithoutBlocking();
streamProvider.PushAsync(new TestEventOne()).RunWithoutBlocking();
var whenAnyTask = await Task.WhenAny(tasks);
whenAnyTask.Status.Should().Be(TaskStatus.Faulted);
streamProvider.Abort();
await AsyncTestingUtil.WaitAsync(() => tasks.All(task => task.IsCompleted));
tasks.All(task => task.IsCompleted).Should().BeTrue();
}
public async Task Publish_MessageStreamProvider_ProcessExceptionRethrown()
{
var receivedStreams = 0;
var received = 0;
var streamPublisher = new StreamPublisher(
PublisherTestsHelper.GetPublisher(
builder => builder
.AddDelegateSubscriber(
(IMessageStreamEnumerable <IEvent> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
foreach (var dummy in enumerable)
{
if (Interlocked.Increment(ref received) >= 3)
{
throw new TestException();
}
}
})
.AddDelegateSubscriber(
async(IMessageStreamEnumerable <TestEventOne> enumerable) =>
{
Interlocked.Increment(ref receivedStreams);
await foreach (var dummy in enumerable)
{
Interlocked.Increment(ref received);
}
})));
var streamProvider = new MessageStreamProvider <IEvent>();
var tasks = streamPublisher.Publish(streamProvider);
streamProvider.PushAsync(new TestEventOne()).RunWithoutBlocking();
streamProvider.PushAsync(new TestEventOne()).RunWithoutBlocking();
streamProvider.PushAsync(new TestEventOne()).RunWithoutBlocking();
await AsyncTestingUtil.WaitAsync(() => received >= 5);
Func <Task> act = async() => await await Task.WhenAny(tasks);
act.Should().Throw <TargetInvocationException>();
}
public async Task Publish_MessageStreamProviderOfEnvelopes_StreamedUnwrappedMessagesReceived()
{
var receivedStreams = 0;
var receivedTestEventOnes = 0;
var receivedTestEnvelopes = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AsObservable()
.AddDelegateSubscriber(
(IMessageStreamObservable <TestEventOne> observable) =>
{
Interlocked.Increment(ref receivedStreams);
observable.Subscribe(_ => Interlocked.Increment(ref receivedTestEventOnes));
})
.AddDelegateSubscriber(
(IMessageStreamObservable <TestEnvelope> observable) =>
{
Interlocked.Increment(ref receivedStreams);
observable.Subscribe(_ => Interlocked.Increment(ref receivedTestEnvelopes));
}));
var streamPublisher = serviceProvider.GetRequiredService <IStreamPublisher>();
var stream = new MessageStreamProvider <IEnvelope>();
await streamPublisher.PublishAsync(stream);
await stream.PushAsync(new TestEnvelope(new TestEventOne()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await stream.PushAsync(new TestEnvelope(new TestEventOne()));
await stream.PushAsync(new TestEnvelope(new TestEventTwo()));
await AsyncTestingUtil.WaitAsync(() => receivedTestEventOnes >= 2 && receivedTestEnvelopes >= 4);
receivedStreams.Should().Be(2);
receivedTestEventOnes.Should().Be(2);
receivedTestEnvelopes.Should().Be(4);
}
/// <summary>
/// Initializes a new instance of the <see cref="SequenceBase{TEnvelope}" /> class.
/// </summary>
/// <param name="sequenceId">
/// The identifier that is used to match the consumed messages with their belonging sequence.
/// </param>
/// <param name="context">
/// The current <see cref="ConsumerPipelineContext" />, assuming that it will be the one from which the
/// sequence gets published to the internal bus.
/// </param>
/// <param name="enforceTimeout">
/// A value indicating whether the timeout has to be enforced.
/// </param>
/// <param name="timeout">
/// The timeout to be applied. If not specified the value of <c>Endpoint.Sequence.Timeout</c> will be
/// used.
/// </param>
/// <param name="streamProvider">
/// The <see cref="IMessageStreamProvider" /> to be pushed. A new one will be created if not provided.
/// </param>
protected SequenceBase(
string sequenceId,
ConsumerPipelineContext context,
bool enforceTimeout = true,
TimeSpan?timeout = null,
IMessageStreamProvider?streamProvider = null)
{
SequenceId = Check.NotNull(sequenceId, nameof(sequenceId));
Context = Check.NotNull(context, nameof(context));
_streamProvider = streamProvider as MessageStreamProvider <TEnvelope> ??
new MessageStreamProvider <TEnvelope>();
_logger = context.ServiceProvider
.GetRequiredService <ISilverbackIntegrationLogger <SequenceBase <TEnvelope> > >();
_enforceTimeout = enforceTimeout;
_timeout = timeout ?? Context.Envelope.Endpoint.Sequence.Timeout;
ResetTimeout();
}
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);
}
public async Task PushAsync_Messages_ReturnedAfterMessagesProcessed()
{
var provider = new MessageStreamProvider <IMessage>();
var stream = provider.CreateStream <IEvent>();
var processed = false;
Task.Run(
async() =>
{
await Task.Delay(50);
stream.GetEnumerator().MoveNext();
await Task.Delay(50);
processed = true;
stream.GetEnumerator().MoveNext();
}).FireAndForget();
await provider.PushAsync(new TestEventOne());
processed.Should().BeTrue();
}
