public void SendMessage_CallsBasicPublish_WithCorrectExchangeName()
{
// Arrange
var propsMock = new Mock <IBasicProperties>();
var channelMock = new Mock <IModel>(MockBehavior.Strict);
channelMock.Setup(c => c.BasicPublish(It.Is <string>(k => k == "Testexchange1"),
"MyRoutingKey",
false,
propsMock.Object,
It.Is <byte[]>(b => Encoding.UTF8.GetString(b) == "MyMessage")))
.Verifiable();
channelMock.Setup(c => c.CreateBasicProperties())
.Returns(propsMock.Object)
.Verifiable();
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object)
.Verifiable();
var context = new RabbitMQBusContext(connectionMock.Object, "Testexchange1");
var sender = new RabbitMQMessageSender(context);
// Act
sender.SendMessage(new EventMessage("MyRoutingKey", "MyMessage"));
// Assert
channelMock.VerifyAll();
}
public void TestInitialize()
{
_exchangeName = "My.Test.ExchangeName";
_queueName = "My.Test.ListenQueue";
_topicFilters = new string[] { "My.Test.Topic", "My.Test.OtherTopic" };
_topic = "My.Test.Topic";
_body = Encoding.Unicode.GetBytes("Hello, World");
_eventMessage = new EventMessage
{
Topic = _topic,
Body = _body,
};
_propMock = new Mock <IBasicProperties>(MockBehavior.Loose);
_propsFromChannelMock = new Mock <IBasicProperties>();
_channelMock = new Mock <IModel>();
_channelMock.Setup(c => c.CreateBasicProperties()).Returns(_propsFromChannelMock.Object);
_channelMock.Setup(c => c.BasicConsume(_queueName, true, It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >(), It.IsAny <IBasicConsumer>()))
.Callback((string a, bool b, string c, bool d, bool e, IDictionary <string, object> args,
IBasicConsumer consumer) => _consumer = (EventingBasicConsumer)consumer);
_connectionMock = new Mock <IConnection>(MockBehavior.Strict);
_connectionMock.Setup(conn => conn.CreateModel()).Returns(_channelMock.Object);
_busContext = new RabbitMQBusContext(_connectionMock.Object, _exchangeName);
}
public void StartReceivingMessages_InvokesCallbackWithCorrectEventMessage()
{
// Arrange
var channelMock = new Mock <IModel>();
AsyncEventingBasicConsumer basicConsumer = null;
channelMock.Setup(c => c.BasicConsume("TestQueue",
true,
"",
false,
false,
null,
It.IsAny <AsyncEventingBasicConsumer>()))
.Callback((string queue,
bool autoAck,
string consumerTag,
bool noLocal,
bool exclusive,
IDictionary <string, object> arguments,
IBasicConsumer consumer) =>
{
basicConsumer = consumer as AsyncEventingBasicConsumer;
});
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")).Wait();
// 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);
}
public void DeclareQueue_CallsQueueDeclare()
{
// Arrange
var channelMock = new Mock <IModel>();
channelMock.Setup(c => c.QueueDeclare("TestQueue",
true,
false,
false,
null))
.Returns(new QueueDeclareOk("", 0, 0))
.Verifiable();
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object)
.Verifiable();
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange");
var receiver = new RabbitMQMessageReceiver(context, "TestQueue", new List <string> {
"TestTopic"
});
// Act
receiver.DeclareQueue();
// Assert
channelMock.VerifyAll();
}
public void Constructor_SetsPropertiesCorrectly()
{
// Arrange
var channelMock = new Mock <IModel>(MockBehavior.Strict);
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object);
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange");
var topicExpressions = new List <string> {
"TestTopic"
};
// Act
var receiver = new RabbitMQMessageReceiver(context, "TestQueue", topicExpressions);
// Assert
Assert.AreEqual("TestExchange", receiver.ExchangeName);
Assert.AreEqual("TestQueue", receiver.QueueName);
Assert.AreEqual(topicExpressions, receiver.TopicExpressions);
IModel channel = TestHelper.GetPrivateProperty <IModel>(receiver, "Channel");
Assert.AreEqual(channelMock.Object, channel);
}
private IBusContext <IConnection> CreateNijnConfig(IServiceCollection serviceCollection)
{
//Deprecated method, maar kan even niet anders
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(
new ConsoleLoggerProvider(
(text, logLevel) => logLevel >= LogLevel.Debug, true));
var connectionBuilder = new RabbitMQContextBuilder()
.ReadFromEnvironmentVariables();
_context = connectionBuilder.CreateContext();
var builder = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies(serviceCollection)
.WithContext(_context)
.UseConventions();
var host = builder.CreateHost();
host.StartListeningInOtherThread();
return(_context);
}
public void SendMessage_CallsBasicPublish_WithCorrectCorrelationIdInBasicProperties()
{
// Arrange
IBasicProperties props = new BasicProperties();
var channelMock = new Mock <IModel>(MockBehavior.Strict);
channelMock.Setup(c => c.CreateBasicProperties())
.Returns(props)
.Verifiable();
channelMock.Setup(c => c.BasicPublish("Testxchange1",
"MyRoutingKey",
false,
It.Is <IBasicProperties>(p => p.CorrelationId == "correlationID"),
It.IsAny <Byte[]>()))
.Verifiable();
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object)
.Verifiable();
var context = new RabbitMQBusContext(connectionMock.Object, "Testxchange1");
var sender = new RabbitMQMessageSender(context);
// Act
sender.SendMessage(new EventMessage("MyRoutingKey", "MyMessage", "Test", 9, "correlationID"));
// Assert
channelMock.VerifyAll();
}
public void DeclareQueue_CallsQueueBindForEveryTopicExpression()
{
// Arrange
var topicExpressions = new List <string> {
"TestTopic1", "TestTopic2"
};
var channelMock = new Mock <IModel>();
foreach (string topicExpression in topicExpressions)
{
channelMock.Setup(c => c.QueueBind("TestQueue", "TestExchange", topicExpression, null))
.Verifiable();
}
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object)
.Verifiable();
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange");
var receiver = new RabbitMQMessageReceiver(context, "TestQueue", topicExpressions);
// Act
receiver.DeclareQueue();
// Assert
channelMock.VerifyAll();
}
public void CreateMessageReceiver_ReturnsMessageReceiverWithCorrectProperties()
{
// Arrange
var channelMock = new Mock <IModel>(MockBehavior.Strict);
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object);
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange4");
var topicExpressions = new List <string> {
"topic.expression.a", "routing.key.b"
};
// Act
RabbitMQMessageReceiver receiver = (RabbitMQMessageReceiver)context.CreateMessageReceiver("TestQueue", topicExpressions);
// Assert
Assert.AreEqual("TestExchange4", receiver.ExchangeName);
Assert.AreEqual("TestQueue", receiver.QueueName);
Assert.AreEqual(topicExpressions, receiver.TopicExpressions);
IModel channel = TestHelper.GetPrivateProperty <IModel>(receiver, "Channel");
Assert.AreEqual(channelMock.Object, channel);
}
public void RecieveCommandsCalledCorrectly()
{
// Arrange
var queueName = "TestQueue1";
var channelMock = new Mock <IModel>(MockBehavior.Strict);
channelMock.Setup(c => c.QueueDeclare(queueName, false, false, true, null)).Returns(new QueueDeclareOk("", 0, 0))
.Verifiable();
channelMock.Setup(c => c.BasicQos(0, 1, false)).Verifiable();
channelMock.Setup(m => m.BasicConsume(queueName, false, "", false, false, null, It.IsAny <AsyncEventingBasicConsumer>())).Returns(queueName);
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(r => r.CreateModel())
.Returns(channelMock.Object)
.Verifiable();
var context = new RabbitMQBusContext(connectionMock.Object, "");
var target = new RabbitMQCommandReceiver(context, queueName);
// Act
target.DeclareCommandQueue();
target.StartReceivingCommands(Callback);
// Assert
channelMock.VerifyAll();
}
public void StartReceivingMessages_CallsBasicConsume()
{
// Arrange
var channelMock = new Mock <IModel>();
channelMock.Setup(c => c.BasicConsume("TestQueue",
true,
"",
false,
false,
null,
It.IsAny <IBasicConsumer>()))
.Verifiable();
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
receiver.StartReceivingMessages((e) => { });
// Assert
channelMock.VerifyAll();
}
public void TestInitialize()
{
var contextBuilder = new RabbitMQContextBuilder();
_context = contextBuilder.WithCredentials("guest", "guest")
.WithAddress(_hostname, 5672)
.WithExchange("TestExchange1")
.CreateContext();
}
public void RabbitMQBusContextHasConnectionAndExchange()
{
Mock <IConnection> connectionMock = new Mock <IConnection>(MockBehavior.Strict);
string exchangeName = "My.Test.ExchangeName";
var target = new RabbitMQBusContext(connectionMock.Object, exchangeName);
Assert.AreEqual(connectionMock.Object, target.Connection);
Assert.AreEqual("My.Test.ExchangeName", target.ExchangeName);
}
public void RabbitMQBusContextDisposesConnection()
{
Mock <IConnection> connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(conn => conn.Dispose());
var target = new RabbitMQBusContext(connectionMock.Object, "My.Test.ExchangeName");
target.Dispose();
connectionMock.Verify(c => c.Dispose());
}
public void SendCommandCallsBasicPublishWithCorrectMessage()
{
// Arrange
var queueName = "MyRoutingKey";
var replyQueueName = "replyQueueName";
var timeStamp = new AmqpTimestamp(DateTime.Now.Ticks);
var propsMock = new Mock <IBasicProperties>();
propsMock.Setup(x => x.CorrelationId).Returns("test1");
propsMock.Setup(x => x.ReplyTo).Returns(replyQueueName);
propsMock.Setup(x => x.Timestamp).Returns(timeStamp);
var channelMock = new Mock <IModel>(MockBehavior.Strict);
channelMock.Setup(c => c.BasicPublish("",
queueName,
false,
propsMock.Object,
It.Is <byte[]>(b => Encoding.UTF8.GetString(b) == "MyMessage")))
.Verifiable();
channelMock.Setup(c => c.CreateBasicProperties())
.Returns(propsMock.Object)
.Verifiable();
channelMock.Setup(c => c.QueueDeclare("", false, false, true, null)).Returns(new QueueDeclareOk(replyQueueName, 0, 0))
.Verifiable();
channelMock.Setup(m =>
m.BasicConsume(replyQueueName, true, "", false, false, null, It.IsAny <AsyncEventingBasicConsumer>())).Returns("");
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(r => r.CreateModel())
.Returns(channelMock.Object)
.Verifiable();
var context = new RabbitMQBusContext(connectionMock.Object, "");
var target = new RabbitMQCommandSender(context);
// Act
target.SendCommandAsync(new CommandRequestMessage("MyMessage", "test"), queueName);
// Assert
channelMock.VerifyAll();
}
public void CreateMessageSender_WithBusContextDisposed_ThrowsObjectDisposedException()
{
// Arrange
var connectionMock = new Mock <IConnection>();
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange3");
context.Dispose();
// Act & Assert
Assert.ThrowsException <ObjectDisposedException>(() =>
{
context.CreateMessageSender();
});
}
public void CreateMessageSenderCreatesRabbitMQMessageSender()
{
Mock <IModel> channelMock = new Mock <IModel>();
Mock <IConnection> connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(conn => conn.CreateModel()).Returns(channelMock.Object);
var target = new RabbitMQBusContext(connectionMock.Object, "My.Test.ExchangeName");
// Act
var sender = target.CreateMessageSender();
// Assert
Assert.IsInstanceOfType(sender, typeof(RabbitMQMessageSender));
connectionMock.Verify(conn => conn.CreateModel());
}
public void CreateMessageReceiver_WithBusContextDisposed_ThrowsObjectDisposedException()
{
// Arrange
var connectionMock = new Mock <IConnection>();
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange3");
context.Dispose();
// Act & Assert
Assert.ThrowsException <ObjectDisposedException>(() =>
{
context.CreateMessageReceiver("TestQueue", new List <string> {
"topic.expression.a", "routing.key.b"
});
});
}
public void TestInitialize()
{
_exchangeName = "My.Test.ExchangeName";
_topic = "My.Test.Topic";
_body = Encoding.Unicode.GetBytes("Hello, World");
_eventMessage = new EventMessage
{
Topic = _topic,
Body = _body,
};
_propsMock = new Mock <IBasicProperties>();
_channelMock = new Mock <IModel>();
_channelMock.Setup(c => c.CreateBasicProperties()).Returns(_propsMock.Object);
_connectionMock = new Mock <IConnection>(MockBehavior.Strict);
_connectionMock.Setup(conn => conn.CreateModel()).Returns(_channelMock.Object);
_busContext = new RabbitMQBusContext(_connectionMock.Object, _exchangeName);
}
public void CreateMessageSender_ReturnsMessageSenderWithCorrectProperties()
{
// Arrange
var channelMock = new Mock <IModel>(MockBehavior.Strict);
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object);
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange3");
// Act
RabbitMQMessageSender sender = (RabbitMQMessageSender)context.CreateMessageSender();
// Assert
Assert.AreEqual("TestExchange3", sender.ExchangeName);
IModel channel = TestHelper.GetPrivateProperty <IModel>(sender, "Channel");
Assert.AreEqual(channelMock.Object, channel);
}
public void Constructor_SetsPropertiesCorrectly()
{
// Arrange
var channelMock = new Mock <IModel>(MockBehavior.Strict);
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object);
var context = new RabbitMQBusContext(connectionMock.Object, "ExchangeName");
// Act
var sender = new RabbitMQMessageSender(context);
// Assert
Assert.AreEqual("ExchangeName", sender.ExchangeName);
IModel channel = TestHelper.GetPrivateProperty <IModel>(sender, "Channel");
Assert.AreEqual(channelMock.Object, channel);
}
public void CreateMessageReceiverCreatesRabbitMQMessageReceiver()
{
Mock <IModel> channelMock = new Mock <IModel>();
Mock <IConnection> connectionMock = new Mock <IConnection>(MockBehavior.Strict);
connectionMock.Setup(conn => conn.CreateModel()).Returns(channelMock.Object);
var target = new RabbitMQBusContext(connectionMock.Object, "My.Test.ExchangeName");
// Act
string queueName = "My.Test.ListenQueue";
string[] topicFilters = new string[] { "My.Test.Topic", "My.Test.OtherTopic" };
var receiver = target.CreateMessageReceiver(queueName, topicFilters);
// Assert
Assert.IsInstanceOfType(receiver, typeof(RabbitMQMessageReceiver));
connectionMock.Verify(conn => conn.CreateModel());
Assert.AreEqual("My.Test.ListenQueue", receiver.QueueName);
CollectionAssert.AreEquivalent(topicFilters, receiver.TopicFilters.ToList());
}
public void StartReceivingMessages_IfAlreadyStarted_ThrowsBusConfigurationException()
{
// Arrange
var channelMock = new Mock <IModel>();
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 & Assert
receiver.StartReceivingMessages(m => { });
Assert.ThrowsException <BusConfigurationException>(() =>
{
receiver.StartReceivingMessages(m => { });
});
}
public void StartReceivingMessages_WithCallbackNull_ThrowsArgumentNullException()
{
// Arrange
var channelMock = new Mock <IModel>(MockBehavior.Strict);
var connectionMock = new Mock <IConnection>(MockBehavior.Strict);
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 & Assert
var exception = Assert.ThrowsException <ArgumentNullException>(() =>
{
receiver.StartReceivingMessages(null);
});
Assert.AreEqual("callback", exception.ParamName);
}
public void SendMessage_WithSenderDisposed_ThrowsObjectDisposedException()
{
// Arrange
var channelMock = new Mock <IModel>();
var connectionMock = new Mock <IConnection>();
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object);
var context = new RabbitMQBusContext(connectionMock.Object, "Testexchange1");
var sender = new RabbitMQMessageSender(context);
sender.Dispose();
// Act & Assert
Assert.ThrowsException <ObjectDisposedException>(() =>
{
sender.SendMessage(new EventMessage("MyRoutingKey", "MyMessage"));
});
}
public void StartReceivingMessages_WithReceiverDisposed_ThrowsObjectDisposedException()
{
// Arrange
var channelMock = new Mock <IModel>();
var connectionMock = new Mock <IConnection>();
connectionMock.Setup(c => c.CreateModel())
.Returns(channelMock.Object);
var context = new RabbitMQBusContext(connectionMock.Object, "TestExchange3");
var receiver = new RabbitMQMessageReceiver(context, "TestQueue", new List <string> {
"TestTopic2"
});
receiver.Dispose();
// Act & Assert
Assert.ThrowsException <ObjectDisposedException>(() =>
{
receiver.StartReceivingMessages((e) => { });
});
}
public RabbitMQMessageSender(RabbitMQBusContext buscontext)
{
_buscontext = buscontext;
_channel = _buscontext.Connection.CreateModel();
_channel.ExchangeDeclare(_buscontext.ExchangeName, ExchangeType.Topic);
}
