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 Subscribe_DeadLetterIsSibscribedThenDisposed_DeadLetterMessagesAreDeliveredCorrectlyToSecondSubscriber()
{
//prepare
IConfiguration configuration = ConfigurationHelper.ProvideConfiguration();
var exchangeName =
"Subscribe_DeadLetterIsSibscribedThenUnsibcribed_DeadLetterMessagesAreDeliveredCorrectly.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 accountCreatedSubscriberFactory = container.Resolve <ISubscriberFactory>();
var accountTypedConsumerSubscriberName = "Subscribe_DeadLetterIsSibscribedThenUnsibcribed_DeadLetterMessagesAreDeliveredCorrectly";
ISubscriber typedSubscriber =
await accountCreatedSubscriberFactory
.CreateSubscriberAsync(accountTypedConsumerSubscriberName
, new List <string> {
accountcreatedbindingkey
}, maxretrycount);
var accountCreatedEventType = "accountcreated";
AccountBookingTypedConsumer typedConsumer = new AccountBookingTypedConsumer(10, 0);
typedSubscriber.Subscribe(SubscriptionBuilder.Create()
.AddSubscription <AccountCreated>(accountCreatedEventType, () => typedConsumer).Build());
//Let's create AccountTypedConsumer for dead letter queue Subscriber
var deadLetterSubscriberFactory = container.Resolve <IDeadLetterSubscriberFactory>();
DeadLetterConsumer deadLetterConsumer = new DeadLetterConsumer(0, 0);
ISubscriber deadLetterSubscriber =
await deadLetterSubscriberFactory.CreateSubscriberAsync(accountTypedConsumerSubscriberName, 1);
deadLetterSubscriber.Subscribe(SubscriptionBuilder.Create()
.AddDefaultSubscription <DeadLetterEventDescriptor <AccountCreated> >(() => deadLetterConsumer).Build());
//create Publisher
var publisher = container.Resolve <IPublisher>();
string accountcreatedroutingKey = "changetracker.entity.create.account";
//act
AccountCreated accountCreated =
new AccountCreated()
{
AccountLevel = 10
};
var accountCreatedIntegrationEvent = new IntegrationEvent <AccountCreated>()
{
Content = accountCreated,
EventType = accountCreatedEventType,
CorrelationId = Guid.NewGuid()
};
await publisher.PublishEventAsync(accountCreatedIntegrationEvent, accountcreatedroutingKey);
//The event must be sent to the deadletter queue.
await Task.Delay(1000);
//Let's check that dead letter consumer processed the message with Type = AccountCreated on the first try.
IntegrationEvent <DeadLetterEventDescriptor <AccountCreated> > deadLetterAccountCreatedMessage = deadLetterConsumer.ProcessedAccountCreatedIntegrationEvents.First();
deadLetterConsumer.ProcessedAccountCreatedIntegrationEvents.Count().Should().Be(1);
deadLetterAccountCreatedMessage.CorrelationId.Should().Be(accountCreatedIntegrationEvent.CorrelationId);
deadLetterAccountCreatedMessage.Content.Original.ShouldBeEquivalentTo(accountCreatedIntegrationEvent);
deadLetterConsumer.CountOfAttemptsForAccountCreated.Should().Be(1);
//Let's dispose
deadLetterSubscriber.Dispose();
//Let's publish the new message that must be sent to the dead letter queue
AccountCreated uptickAccountCreated =
new AccountCreated()
{
AccountLevel = 20
};
var uptickAccountCreatedIntegrationEvent = new IntegrationEvent <AccountCreated>()
{
Content = uptickAccountCreated,
EventType = accountCreatedEventType,
CorrelationId = Guid.NewGuid()
};
await publisher.PublishEventAsync(uptickAccountCreatedIntegrationEvent, accountcreatedroutingKey);
//Let's create the new Dead Letter queue Subscriber
DeadLetterConsumer secondDeadLetterConsumer = new DeadLetterConsumer(0, 0);
ISubscriber secondDeadLetterSubscriber =
await deadLetterSubscriberFactory.CreateSubscriberAsync(accountTypedConsumerSubscriberName, 1);
secondDeadLetterSubscriber.Subscribe(SubscriptionBuilder.Create()
.AddDefaultSubscription <DeadLetterEventDescriptor <AccountCreated> >(() => secondDeadLetterConsumer).Build());
await Task.Delay(1000);
//check that the second dead letter qeuee message was sent to the new second consumer. The first should not have recieved new message.
deadLetterConsumer.ProcessedAccountCreatedIntegrationEvents.Count().Should().Be(1);
deadLetterAccountCreatedMessage.CorrelationId.Should().Be(accountCreatedIntegrationEvent.CorrelationId);
deadLetterAccountCreatedMessage.Content.Original.ShouldBeEquivalentTo(accountCreatedIntegrationEvent);
deadLetterConsumer.CountOfAttemptsForAccountCreated.Should().Be(1);
IntegrationEvent <DeadLetterEventDescriptor <AccountCreated> > uptickAccountDeadLetterAccountCreatedMessage = secondDeadLetterConsumer.ProcessedAccountCreatedIntegrationEvents.First();
secondDeadLetterConsumer.ProcessedAccountCreatedIntegrationEvents.Count().Should().Be(1);
uptickAccountDeadLetterAccountCreatedMessage.CorrelationId.Should().Be(uptickAccountCreatedIntegrationEvent.CorrelationId);
uptickAccountDeadLetterAccountCreatedMessage.Content.Original.ShouldBeEquivalentTo(uptickAccountCreatedIntegrationEvent);
secondDeadLetterConsumer.CountOfAttemptsForAccountCreated.Should().Be(1);
}
public async Task Subscribe_DeadLetterMessageIsSentToDeadLetter_DeadLetterIsReadByDeadLetterReloaderAndSentToTheOriginalQueue()
{
//prepare
IConfiguration configuration = ConfigurationHelper.ProvideConfiguration();
var exchangeName =
"Subscribe_DeadLetterMessageIsSentToDeadLetter_DeadLetterIsReadByDeadLetterReloaderAndSentToTheOriginalQueue.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_DeadLetterMessageIsSentToDeadLetter_DeadLetterIsReadByDeadLetterReloaderAndSentToTheOriginalQueue";
ISubscriber typedSubscriber =
await accountBookingCreatedSubscriberFactory
.CreateSubscriberAsync(accountBookingTypedConsumerSubscriberName
, new List <string> {
accountcreatedbindingkey, bookingcreatedbindingkey
}, maxretrycount);
var accountCreatedEventType = "accountcreated";
var bookingCreatedEventType = "bookingcreated";
AccountBookingTypedConsumer typedConsumer = new AccountBookingTypedConsumer(1, 1);
typedSubscriber.Subscribe(SubscriptionBuilder.Create()
.AddSubscription <AccountCreated>(accountCreatedEventType,
() => typedConsumer)
.AddDefaultSubscription <BookingCreated>(() => typedConsumer).Build());
//create Publisher
var publisher = container.Resolve <IPublisher>();
string accountcreatedroutingKey = "changetracker.entity.create.account";
string bookingcreatedroutingKey = "changetracker.entity.create.booking";
//Let's create AccountBookingTypedConsumer dead letter queue Subscriber and use DeadLetterReloader
var deadLetterSubscriberFactory = container.Resolve <IDeadLetterSubscriberFactory>();
DeadLetterReloader <AccountCreated> deadLetterreloader = new DeadLetterReloader <AccountCreated>(publisher, accountBookingTypedConsumerSubscriberName);
ISubscriber deadLetterSubscriber =
await deadLetterSubscriberFactory.CreateSubscriberAsync(accountBookingTypedConsumerSubscriberName, 1);
deadLetterSubscriber.Subscribe(SubscriptionBuilder.Create()
.AddDefaultSubscription(() => deadLetterreloader).Build());
//act
AccountCreated accountCreated =
new AccountCreated()
{
AccountLevel = 10
};
var accountCreatedIntegrationEvent = new IntegrationEvent <AccountCreated>()
{
Content = accountCreated,
EventType = accountCreatedEventType,
CorrelationId = Guid.NewGuid()
};
await publisher.PublishEventAsync(accountCreatedIntegrationEvent, accountcreatedroutingKey);
//The event must be sent to the deadletter queue.
await Task.Delay(2000);
//Let's check that dead letter reloader processed the message with Type = AccountCreated and sent it to the original queue.
//AccountBookingTypedConsumer should process the original message at the second attempt.
IntegrationEvent <AccountCreated> accountCreatedMessage =
typedConsumer.ProcessedAccountCreatedIntegrationEvent;
accountCreatedMessage.CorrelationId.Should().Be(accountCreatedIntegrationEvent.CorrelationId);
accountCreatedMessage.Content.ShouldBeEquivalentTo(accountCreatedIntegrationEvent.Content);
typedConsumer.CountOfAttemptsForAccountCreated.Should().Be(2);
typedConsumer.CountOfAttemptsForBookingCreated.Should().Be(0);
}
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);
}
