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();
}
