public async void RabbitModelConsumerWithConcurrencyControlTest()
{
// Arrange
byte[] messageBody1 = { 0xBE, 0xBE };
byte[] messageBody2 = { 0xBA, 0xBA };
var modelMock = new Mock <IModel>();
IBasicConsumer mockConsumer = null;
modelMock.Setup(m => m.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(),
It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <EventingBasicConsumer>()))
.Returns("consumerTag")
.Callback <string, bool, string, bool, bool, IDictionary <string, object>, IBasicConsumer>(
(queue, autoAck, consumerTag, noLocal, exclusive, arguments, consumer) =>
{
mockConsumer = consumer;
});
var messageConsumerActorRef = CreateTestProbe("MessageConsumer");
var requestModelConsumer = Mock.Of <IRequestModelConsumerWithConcurrencyControl>(rmc => rmc.MessageConsumer == messageConsumerActorRef &&
rmc.ConcurrencyLevel == 1);
var rabbitModelConsumer = Sys.ActorOf(RabbitModelConsumerWithConcurrencyControl.CreateProps(modelMock.Object, requestModelConsumer));
// Act
var started = await rabbitModelConsumer.Ask <bool>("start");
EventingBasicConsumer x = (EventingBasicConsumer)mockConsumer;
// Send two messages
x.HandleBasicDeliver("", 1, false, "", "", null, messageBody1);
x.HandleBasicDeliver("", 1, false, "", "", null, messageBody1);
// Assert
Assert.IsTrue(started);
// Receive only the first message as concurrency is set to 1
messageConsumerActorRef.ExpectMsg <IConsumedMessage>(
consumedMessage => consumedMessage.Message == messageBody1);
Assert.IsFalse(messageConsumerActorRef.HasMessages);
// Acknowledge message processed
messageConsumerActorRef.Send(rabbitModelConsumer, Mock.Of <IMessageProcessed>());
x.HandleBasicDeliver("", 1, false, "", "", null, messageBody2);
messageConsumerActorRef.ExpectMsg <IConsumedMessage>(
consumedMessage => consumedMessage.Message == messageBody2);
}
public void StartHandlingMessages_CallsCallbackOnReceivingMessages()
{
var target = new RabbitMQMessageReceiver(_busContext, _queueName, _topicFilters);
target.StartReceivingMessages();
bool hasBeenCalled = false;
target.StartHandlingMessages(em => { hasBeenCalled = true; });
// Act
_consumer.HandleBasicDeliver("ctag", 5, false, _exchangeName, _topic, _propMock.Object, _body);
Assert.AreEqual(true, hasBeenCalled);
}
public async void RabbitModelConsumerTest()
{
// Arrange
byte[] messageBody = { 0xBE, 0xBE };
var modelMock = new Mock <IModel>();
IBasicConsumer mockConsumer = null;
modelMock.Setup(m => m.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(),
It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <EventingBasicConsumer>()))
.Returns("consumerTag")
.Callback <string, bool, string, bool, bool, IDictionary <string, object>, IBasicConsumer>(
(queue, autoAck, consumerTag, noLocal, exclusive, arguments, consumer) =>
{
mockConsumer = consumer;
});
var messageConsumerActorRef = CreateTestProbe("MessageConsumer");
var requestModelConsumer = Mock.Of <IRequestModelConsumer>(rmc => rmc.MessageConsumer == messageConsumerActorRef);
var rabbitModelConsumer = Sys.ActorOf(RabbitModelConsumer.CreateProps(modelMock.Object, requestModelConsumer));
// Act
var started = await rabbitModelConsumer.Ask <bool>("start");
EventingBasicConsumer x = (EventingBasicConsumer)mockConsumer;
x.HandleBasicDeliver("", 1, false, "", "", null, messageBody);
// Assert
Assert.IsTrue(started);
messageConsumerActorRef.ExpectMsg <IConsumedMessage>(
consumedMessage => consumedMessage.Message == messageBody);
}
public void Run_ProcessorExists_ShouldRunAndListenMessages()
{
ResetCalls();
var message = "{ 'email' : '*****@*****.**', 'name': 'test' }";
var queueName1 = string.Empty;
bool?durable = null;
bool?exclusive = null;
bool?autoDelete = null;
bool?exchangeDurable = null;
bool?exchangeAutoDelete = null;
var exchange = string.Empty;
var body = Encoding.UTF8.GetBytes(message);
var type = MessageType.CreateClient;
var queueName = $"{Guid.NewGuid()}_queue";
var exchangeName = "exchange name";
var processedMessage = string.Empty;
var consumer = new EventingBasicConsumer(Model.Object);
ConsumerFactory.Setup(x => x.CreateEventConsumer(Model.Object)).Returns(consumer);
Model.Setup(x => x.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()))
.Callback <string, bool, bool, bool, IDictionary <string, object> >((queueParam, durableParam, exclusiveParam, autoDeleteParam, param) =>
{
queueName1 = queueParam;
durable = durableParam;
exclusive = exclusiveParam;
autoDelete = autoDeleteParam;
});
Model.Setup(x => x.ExchangeDeclare(exchangeName, ExchangeType.Direct, true, false, null))
.Callback <string, string, bool, bool, IDictionary <string, object> >((exchangeParam, directParam, durableParam, autoDeleteParam, param) =>
{
exchange = exchangeParam;
exchangeDurable = durableParam;
exchangeAutoDelete = autoDeleteParam;
});
Model.Setup(x => x.QueueBind(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), null));
Connection.Setup(x => x.CreateModel()).Returns(Model.Object);
ConnectionFactory.Setup(x => x.CreateConnection()).Returns(Connection.Object);
MessageProcessor1.Setup(x => x.Type).Returns(MessageType.CreateClient);
MessageProcessor1.Setup(x => x.Process(It.IsAny <string>())).Callback <string>((messageParam) => processedMessage = messageParam);
var listener = new Listener(ConnectionFactory.Object, ConsumerFactory.Object, type, queueName, exchangeName, new List <IMessageProcessor> {
MessageProcessor1.Object
}, Logger.Object);
listener.Run();
consumer.HandleBasicDeliver("consumer tag", 1, false, exchangeName, exchangeName, null, body);
Assert.AreEqual(processedMessage, message);
Assert.AreEqual(durable, true);
Assert.AreEqual(exclusive, false);
Assert.AreEqual(autoDelete, false);
Assert.AreEqual(exchange, exchangeName);
Assert.AreEqual(exchangeDurable, true);
Assert.AreEqual(exchangeAutoDelete, false);
Assert.AreEqual(Encoding.UTF8.GetString(body), message);
ConnectionFactory.Verify(x => x.CreateConnection(), Times.Once);
Connection.Verify(x => x.CreateModel(), Times.Once);
Model.Verify(x => x.ExchangeDeclare(exchangeName, ExchangeType.Direct, true, false, null), Times.Once);
Model.Verify(x => x.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()), Times.Once);
Model.Verify(x => x.QueueBind(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), null), Times.Once);
Model.Verify(x => x.BasicAck(It.IsAny <ulong>(), It.IsAny <bool>()), Times.Once);
MessageProcessor1.Verify(x => x.Process(It.IsAny <string>()), Times.Once);
}
public void Run_ProcessorExists_ShouldRunAndListenMessages()
{
ResetCalls();
var email = "*****@*****.**";
var title = "invitation email";
var body = "welcome onboard!";
var queueName1 = string.Empty;
bool?durable = null;
bool?exclusive = null;
bool?autoDelete = null;
bool?exchangeDurable = null;
bool?exchangeAutoDelete = null;
var exchange = string.Empty;
var messageBody = Encoding.UTF8.GetBytes("{" + $"\"email\": \"{email}\", \"title\": \"{title}\", \"body\": \"{body}\"" + "}");
var queueName = "126_queue";
var exchangeName = "exchange name";
var processedEmail = string.Empty;
var processedTitle = string.Empty;
var processedBody = string.Empty;
var consumer = new EventingBasicConsumer(Model.Object);
ConsumerFactory.Setup(x => x.CreateEventConsumer(Model.Object)).Returns(consumer);
Model.Setup(x => x.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()))
.Callback <string, bool, bool, bool, IDictionary <string, object> >((queueParam, durableParam, exclusiveParam, autoDeleteParam, param) =>
{
queueName1 = queueParam;
durable = durableParam;
exclusive = exclusiveParam;
autoDelete = autoDeleteParam;
});
Model.Setup(x => x.ExchangeDeclare(exchangeName, ExchangeType.Direct, true, false, null))
.Callback <string, string, bool, bool, IDictionary <string, object> >((exchangeParam, directParam, durableParam, autoDeleteParam, param) =>
{
exchange = exchangeParam;
exchangeDurable = durableParam;
exchangeAutoDelete = autoDeleteParam;
});
Model.Setup(x => x.QueueBind(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), null));
Connection.Setup(x => x.CreateModel()).Returns(Model.Object);
ConnectionFactory.Setup(x => x.CreateConnection()).Returns(Connection.Object);
EmailService1.Setup(x => x.Type).Returns(EmailServiceType.SendGrid);
EmailService1.Setup(x => x.SendEmail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Callback <string, string, string>((emailParam, titleParam, bodyParam) =>
{
processedEmail = emailParam;
processedTitle = titleParam;
processedBody = bodyParam;
});
EmailService2.Setup(x => x.Type).Returns(EmailServiceType.Elastic);
EmailService2.Setup(x => x.SendEmail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Callback <string, string, string>((emailParam, titleParam, bodyParam) =>
{
processedEmail = emailParam;
processedTitle = titleParam;
processedBody = bodyParam;
});
var listener = new Listener(EmailServiceType.Elastic, ConnectionFactory.Object, ConsumerFactory.Object, queueName, exchangeName, new List <IEmailService> {
EmailService1.Object, EmailService2.Object
}, Logger.Object);
listener.Run();
consumer.HandleBasicDeliver("consumer tag", 1, false, exchangeName, exchangeName, null, messageBody);
Assert.AreEqual(processedEmail, email);
Assert.AreEqual(processedTitle, title);
Assert.AreEqual(processedBody, body);
Assert.AreEqual(durable, true);
Assert.AreEqual(exclusive, false);
Assert.AreEqual(autoDelete, false);
Assert.AreEqual(exchange, exchangeName);
Assert.AreEqual(exchangeDurable, true);
Assert.AreEqual(exchangeAutoDelete, false);
ConnectionFactory.Verify(x => x.CreateConnection(), Times.Once);
Connection.Verify(x => x.CreateModel(), Times.Once);
Model.Verify(x => x.ExchangeDeclare(exchangeName, ExchangeType.Direct, true, false, null), Times.Once);
Model.Verify(x => x.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()), Times.Once);
Model.Verify(x => x.QueueBind(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), null), Times.Once);
Model.Verify(x => x.BasicAck(It.IsAny <ulong>(), It.IsAny <bool>()), Times.Once);
EmailService1.Verify(x => x.SendEmail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Never);
EmailService2.Verify(x => x.SendEmail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public void StartReceivingMessages_InvokesCallbackWithCorrectEventMessage()
{
// Arrange
var channelMock = new Mock <IModel>();
EventingBasicConsumer basicConsumer = null;
channelMock.Setup(c => c.BasicConsume("TestQueue",
true,
"",
false,
false,
null,
It.IsAny <EventingBasicConsumer>()))
.Callback((string queue,
bool autoAck,
string consumerTag,
bool noLocal,
bool exclusive,
IDictionary <string, object> arguments,
IBasicConsumer consumer) =>
{
basicConsumer = consumer as EventingBasicConsumer;
});
var connectionMock = new Mock <IConnection>();
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object);
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange");
var receiver = new RabbitMQMessageReceiver(context, "TestQueue", new List <string> {
"TestTopic2"
});
// Act
bool callbackWasInvoked = false;
IEventMessage eventMessage = null;
receiver.StartReceivingMessages((e) =>
{
callbackWasInvoked = true;
eventMessage = e;
});
var properties = new BasicProperties
{
Type = "Test type",
Timestamp = new AmqpTimestamp(1542183431),
CorrelationId = "test id"
};
basicConsumer.HandleBasicDeliver("", 0, false, "", "routing.key", properties,
Encoding.UTF8.GetBytes("test message"));
// Assert
Assert.IsTrue(callbackWasInvoked);
Assert.AreEqual("routing.key", eventMessage.RoutingKey);
Assert.AreEqual("test message", eventMessage.Message);
Assert.AreEqual("Test type", eventMessage.EventType);
Assert.AreEqual(1542183431, eventMessage.Timestamp);
Assert.AreEqual("test id", eventMessage.CorrelationId);
}
