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); } }