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 ConnectAsync_WithEndpointConfigurators_InvokedOnce()
{
var configurator1 = Substitute.For <IEndpointsConfigurator>();
var configurator2 = Substitute.For <IEndpointsConfigurator>();
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.AddBroker <TestOtherBroker>())
.AddEndpointsConfigurator(_ => configurator1)
.AddEndpointsConfigurator(_ => configurator2));
var broker = serviceProvider.GetRequiredService <TestBroker>();
var otherBroker = serviceProvider.GetRequiredService <TestOtherBroker>();
await broker.ConnectAsync();
await otherBroker.ConnectAsync();
await broker.ConnectAsync();
await otherBroker.ConnectAsync();
configurator1.Received(1).Configure(Arg.Any <IEndpointsConfigurationBuilder>());
configurator2.Received(1).Configure(Arg.Any <IEndpointsConfigurationBuilder>());
}
public async Task InvokeAsync_NoMatchingHandler_TypesResolvedOnlyOnce()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(options => options.AddBroker <TestBroker>()));
var substituteServiceProvider = Substitute.For <IServiceProvider>();
substituteServiceProvider
.GetService(typeof(IEnumerable <IBrokerCallback>))
.Returns(Array.Empty <IBrokerCallback>());
var invoker = serviceProvider.GetRequiredService <IBrokerCallbacksInvoker>();
await invoker.InvokeAsync <ICallbackOneHandlerAsync>(
handler => handler.HandleAsync(),
substituteServiceProvider);
await invoker.InvokeAsync <ICallbackTwoHandlerAsync>(
handler => handler.HandleAsync(),
substituteServiceProvider);
await invoker.InvokeAsync <ICallbackOneHandlerAsync>(
handler => handler.HandleAsync(),
substituteServiceProvider);
substituteServiceProvider.ReceivedWithAnyArgs(1).GetService(null !);
}
public async Task AddInbound_WithMessageTypeParameter_TypedDefaultSerializerSet()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(broker => broker.AddKafka())
.AddKafkaEndpoints(
endpoints => endpoints
.Configure(
config =>
{
config.BootstrapServers = "PLAINTEXT://unittest";
})
.AddInbound(
typeof(TestEventOne),
endpoint => endpoint
.Configure(
config =>
{
config.GroupId = "group";
})
.ConsumeFrom("test"))));
var broker = serviceProvider.GetRequiredService <KafkaBroker>();
await broker.ConnectAsync();
broker.Consumers[0].Endpoint.Serializer.Should().BeOfType <JsonMessageSerializer <TestEventOne> >();
}
public async Task StartAsync_ExceptionWithRetryEnabled_ConnectRetried()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddTransient(_ => Substitute.For <IApplicationLifetime>())
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.AddBroker <TestOtherBroker>()
.WithConnectionOptions(
new BrokerConnectionOptions
{
Mode = BrokerConnectionMode.Startup,
RetryOnFailure = true,
RetryInterval = TimeSpan.FromMilliseconds(1)
})));
var testBroker = serviceProvider.GetRequiredService <TestBroker>();
testBroker.SimulateConnectIssues = true;
var service = serviceProvider.GetServices <IHostedService>().OfType <BrokerConnectorService>().Single();
await service.StartAsync(CancellationToken.None);
var brokers = serviceProvider.GetRequiredService <IBrokerCollection>();
brokers.ForEach(broker => broker.IsConnected.Should().BeTrue());
testBroker.SimulateConnectIssues.Should().BeFalse(); // Check that the exception mechanism what triggered
}
public async Task Publish_SimpleMessageAndObservableOfMessages_StreamSubscribersNotInvoked()
{
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(_ => { });
}));
var publisher = serviceProvider.GetRequiredService <IPublisher>();
publisher.Publish(new TestEventOne());
await publisher.PublishAsync(new TestEventTwo());
await Task.Delay(200);
receivedStreams.Should().Be(0);
}
public async Task CheckHealthAsync_ConsumerNotReady_UnhealthyReturned()
{
var statusInfo = Substitute.For <IConsumerStatusInfo>();
statusInfo.Status.Returns(ConsumerStatus.Connected);
var consumer = Substitute.For <IConsumer>();
consumer.StatusInfo.Returns(statusInfo);
consumer.Id.Returns(new InstanceIdentifier(Guid.Empty));
consumer.Endpoint.Returns(new TestConsumerEndpoint("topic1"));
var broker = Substitute.For <IBroker>();
broker.ProducerEndpointType.Returns(typeof(TestProducerEndpoint));
broker.ConsumerEndpointType.Returns(typeof(TestConsumerEndpoint));
broker.Consumers.Returns(new[] { consumer });
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddSilverback()
.Services
.AddSingleton <IBrokerCollection>(new BrokerCollection(new[] { broker }))
.AddHealthChecks()
.AddConsumersCheck());
var(healthCheck, context) = GetHealthCheck(serviceProvider);
var result = await healthCheck.CheckHealthAsync(context);
result.Status.Should().Be(HealthStatus.Unhealthy);
result.Description.Should().Be(
$"One or more consumers are not connected:{Environment.NewLine}" +
"- topic1 [00000000-0000-0000-0000-000000000000]");
}
public async Task StartAsync_ConnectAfterStartup_BrokerConnectedAfterLifetimeEvent()
{
var appStartedTokenSource = new CancellationTokenSource();
var lifetimeEvents = Substitute.For <IHostApplicationLifetime>();
lifetimeEvents.ApplicationStarted.Returns(appStartedTokenSource.Token);
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddTransient(_ => lifetimeEvents)
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.WithConnectionOptions(
new BrokerConnectionOptions
{
Mode = BrokerConnectionMode.AfterStartup
})));
var service = serviceProvider.GetServices <IHostedService>().OfType <BrokerConnectorService>().Single();
await service.StartAsync(CancellationToken.None);
var testBroker = serviceProvider.GetRequiredService <TestBroker>();
testBroker.IsConnected.Should().BeFalse();
appStartedTokenSource.Cancel();
testBroker.IsConnected.Should().BeTrue();
}
public async Task CheckHealthAsync_ConsumerReady_HealthyReturned()
{
var statusInfo = Substitute.For <IConsumerStatusInfo>();
statusInfo.Status.Returns(ConsumerStatus.Ready);
var consumer = Substitute.For <IConsumer>();
consumer.StatusInfo.Returns(statusInfo);
var broker = Substitute.For <IBroker>();
broker.ProducerEndpointType.Returns(typeof(TestProducerEndpoint));
broker.ConsumerEndpointType.Returns(typeof(TestConsumerEndpoint));
broker.Consumers.Returns(new[] { consumer });
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddSilverback()
.Services
.AddSingleton <IBrokerCollection>(new BrokerCollection(new[] { broker }))
.AddHealthChecks()
.AddConsumersCheck());
var(healthCheck, context) = GetHealthCheck(serviceProvider);
var result = await healthCheck.CheckHealthAsync(context);
result.Status.Should().Be(HealthStatus.Healthy);
}
public async Task CheckHealthAsync_WithCustomGracePeriod_CorrectStatusReturned()
{
var statusInfo = Substitute.For <IConsumerStatusInfo>();
statusInfo.Status.Returns(ConsumerStatus.Connected);
var consumer = Substitute.For <IConsumer>();
consumer.StatusInfo.Returns(statusInfo);
consumer.StatusInfo.History.Returns(
new List <IConsumerStatusChange>
{
new ConsumerStatusChange(ConsumerStatus.Connected, DateTime.UtcNow.AddSeconds(-300)),
new ConsumerStatusChange(ConsumerStatus.Ready, DateTime.UtcNow.AddSeconds(-120)),
new ConsumerStatusChange(ConsumerStatus.Connected, DateTime.UtcNow.AddSeconds(-25))
});
var broker = Substitute.For <IBroker>();
broker.ProducerEndpointType.Returns(typeof(TestProducerEndpoint));
broker.ConsumerEndpointType.Returns(typeof(TestConsumerEndpoint));
broker.Consumers.Returns(new[] { consumer });
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddSilverback()
.Services
.AddSingleton <IBrokerCollection>(new BrokerCollection(new[] { broker }))
.AddHealthChecks()
.AddConsumersCheck(gracePeriod: TimeSpan.FromSeconds(5)));
var(healthCheck, context) = GetHealthCheck(serviceProvider);
var result = await healthCheck.CheckHealthAsync(context);
result.Status.Should().Be(HealthStatus.Unhealthy);
}
public async Task Publish_WithSortedBehaviors_BehaviorsExecutedInExpectedOrder()
{
var callsSequence = new List <string>();
var behavior1 = new TestSortedBehavior(100, callsSequence);
var behavior2 = new TestSortedBehavior(50, callsSequence);
var behavior3 = new TestSortedBehavior(-50, callsSequence);
var behavior4 = new TestSortedBehavior(-100, callsSequence);
var behavior5 = new TestBehavior(callsSequence);
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddSingletonBehavior(behavior1)
.AddScopedBehavior(_ => behavior2)
.AddTransientBehavior(_ => behavior3)
.AddSingletonBehavior(behavior4)
.AddSingletonBehavior(behavior5));
var publisher = serviceProvider.GetRequiredService <IPublisher>();
publisher.Publish(new TestCommandOne());
await publisher.PublishAsync(new TestCommandOne());
callsSequence.Should().BeEquivalentTo(
new[]
{
"-100", "-50", "unsorted", "50", "100",
"-100", "-50", "unsorted", "50", "100"
},
options => options.WithStrictOrdering());
}
public async Task Publish_EnvelopesWithFilter_FilteredEnvelopesAndMessagesReceived()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddScopedSubscriber <TestFilteredSubscriber>());
var publisher = serviceProvider.GetRequiredService <IPublisher>();
var filteredSubscriber = serviceProvider.GetRequiredService <TestFilteredSubscriber>();
publisher.Publish(new TestEnvelope(new TestEventOne {
Message = "yes"
}));
publisher.Publish(new TestEnvelope(new TestEventOne {
Message = "no"
}));
await publisher.PublishAsync(new TestEnvelope(new TestEventOne {
Message = "yes"
}));
await publisher.PublishAsync(new TestEnvelope(new TestEventOne {
Message = "no"
}));
filteredSubscriber.ReceivedEnvelopesCount.Should().Be(2);
filteredSubscriber.ReceivedMessagesCount.Should().Be(2);
}
public async Task AddOutbound_WithIdempotentRegistration_LogCriticalWhenConfigurationDiffers()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddLoggerSubstitute()
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>())
.AddEndpoints(
endpoints =>
endpoints
.AddOutbound <TestEventOne>(new TestProducerEndpoint("test1"))
.AddOutbound <TestEventOne>(
new TestProducerEndpoint("test1")
{
Chunk = new ChunkSettings {
AlwaysAddHeaders = true, Size = 200
}
})));
var broker = serviceProvider.GetRequiredService <TestBroker>();
var loggerSubstitute =
(LoggerSubstitute <EndpointsConfigurationBuilder>)serviceProvider
.GetRequiredService <ILogger <EndpointsConfigurationBuilder> >();
await broker.ConnectAsync();
loggerSubstitute.Received(
LogLevel.Critical,
typeof(EndpointConfigurationException),
null,
1102,
"An endpoint 'test1' for message type 'Silverback.Tests.Types.Domain.TestEventOne' but with a different configuration is already registered.");
}
public async Task AddOutbound_WithIdempotentRegistration_RegisterMultipleTimesWhenAllowed()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.AllowDuplicateEndpointRegistrations())
.AddEndpoints(
endpoints =>
endpoints
.AddOutbound <TestEventOne>(new TestProducerEndpoint("test1"))
.AddOutbound <TestEventOne>(new TestProducerEndpoint("test1"))));
var broker = serviceProvider.GetRequiredService <TestBroker>();
await broker.ConnectAsync();
var publisher = serviceProvider.GetRequiredService <IPublisher>();
await publisher.PublishAsync(new TestEventOne());
broker.ProducedMessages.Should().HaveCount(2);
}
ConnectAsyncAndDisconnectAsync_WithMultipleBrokers_AllBrokersConnectedAndDisconnected()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.AddBroker <TestOtherBroker>()));
var brokerCollection = serviceProvider.GetRequiredService <IBrokerCollection>();
brokerCollection[0].IsConnected.Should().BeFalse();
brokerCollection[1].IsConnected.Should().BeFalse();
await brokerCollection.ConnectAsync();
brokerCollection[0].IsConnected.Should().BeTrue();
brokerCollection[1].IsConnected.Should().BeTrue();
await brokerCollection.DisconnectAsync();
brokerCollection[0].IsConnected.Should().BeFalse();
brokerCollection[1].IsConnected.Should().BeFalse();
}
public async Task Publish_MultipleDelegateSubscribersReturnMessagesAsyncEnumerable_MessagesRepublished()
{
var republishedMessages = new List <object>();
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddDelegateSubscriber(
(TestEventTwo _) => new ICommand[]
{
new TestCommandOne(),
new TestCommandTwo(),
new TestCommandOne()
}.ToAsyncEnumerable())
.AddDelegateSubscriber(
(TestEventTwo _) => new List <ICommand>
{
new TestCommandOne(),
new TestCommandTwo(),
new TestCommandOne()
}.ToAsyncEnumerable())
.AddDelegateSubscriber((ICommand message) => republishedMessages.Add(message)));
var publisher = serviceProvider.GetRequiredService <IPublisher>();
publisher.Publish(new TestEventTwo());
await publisher.PublishAsync(new TestEventTwo());
republishedMessages.Should().HaveCount(12);
}
public async Task Publish_ToDelegateSubscriberWithAdditionalParameters_MessagesReceived()
{
int count = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddDelegateSubscriber <object>(
(_, forwardedServiceProvider) =>
{
if (forwardedServiceProvider != null)
{
count++;
}
}));
var publisher = serviceProvider.GetRequiredService <IPublisher>();
publisher.Publish(new TestCommandOne());
await publisher.PublishAsync(new TestCommandOne());
publisher.Publish(new TestCommandTwo());
await publisher.PublishAsync(new TestCommandTwo());
count.Should().Be(4);
}
public async Task StartAsync_ApplicationStopping_BrokerGracefullyDisconnectedRegardlessOfMode(
BrokerConnectionMode mode)
{
var appStoppingTokenSource = new CancellationTokenSource();
var lifetimeEvents = Substitute.For <IApplicationLifetime>();
lifetimeEvents.ApplicationStopping.Returns(appStoppingTokenSource.Token);
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddTransient(_ => lifetimeEvents)
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.WithConnectionOptions(
new BrokerConnectionOptions
{
Mode = mode
})));
var service = serviceProvider.GetServices <IHostedService>().OfType <BrokerConnectorService>().Single();
await service.StartAsync(CancellationToken.None);
var testBroker = serviceProvider.GetRequiredService <TestBroker>();
await testBroker.ConnectAsync();
testBroker.IsConnected.Should().BeTrue();
appStoppingTokenSource.Cancel();
testBroker.IsConnected.Should().BeFalse();
}
public async Task Publish_ToMultipleSubscribers_MessagesReceived()
{
int delegateCount = 0;
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.AddSingletonSubscriber <TestSubscriber>()
.AddDelegateSubscriber(
(object _) =>
{
delegateCount++;
return(Task.CompletedTask);
}));
var publisher = serviceProvider.GetRequiredService <IPublisher>();
var subscriber = serviceProvider.GetRequiredService <TestSubscriber>();
publisher.Publish(new TestCommandOne());
await publisher.PublishAsync(new TestCommandOne());
publisher.Publish(new TestCommandTwo());
await publisher.PublishAsync(new TestCommandTwo());
subscriber.ReceivedMessagesCount.Should().Be(4);
subscriber.ReceivedCallsCount.Should().Be(12);
delegateCount.Should().Be(4);
}
public async Task StartAsync_ExceptionWithRetryDisabled_ConnectNotRetried()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddTransient(_ => Substitute.For <IApplicationLifetime>())
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.WithConnectionOptions(
new BrokerConnectionOptions
{
Mode = BrokerConnectionMode.Startup,
RetryOnFailure = false
})));
var testBroker = serviceProvider.GetRequiredService <TestBroker>();
testBroker.SimulateConnectIssues = true;
var service = serviceProvider.GetServices <IHostedService>().OfType <BrokerConnectorService>().Single();
await service.StartAsync(CancellationToken.None);
testBroker.IsConnected.Should().BeFalse();
}
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_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_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 AddInbound_WithMultipleBrokers_ConsumersCorrectlyConnected()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.AddBroker <TestOtherBroker>())
.AddEndpoints(
endpoints =>
endpoints
.AddInbound(new TestConsumerEndpoint("test1"))
.AddInbound(new TestOtherConsumerEndpoint("test2"))));
var broker = serviceProvider.GetRequiredService <TestBroker>();
await broker.ConnectAsync();
var otherBroker = serviceProvider.GetRequiredService <TestOtherBroker>();
await otherBroker.ConnectAsync();
broker.Consumers.Should().HaveCount(1);
otherBroker.Consumers.Should().HaveCount(1);
}
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 static IPublisher GetPublisher(Action <ISilverbackBuilder> buildAction)
{
return(ServiceProviderHelper.GetServiceProvider(
services =>
{
var builder = services.AddSilverback().AsObservable();
buildAction(builder);
}).GetRequiredService <IPublisher>());
}
public KafkaBrokerTests()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddSilverback()
.WithConnectionToMessageBroker(options => options.AddKafka()));
_broker = serviceProvider.GetRequiredService <KafkaBroker>();
}
public RabbitBrokerTests()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.WithConnectionToMessageBroker(options => options.AddRabbit()));
_broker = serviceProvider.GetRequiredService <RabbitBroker>();
}
public QueryPublisherTests()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.UseModel()
.AddDelegateSubscriber((TestQuery _) => new[] { 1, 2, 3 }));
_publisher = serviceProvider.CreateScope().ServiceProvider.GetRequiredService <IQueryPublisher>();
}
public EventPublisherTests()
{
var serviceProvider = ServiceProviderHelper.GetServiceProvider(
services => services
.AddFakeLogger()
.AddSilverback()
.UseModel()
.AddDelegateSubscriber((TestEvent _) => _receivedMessages++));
_publisher = serviceProvider.CreateScope().ServiceProvider.GetRequiredService <IEventPublisher>();
}