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 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 QueueDeclare_CreatesQueue()
{
// Arrange
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
const string queueName = "someQueue";
const bool isDurable = true;
const bool isExclusive = true;
const bool isAutoDelete = false;
var arguments = new Dictionary <string, object>();
// Act
model.QueueDeclare(queue: queueName, durable: isDurable, exclusive: isExclusive, autoDelete: isAutoDelete, arguments: arguments);
// Assert
Assert.Single(node.Queues);
var queue = node.Queues.First();
AssertQueueDetails(queue, queueName, isAutoDelete, arguments, isDurable, isExclusive);
}
}
public void QueuePurge_removes_all_messages_from_specified_queue()
{
var node = new RabbitServer();
using (var model = new FakeModel(node))
{
model.QueueDeclare("my_other_queue");
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_other_queue"].Messages.Enqueue(new RabbitMessage());
model.QueueDeclare("my_queue");
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
node.Queues["my_queue"].Messages.Enqueue(new RabbitMessage());
var count = model.QueuePurge("my_queue");
Assert.Equal(4u, count);
Assert.True(node.Queues["my_queue"].Messages.IsEmpty);
Assert.False(node.Queues["my_other_queue"].Messages.IsEmpty);
}
}
public void BasicCancel_removes_a_consumer()
{
var server = new RabbitServer();
using (var model = new FakeModel(server))
{
model.QueueDeclare("my_queue");
var expectedConsumerTag = "foo";
var actualConsumerTag = "";
var consumer = new EventingBasicConsumer(model)
{
ConsumerTag = expectedConsumerTag
};
consumer.Unregistered += (s, e) => actualConsumerTag = e.ConsumerTag;
model.BasicConsume("my_queue", false, expectedConsumerTag, consumer);
Assert.True(consumer.IsRunning);
model.BasicCancel(expectedConsumerTag);
Assert.False(consumer.IsRunning);
Assert.Equal(expectedConsumerTag, actualConsumerTag);
}
}
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);
}
}
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 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));
}
}
[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);
}
}
