public async Task Subscriber_ProcessTheMessageTheSecondTime_MessageMustBeRemovedFromTheRabbitMq() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Subscriber_ProcessTheMessageTheSecondTime_MessageMustBeRemovedFromTheRabbitMq.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); configuration["rabbitmq:retryfactor"] = 100.ToString(); var maxretrycount = 2; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //create Subscriber var bookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); ISubscriber typedSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("Subscriber_ProcessTheMessageTheSecondTime_MessageMustBeRemovedFromTheRabbitMq" + ".typedbookingcreatedconsumer", new List <string> { "*.entity.create.booking" }, maxretrycount); BookingTypedConsumer typedConsumer = new BookingTypedConsumer(1); typedSubscriber.Subscribe(SubscriptionBuilder.Create().AddDefaultSubscription(() => typedConsumer).Build()); //create Publisher var publisher = container.Resolve <IPublisher>(); string routingKey = "changetracker.entity.create.booking"; //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated" }; await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, routingKey); await Task.Delay(500); //check typedConsumer.ProcessedIntegrationEvent.ShouldBeEquivalentTo(bookingCreatedIntegrationEvent); typedConsumer.CountOfAttempts.Should().Be(2); container.Dispose(); }
public async Task Publisher_PublishDirectEventAsync_MessageMustBeSerializedAndCorrectlyRoutedToSpecificSubscriber() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Publisher_PublishDirectEventAsync_MessageMustBeSerializedAndCorrectlyRoutedToSpecificSubscriber.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); var maxretrycount = 2; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //create Subscriber var bookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); string subscriberName = "Publisher_PublishDirectEventAsync_MessageMustBeSerializedAndCorrectlyRoutedToSpecificSubscriber.typedbookingcreatedconsumer"; ISubscriber typedSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync(subscriberName, (List <string>) null, maxretrycount); BookingTypedConsumer typedConsumer = new BookingTypedConsumer(0); typedSubscriber.Subscribe(SubscriptionBuilder.Create().AddDefaultSubscription(() => typedConsumer).Build()); //create Publisher var publisher = container.Resolve <IPublisher>(); //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated" }; await publisher.PublishDirectEventAsync(bookingCreatedIntegrationEvent, subscriberName); await Task.Delay(200); //check typedConsumer.ProcessedIntegrationEvent.ShouldBeEquivalentTo(bookingCreatedIntegrationEvent); typedConsumer.CountOfAttempts.Should().Be(1); container.Dispose(); }
public async Task Publisher_Publish_MessageMustBeSerializedAndCorrectlyRouted() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Publisher_Publish_MessageMustBeSerializedAndCorrectlyRouted.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); var publisher = container.Resolve <IPublisher>(); string routingKey = "changetracker.entity.create.booking"; var bus = container.Resolve <IAdvancedBus>(); IExchange exchange = bus.ExchangeDeclare(exchangeName, ExchangeType.Topic); var queue = bus.QueueDeclare("Publisher_Publish_MessageMustBeSentAndCorrectlyRouted.subscriberqueue"); var binding = bus.Bind(exchange, queue, "changetracker.entity.create.booking"); //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated" }; await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, routingKey); await Task.Delay(300); //check IBasicGetResult result = bus.Get(queue); var message = Encoding.UTF8.GetString(result.Body); IntegrationEvent <BookingCreated> eventToCheck = JsonConvert.DeserializeObject <IntegrationEvent <BookingCreated> >(message); eventToCheck.ShouldBeEquivalentTo(bookingCreatedIntegrationEvent); container.Dispose(); }
public async Task Subscriber_2DifferentSubscribersWithEqualPrefetchCount_SubscribersShouldProcessEventsInParallelWithEqualSpeed() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Subscriber_2DifferentSubscribersWithEqualPrefetchCount_SubscribersShouldProcessEventsInParallelWithEqualSpeed.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); var maxretrycount = 2; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //create Subscriber var bookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); ISubscriber fastSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("Subscriber_2DifferentSubscribersWithEqualPrefetchCount_SubscribersShouldProcessEventsInParallelWithEqualSpeed" + ".first", new List <string> { "*.entity.create.booking", }, maxretrycount, 1); ISubscriber slowSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("Subscriber_2DifferentSubscribersWithEqualPrefetchCount_SubscribersShouldProcessEventsInParallelWithEqualSpeed" + ".second", new List <string> { "*.entity.create.booking", }, maxretrycount, 1); var firstBookingTypedSubscriberConsumer = new BookingTypedParallellismCounterConsumer(3000); var secondBookingTypedSubscriberConsumer = new BookingTypedParallellismCounterConsumer(3000); fastSubscriber.Subscribe(SubscriptionBuilder.Create() .AddSubscription("bookingcreated", () => firstBookingTypedSubscriberConsumer) .Build()); slowSubscriber.Subscribe(SubscriptionBuilder.Create() .AddSubscription("bookingcreated", () => secondBookingTypedSubscriberConsumer) .Build()); //create Publisher var publisher = container.Resolve <IPublisher>(); string bookingRoutingKey = "changetracker.entity.create.booking"; //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated" }; for (int i = 1; i <= 8; i++) { await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, bookingRoutingKey); } //wait 30 seconds await Task.Delay(30000); //check firstBookingTypedSubscriberConsumer.MaxParrelelEvents.Should().Be(1); firstBookingTypedSubscriberConsumer.CountOfProcessedEvents.Should().Be(8); secondBookingTypedSubscriberConsumer.MaxParrelelEvents.Should().Be(1); secondBookingTypedSubscriberConsumer.CountOfProcessedEvents.Should().Be(8); container.Dispose(); }
public async Task Subscriber_ProcessThe2MessageTheFirstTimeWith2DifferentRoutingKeys_MessagesMustBeRemovedFromTheRabbitMq() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Subscriber_ProcessTheMessageTheFirstTime_MessageMustBeRemovedFromTheRabbitMq.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); var maxretrycount = 2; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //create Subscriber var bookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); ISubscriber typedSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("Subscriber_ProcessTheMessageTheFirstTime_MessageMustBeRemovedFromTheRabbitMq" + ".typedbookingcreatedconsumer", new List <string> { "*.entity.create.booking", "*.entity.create.account" }, maxretrycount); BookingTypedConsumer bookingTypedConsumer = new BookingTypedConsumer(0); AccountTypedConsumer accountTypedConsumer = new AccountTypedConsumer(0); typedSubscriber.Subscribe(SubscriptionBuilder.Create() .AddSubscription("bookingcreated", () => bookingTypedConsumer) .AddSubscription("accountcreated", () => accountTypedConsumer).Build()); //create Publisher var publisher = container.Resolve <IPublisher>(); string bookingRoutingKey = "changetracker.entity.create.booking"; string accountRoutingKey = "changetracker.entity.create.account"; //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; AccountCreated accountCreated = new AccountCreated() { AccountLevel = 100 }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated" }; var accountCreatedIntegrationEvent = new IntegrationEvent <AccountCreated>() { Content = accountCreated, EventType = "accountcreated" }; await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, bookingRoutingKey); await publisher.PublishEventAsync(accountCreatedIntegrationEvent, accountRoutingKey); await Task.Delay(200); //check bookingTypedConsumer.ProcessedIntegrationEvent.ShouldBeEquivalentTo(bookingCreatedIntegrationEvent); bookingTypedConsumer.CountOfAttempts.Should().Be(1); accountTypedConsumer.ProcessedIntegrationEvent.ShouldBeEquivalentTo(accountCreatedIntegrationEvent); accountTypedConsumer.CountOfAttempts.Should().Be(1); container.Dispose(); }
public async Task Subscriber_DiscardException_MessageMustBeMovedToGlobalDeadLetterQueue() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Subscriber_DiscardException_MessageMustBeMovedToGlobalDeadLetterQueue.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); var maxretrycount = 2; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //create Subscriber var bookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); ISubscriber typedSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("Subscriber_DiscardException_MessageMustBeMovedToGlobalDeadLetterQueue" + ".typedbookingcreatedconsumer", new List <string> { "*.entity.create.booking" }, maxretrycount); DiscardConsumer discardConsumer = new DiscardConsumer(); typedSubscriber.Subscribe(SubscriptionBuilder.Create().AddDefaultSubscription(() => discardConsumer).Build()); //create Publisher var publisher = container.Resolve <IPublisher>(); string routingKey = "changetracker.entity.create.booking"; //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated", CorrelationId = Guid.NewGuid() }; await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, routingKey); await Task.Delay(3000); //check var bus = container.Resolve <IAdvancedBus>(); var deadleterqueue = bus.QueueDeclare($"{exchangeName}.defaultTombQueue"); IBasicGetResult result = bus.Get(deadleterqueue); var message = Encoding.UTF8.GetString(result.Body); JObject errorEvent = JObject.Parse(message); errorEvent["RoutingKey"].Value <string>().Should().Be("changetracker.entity.create.booking"); errorEvent["Exchange"] .Value <string>().Should().Be("Subscriber_DiscardException_MessageMustBeMovedToGlobalDeadLetterQueue.exchangename"); errorEvent["Queue"] .Value <string>().Should().Be($"{exchangeName}.Subscriber_DiscardException_MessageMustBeMovedToGlobalDeadLetterQueue.typedbookingcreatedconsumer"); //check bindings var managementClient = new ManagementClient(configuration["rabbitmqmanagement:hostUrl"], configuration["rabbitmqmanagement:username"], configuration["rabbitmqmanagement:password"], configuration.GetValue <int>("rabbitmqmanagement:portNumber")); var virtualHostName = new ConnectionStringParser().Parse(configuration["rabbitmq:connectionstring"]).VirtualHost; var virtualhost = await managementClient.GetVhostAsync(virtualHostName); var deadleterq = await managementClient.GetQueueAsync(deadleterqueue.Name, virtualhost); var deadleterqbindings = (await managementClient.GetBindingsForQueueAsync(deadleterq)).ToList(); deadleterqbindings.Should().HaveCount(2);//one is default deadleterqbindings.Where(x => x.Source == $"{exchangeName}_error" && x.RoutingKey == routingKey).Should().HaveCount(1); container.Dispose(); }
public async Task Subscriber_ExceededCountOfAttempts_MessageMustBeMovedToSpecificDeadLetterQueue() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Subscriber_ExceededCountOfAttempts_MessageMustBeMovedToDeadLetterQueue.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); configuration["rabbitmq:retryfactor"] = 100.ToString(); var maxretrycount = 2; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //create Subscriber var bookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); ISubscriber typedSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("Subscriber_ExceededCountOfAttempts_MessageMustBeMovedToDeadLetterQueue" + ".typedbookingcreatedconsumer", new List <string> { "*.entity.create.booking" }, maxretrycount); BookingTypedConsumer typedConsumer = new BookingTypedConsumer(3); IntegrationEvent <BookingCreated> actualDeadLetterCallbackIntegrationEvent = null; Exception actualDeadLetterCallbackException = null; typedSubscriber.Subscribe(SubscriptionBuilder.Create().AddDefaultSubscription(() => typedConsumer, (integrationEvent, exception) => { actualDeadLetterCallbackIntegrationEvent = integrationEvent; actualDeadLetterCallbackException = exception; return(Task.CompletedTask); }).Build()); //create Publisher var publisher = container.Resolve <IPublisher>(); string routingKey = "changetracker.entity.create.booking"; //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated", CorrelationId = Guid.NewGuid() }; await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, routingKey); //wait 1 second await Task.Delay(1000); //check var bus = container.Resolve <IAdvancedBus>(); var deadleterqueue = bus.QueueDeclare($"{exchangeName}.deadletter" + ".Subscriber_ExceededCountOfAttempts_MessageMustBeMovedToDeadLetterQueue." + "typedbookingcreatedconsumer"); IBasicGetResult result = bus.Get(deadleterqueue); var message = Encoding.UTF8.GetString(result.Body); var actualDeadLetterQueueIntergrationEvent = JsonConvert. DeserializeObject <IntegrationEvent <DeadLetterEventDescriptor <BookingCreated> > >(message); result.Info.RoutingKey.Should().Be("deadletter" + ".Subscriber_ExceededCountOfAttempts_MessageMustBeMovedToDeadLetterQueue" + ".typedbookingcreatedconsumer"); actualDeadLetterQueueIntergrationEvent.Content.Original .ShouldBeEquivalentTo(bookingCreatedIntegrationEvent); actualDeadLetterQueueIntergrationEvent.CorrelationId .ShouldBeEquivalentTo(bookingCreatedIntegrationEvent.CorrelationId); actualDeadLetterQueueIntergrationEvent.EventType.Should() .BeEquivalentTo(string.Concat("deadletter.", bookingCreatedIntegrationEvent.EventType)); actualDeadLetterCallbackException.Message.Should().Be("ExceptionHasBeenThrown"); actualDeadLetterCallbackException.Should().BeOfType <Exception>(); actualDeadLetterCallbackIntegrationEvent.ShouldBeEquivalentTo(bookingCreatedIntegrationEvent); typedConsumer.ProcessedIntegrationEvent.Should().BeNull(); typedConsumer.CountOfAttempts.Should().Be(3); container.Dispose(); }
public async Task Subscribe_DeadLetterMessageIsSentToDeadLetter_DeadLetterIsReadBySubscriber() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "Subscribe_DeadLetterMessageIsSentToDeadLetter_DeadLetterIsReadBySubscriber.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //Let's create AccountBookingTypedConsumer Subscriber var maxretrycount = 0; var accountcreatedbindingkey = "*.entity.create.account"; var bookingcreatedbindingkey = "*.entity.create.booking"; var accountBookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); var accountBookingTypedConsumerSubscriberName = "Subscribe_DeadLetterMessagesAreSentToDeadLetter_DeadLettersAreReadByAppropriateConsumers"; ISubscriber typedSubscriber = await accountBookingCreatedSubscriberFactory .CreateSubscriberAsync(accountBookingTypedConsumerSubscriberName , new List <string> { accountcreatedbindingkey, bookingcreatedbindingkey }, maxretrycount); var accountCreatedEventType = "accountcreated"; var bookingCreatedEventType = "bookingcreated"; AccountBookingTypedConsumer typedConsumer = new AccountBookingTypedConsumer(10, 10); typedSubscriber.Subscribe(SubscriptionBuilder.Create() .AddSubscription <AccountCreated>(accountCreatedEventType, () => typedConsumer) .AddDefaultSubscription <BookingCreated>(() => typedConsumer).Build()); //Let's create AccountBookingTypedConsumer dead letter queue Subscriber var deadLetterSubscriberFactory = container.Resolve <IDeadLetterSubscriberFactory>(); DeadLetterConsumer deadLetterConsumer = new DeadLetterConsumer(0, 0); ISubscriber deadLetterSubscriber = await deadLetterSubscriberFactory.CreateSubscriberAsync(accountBookingTypedConsumerSubscriberName, 1); deadLetterSubscriber.Subscribe(SubscriptionBuilder.Create() .AddSubscription <DeadLetterEventDescriptor <BookingCreated> >(bookingCreatedEventType, () => deadLetterConsumer) .AddDefaultSubscription <DeadLetterEventDescriptor <AccountCreated> >(() => deadLetterConsumer).Build()); //create Publisher var publisher = container.Resolve <IPublisher>(); string accountcreatedroutingKey = "changetracker.entity.create.account"; string bookingcreatedroutingKey = "changetracker.entity.create.booking"; //act AccountCreated accountCreated = new AccountCreated() { AccountLevel = 10 }; var accountCreatedIntegrationEvent = new IntegrationEvent <AccountCreated>() { Content = accountCreated, EventType = accountCreatedEventType, CorrelationId = Guid.NewGuid() }; await publisher.PublishEventAsync(accountCreatedIntegrationEvent, accountcreatedroutingKey); BookingCreated bookingCreated = new BookingCreated() { BookingName = "bookingName" }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = bookingCreatedEventType, CorrelationId = Guid.NewGuid() }; await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, bookingcreatedroutingKey); //The event must be sent to the deadletter queue. await Task.Delay(500); //Let's check that dead letter consumer got the message. IntegrationEvent <DeadLetterEventDescriptor <AccountCreated> > deadLetterAccountCreatedMessage = deadLetterConsumer.ProcessedAccountCreatedIntegrationEvents.First(); deadLetterConsumer.ProcessedAccountCreatedIntegrationEvents.Count().Should().Be(1); deadLetterAccountCreatedMessage.CorrelationId.Should().Be(accountCreatedIntegrationEvent.CorrelationId); deadLetterAccountCreatedMessage.Content.Original.ShouldBeEquivalentTo(accountCreatedIntegrationEvent); IntegrationEvent <DeadLetterEventDescriptor <BookingCreated> > deadLetterBookingCreatedMessage = deadLetterConsumer.ProcessedBookingCreatedIntegrationEvents.First(); deadLetterConsumer.ProcessedBookingCreatedIntegrationEvents.Count().Should().Be(1); deadLetterBookingCreatedMessage.CorrelationId.Should().Be(bookingCreatedIntegrationEvent.CorrelationId); deadLetterBookingCreatedMessage.Content.Original.ShouldBeEquivalentTo(bookingCreatedIntegrationEvent); }
public async Task QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned() { //prepare IConfiguration configuration = ConfigurationHelper.ProvideConfiguration(); var exchangeName = "QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned.exchangename"; configuration["rabbitmq:exchangename"] = exchangeName; configuration["rabbitmq:waitexchangename"] = exchangeName.Replace("exchangename", "waitexchangename"); var maxretrycount = 2; IContainer container = ConfigurationHelper.ConfigureContainer(configuration); //create Subscriber var bookingCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>(); ISubscriber fastSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned" + ".fast", new List <string> { "*.entity.create.booking", }, maxretrycount, 5); ISubscriber slowSubscriber = await bookingCreatedSubscriberFactory .CreateSubscriberAsync("QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned" + ".slow", new List <string> { "*.entity.create.booking", }, maxretrycount, 1); //create Publisher var publisher = container.Resolve <IPublisher>(); string bookingRoutingKey = "changetracker.entity.create.booking"; //act BookingCreated bookingCreated = new BookingCreated() { BookingName = string.Concat("Microsoft Sale", Guid.NewGuid().ToString()) }; var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>() { Content = bookingCreated, EventType = "bookingcreated" }; for (int i = 1; i <= 8; i++) { await publisher.PublishEventAsync(bookingCreatedIntegrationEvent, bookingRoutingKey); } //wait 1 second await Task.Delay(1000); //ckeck the GetQueueInfo method first call var queueInfoProvider = container.Resolve <IQueueInfoProvider>(); var fastSubscriberQueueSnapshotInfo = queueInfoProvider.GetQueueInfo( "QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned.fast"); fastSubscriberQueueSnapshotInfo.CountOfMessages.Should().Be(8); var slowSubscriberQueueSnapshotInfo = queueInfoProvider.GetQueueInfo( "QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned.slow"); slowSubscriberQueueSnapshotInfo.CountOfMessages.Should().Be(8); //Let's create Subscriber var fastBookingTypedSubscriberConsumer = new BookingTypedParallellismCounterConsumer(500); var slowBookingTypedSubscriberConsumer = new BookingTypedParallellismCounterConsumer(500); fastSubscriber.Subscribe(SubscriptionBuilder.Create() .AddSubscription("bookingcreated", () => fastBookingTypedSubscriberConsumer) .Build()); slowSubscriber.Subscribe(SubscriptionBuilder.Create() .AddSubscription("bookingcreated", () => slowBookingTypedSubscriberConsumer) .Build()); //wait 10 seconds await Task.Delay(10000); //check //ckeck the GetQueueInfo method second call fastSubscriberQueueSnapshotInfo = queueInfoProvider.GetQueueInfo( "QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned.fast"); fastSubscriberQueueSnapshotInfo.CountOfMessages.Should().Be(0); slowSubscriberQueueSnapshotInfo = queueInfoProvider.GetQueueInfo( "QueueInfoProvider_GetQueueInfo_CorrectCountOfReadyMessagesMustBeReturned.slow"); slowSubscriberQueueSnapshotInfo.CountOfMessages.Should().Be(0); container.Dispose(); }