public void BasicPublishBatch_publishes_messages()
{
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var messages = new[] { "hello world!", "Thank you, @inbarbarkai" };
var encodedMessages = messages.Select(m => Encoding.ASCII.GetBytes(m)).ToArray();
var batch = model.CreateBasicPublishBatch();
batch.Add("my_exchange", null, true, new BasicProperties(), encodedMessages[0]);
batch.Add("my_exchange", null, true, new BasicProperties(), encodedMessages[1]);
batch.Publish();
Assert.Equal(2, node.Queues["my_queue"].Messages.Count);
var index = 0;
foreach (var item in node.Queues["my_queue"].Messages)
{
Assert.Equal(encodedMessages[index], item.Body);
index++;
}
}
}
public void ExchangeDeleteNoWait_removes_the_exchange_if_it_exists(bool ifUnused)
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
model.ExchangeDeleteNoWait(exchange: exchangeName, ifUnused: ifUnused);
Assert.Empty(server.Exchanges);
}
}
public void ExchangeDelete_does_nothing_if_exchange_does_not_exist()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
model.ExchangeDelete(exchange: "someOtherExchange");
Assert.Single(server.Exchanges);
}
}
public void ExchangeDelete_with_only_name_argument_removes_the_exchange_if_it_exists()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
model.ExchangeDelete(exchange: exchangeName);
Assert.Empty(server.Exchanges);
}
}
public void ExchangeDeclarePassive_does_not_throw_if_exchange_exists()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Direct);
model.ExchangeDeclarePassive(exchange: exchangeName);
}
Assert.True(true); // The test is successful if it does not throw
}
public void ExchangeDeclare_with_name_and_type_creates_exchange()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string exchangeName = "someExchange";
const string exchangeType = "someType";
model.ExchangeDeclare(exchange: exchangeName, type: exchangeType);
Assert.Single(server.Exchanges);
var exchange = server.Exchanges.First();
AssertEx.AssertExchangeDetails(exchange, exchangeName, false, null, false, exchangeType);
}
}
public void ExchangeBindNoWait_binds_an_exchange_to_a_queue()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Dictionary <string, object>();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclare(queueName);
model.ExchangeBindNoWait(queueName, exchangeName, routingKey, arguments);
AssertEx.AssertBinding(server, exchangeName, routingKey, queueName);
}
}
public void ExchangeDelete_ExchangeDoesNotExists_DoesNothing()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
// Act
model.ExchangeDelete(exchange: "someOtherExchange");
// Assert
Assert.Single(node.Exchanges);
}
}
public void ExchangeDeleteNoWait_ExchangeExists_RemovesTheExchange(bool ifUnused)
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
// Act
model.ExchangeDeleteNoWait(exchange: exchangeName, ifUnused: ifUnused);
// Assert
Assert.Empty(node.Exchanges);
}
}
public void ExchangeDelete_NameOnlyExchangeExists_RemovesTheExchange()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string exchangeName = "someExchange";
model.ExchangeDeclare(exchangeName, "someType");
// Act
model.ExchangeDelete(exchange: exchangeName);
// Assert
Assert.Empty(node.Exchanges);
}
}
public void MessageCount_returns_the_number_of_messages_in_the_queue()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string queueName = "myQueue";
model.QueueDeclare(queueName);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.ExchangeBind(queueName, "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
Assert.Equal(1u, model.MessageCount(queueName));
}
}
public void ConsumerCount_returns_the_number_of_attached_consumers()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string queueName = "myQueue";
model.QueueDeclare(queueName);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.ExchangeBind(queueName, "my_exchange", null);
// Attach 2 consumers
model.BasicConsume(queueName, true, new DefaultBasicConsumer(model));
model.BasicConsume(queueName, true, new DefaultBasicConsumer(model));
Assert.Equal(2u, model.ConsumerCount(queueName));
}
}
public void ExchangeDeclare_with_all_arguments_creates_exchange()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string exchangeName = "someExchange";
const string exchangeType = "someType";
const bool isDurable = true;
const bool isAutoDelete = false;
var arguments = new Dictionary <string, object>();
model.ExchangeDeclare(exchange: exchangeName, type: exchangeType, durable: isDurable, autoDelete: isAutoDelete, arguments: arguments);
Assert.Single(server.Exchanges);
var exchange = server.Exchanges.First();
AssertEx.AssertExchangeDetails(exchange, exchangeName, isAutoDelete, arguments, isDurable, exchangeType);
}
}
[InlineData(false, 1)] // BasicGet with NO auto-ack should NOT remove the message from the queue
public void BasicGet_does_not_remove_the_message_from_the_queue_if_not_acked(bool autoAck, int expectedMessageCount)
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var encodedMessage = Encoding.ASCII.GetBytes("hello world!");
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
_ = model.BasicGet("my_queue", autoAck);
Assert.Equal(expectedMessageCount, server.Queues["my_queue"].Messages.Count);
Assert.Equal(expectedMessageCount, model.WorkingMessagesForUnitTests.Count);
}
}
public void BasicPublish_publishes_message()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
Assert.Single(server.Queues["my_queue"].Messages);
Assert.Equal(encodedMessage, server.Queues["my_queue"].Messages.First().Body);
}
}
public void ExchangeDeclare_WithNameType_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string exchangeName = "someExchange";
const string exchangeType = "someType";
// Act
model.ExchangeDeclare(exchange: exchangeName, type: exchangeType);
// Assert
Assert.Single(node.Exchanges);
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, false, null, false, exchangeType);
}
}
public void BasicGet_retrieves_message_from_the_queue()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
var response = model.BasicGet("my_queue", false);
Assert.Equal(encodedMessage, response.Body);
Assert.True(response.DeliveryTag > 0ul);
}
}
public void ExchangeUnbindNoWait_removes_binding()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Dictionary <string, object>();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclare(queueName);
model.ExchangeBind(exchangeName, queueName, routingKey, arguments);
model.ExchangeUnbindNoWait(queueName, exchangeName, routingKey, arguments);
Assert.True(server.Exchanges[exchangeName].Bindings.IsEmpty);
Assert.True(server.Queues[queueName].Bindings.IsEmpty);
}
}
public void BasicConsume_works_for_asynchronous_consumers()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
var consumer = new FakeAsyncDefaultBasicConsumer(model);
model.BasicConsume("my_queue", false, consumer);
Assert.True(consumer.IsRunning);
Assert.Equal(encodedMessage, consumer.LastDelivery.body);
}
}
public void QueueBind_BindsAnExchangeToAQueue()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Dictionary <string, object>();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclarePassive(queueName);
// Act
model.QueueBind(queueName, exchangeName, routingKey, arguments);
// Assert
AssertBinding(node, exchangeName, routingKey, queueName);
}
}
[InlineData(false, 1)] // BasicGet with NO auto-ack should NOT remove the message from the queue
public void BasicGet_Should_Not_Remove_The_Message_From_Queue_If_Not_Acked(bool autoAck, int expectedMessageCount)
{
// arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var encodedMessage = Encoding.ASCII.GetBytes("hello world!");
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
// act
_ = model.BasicGet("my_queue", autoAck);
// assert
Assert.Equal(expectedMessageCount, node.Queues["my_queue"].Messages.Count);
Assert.Equal(expectedMessageCount, model.WorkingMessages.Count);
}
}
public void ExchangeDeclare_AllArguments_CreatesExchange()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string exchangeName = "someExchange";
const string exchangeType = "someType";
const bool isDurable = true;
const bool isAutoDelete = false;
var arguments = new Dictionary <string, object>();
// Act
model.ExchangeDeclare(exchange: exchangeName, type: exchangeType, durable: isDurable, autoDelete: isAutoDelete, arguments: arguments);
// Assert
Assert.Single(node.Exchanges);
var exchange = node.Exchanges.First();
AssertExchangeDetails(exchange, exchangeName, isAutoDelete, arguments, isDurable, exchangeType);
}
}
public void BasicAck()
{
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
model.BasicConsume("my_queue", false, new EventingBasicConsumer(model));
// Act
var deliveryTag = model.WorkingMessages.First().Key;
model.BasicAck(deliveryTag, false);
// Assert
Assert.Empty(node.Queues["my_queue"].Messages);
}
}
public void BasicGet_MessageOnQueue_GetsMessage()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclarePassive("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
// Act
var response = model.BasicGet("my_queue", false);
// Assert
Assert.Equal(encodedMessage, response.Body);
Assert.True(response.DeliveryTag > 0ul);
}
}
public void MessageCount_returns_the_number_of_non_consumed_messages_in_the_queue()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
const string queueName = "myQueue";
model.QueueDeclare(queueName);
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.ExchangeBind(queueName, "my_exchange", null);
for (var i = 0; i < 10; i++)
{
var message = $"hello world: {i}";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
}
// Consume 4 messages
var consumer = new EventingBasicConsumer(model);
var consumptionCount = 0;
consumer.Received += (s, e) =>
{
if (consumptionCount >= 4)
{
return;
}
model.BasicAck(e.DeliveryTag, false);
consumptionCount++;
};
model.BasicConsume(queueName, true, consumer);
Assert.Equal(6u, model.MessageCount(queueName));
}
}
public void QueueUnbind_RemovesBinding()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string queueName = "someQueue";
const string exchangeName = "someExchange";
const string routingKey = "someRoutingKey";
var arguments = new Dictionary <string, object>();
model.ExchangeDeclare(exchangeName, "direct");
model.QueueDeclarePassive(queueName);
model.ExchangeBind(exchangeName, queueName, routingKey, arguments);
// Act
model.QueueUnbind(queueName, exchangeName, routingKey, arguments);
// Assert
Assert.True(node.Exchanges[exchangeName].Bindings.IsEmpty);
Assert.True(node.Queues[queueName].Bindings.IsEmpty);
}
}
public void BasicAck_removes_message_from_queue()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var message = "hello world!";
var encodedMessage = Encoding.ASCII.GetBytes(message);
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
var consumer = new EventingBasicConsumer(model);
model.BasicConsume("my_queue", false, consumer);
Assert.True(consumer.IsRunning);
var deliveryTag = model.WorkingMessagesForUnitTests.First().Key;
model.BasicAck(deliveryTag, false);
Assert.Empty(server.Queues["my_queue"].Messages);
}
}
[InlineData(false, 0)] // If requeue param to BasicNack is false, the message that is nacked should be removed from Rabbit
public void Nacking_Message_Should_Not_Reenqueue_Brand_New_Message(bool requeue, int expectedMessageCount)
{
// arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var encodedMessage = Encoding.ASCII.GetBytes("hello world!");
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
model.BasicConsume("my_queue", false, new EventingBasicConsumer(model));
// act
var deliveryTag = model.WorkingMessages.First().Key;
model.BasicNack(deliveryTag, false, requeue);
// assert
Assert.Equal(expectedMessageCount, node.Queues["my_queue"].Messages.Count);
Assert.Equal(expectedMessageCount, model.WorkingMessages.Count);
}
}
[InlineData(false, 0)] // If requeue param to BasicNack is false, the message that is nacked should be removed from Rabbit
public void Nacking_message_does_not_reenqueue_a_brand_new_message(bool requeue, int expectedMessageCount)
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
model.ExchangeDeclare("my_exchange", ExchangeType.Direct);
model.QueueDeclare("my_queue");
model.ExchangeBind("my_queue", "my_exchange", null);
var encodedMessage = Encoding.ASCII.GetBytes("hello world!");
model.BasicPublish("my_exchange", null, new BasicProperties(), encodedMessage);
var consumer = new EventingBasicConsumer(model);
model.BasicConsume("my_queue", false, consumer);
Assert.True(consumer.IsRunning);
var deliveryTag = model.WorkingMessagesForUnitTests.First().Key;
model.BasicNack(deliveryTag, false, requeue);
Assert.Equal(expectedMessageCount, server.Queues["my_queue"].Messages.Count);
Assert.Equal(expectedMessageCount, model.WorkingMessagesForUnitTests.Count);
}
}