public void SendToExchangeWithAlternate()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "my_exchange", type: ExchangeType.Topic, arguments: new Dictionary <string, object> {
["alternate-exchange"] = "my_alternate_exchange"
});
channel.ExchangeDeclare(exchange: "my_alternate_exchange", type: ExchangeType.Fanout);
channel.QueueDeclare(queue: "main_queue", durable: false, exclusive: false, autoDelete: false, arguments: null);
channel.QueueDeclare(queue: "fallback_queue", durable: false, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind("fallback_queue", "my_alternate_exchange", null);
channel.QueueBind("main_queue", "my_exchange", "topic");
}
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string message = "hello world!";
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange: "my_exchange", routingKey: "other_topic", mandatory: false, basicProperties: null, body: messageBody);
messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange: "my_exchange", routingKey: "topic", mandatory: false, basicProperties: null, body: messageBody);
}
Assert.Equal(2, rabbitServer.Exchanges["my_exchange"].Messages.Count);
Assert.Single(rabbitServer.Exchanges["my_alternate_exchange"].Messages);
Assert.Single(rabbitServer.Queues["fallback_queue"].Messages);
Assert.Single(rabbitServer.Queues["main_queue"].Messages);
}
public void Closing_a_connection_after_disconnection_then_reconnection_should_not_throw()
{
var factory = new FakeConnectionFactory();
var connection = factory.CreateConnection();
connection.Close();
connection = factory.CreateConnection();
connection.Close();
Assert.True(true); // If we didn't throw, we reached this point.
}
public void ExecuteFullTest()
{
var operation = new UnbindQueueOperation()
.SetExchangeName("foo")
.SetQueueName("bar")
.SetRoutingKey("#");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
using (var model = connection.CreateModel())
{
model.ExchangeDeclare("foo", ExchangeType.Topic, true);
model.QueueDeclare("bar", true);
model.QueueBind("bar", "foo", "#", null);
}
operation.Execute(connection, string.Empty);
}
Assert.AreEqual(1, server.Queues.Count);
var queue = server.Queues.Values.First();
Assert.AreEqual("bar", queue.Name);
Assert.AreEqual(0, queue.Bindings.Count);
}
public void ExecuteFullTest()
{
var operation = new AddExchangeOperation()
.SetName("bar")
.SetType(ExchangeType.Topic)
.SetAutoDelete(true)
.SetDurable(true)
.AddArgument("foo", "foo-bar")
.AddExchangeBind("foo", "#");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
operation.Execute(connection, string.Empty);
}
Assert.AreEqual(1, server.Exchanges.Count);
var exchange = server.Exchanges.Values.First();
Assert.AreEqual("bar", exchange.Name);
Assert.AreEqual(ExchangeType.Topic, exchange.Type);
Assert.IsTrue(exchange.IsAutoDelete);
Assert.IsTrue(exchange.IsDurable);
Assert.AreEqual(1, exchange.Arguments.Count);
Assert.IsTrue(exchange.Arguments.Contains("foo"));
Assert.AreEqual("foo-bar", exchange.Arguments["foo"]);
Assert.AreEqual(0, exchange.Bindings.Count);
//Exchange-to-exchange bindings not supported in fakes...
}
public void QueueingConsumer_MessagesOnQueueBeforeConsumerIsCreated_ReceiveMessagesOnQueue()
{
var rabbitServer = new RabbitServer();
ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue");
SendMessage(rabbitServer, "my_exchange", "hello_world");
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using var connection = connectionFactory.CreateConnection();
using var channel = connection.CreateModel();
#pragma warning disable CS0618 // Type or member is obsolete
var consumer = new QueueingBasicConsumer(channel);
#pragma warning restore CS0618 // Type or member is obsolete
channel.BasicConsume("my_queue", false, consumer);
if (consumer.Queue.Dequeue(5000, out var messageOut))
{
var messageBody = Encoding.ASCII.GetString(messageOut.Body);
Assert.Equal("hello_world", messageBody);
channel.BasicAck(messageOut.DeliveryTag, multiple: false);
}
Assert.NotNull(messageOut);
}
public void ExecuteFullTest()
{
var operation = new UnbindExchangeOperation()
.SetSourceExchangeName("foo")
.SetDestinationExchangeName("bar")
.SetRoutingKey("#");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
using (var model = connection.CreateModel())
{
model.ExchangeDeclare("foo", ExchangeType.Topic, true);
model.QueueDeclare("bar", true);
}
operation.Execute(connection, string.Empty);
}
Assert.AreEqual(1, server.Queues.Count);
Assert.AreEqual(1, server.Exchanges.Count);
//Exchange-to-exchange bindings not supported in fakes...
}
public void ReceiveMessagesOnQueue()
{
var rabbitServer = new RabbitServer();
ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue");
SendMessage(rabbitServer, "my_exchange", "hello_world");
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
// First message
var message = channel.BasicGet("my_queue", autoAck: false);
Assert.That(message, Is.Not.Null);
var messageBody = Encoding.ASCII.GetString(message.Body);
Assert.That(messageBody, Is.EqualTo("hello_world"));
Assert.That(rabbitServer.Queues["my_queue"].Messages.Count == 1);
channel.BasicAck(message.DeliveryTag, multiple: false);
Assert.That(rabbitServer.Queues["my_queue"].Messages.Count == 0);
}
}
public void QueueingConsumer_MessagesOnQueueBeforeConsumerIsCreated_ReceiveMessagesOnQueue()
{
var rabbitServer = new RabbitServer();
ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue");
SendMessage(rabbitServer, "my_exchange", "hello_world");
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
var consumer = new QueueingBasicConsumer();
channel.BasicConsume("my_queue", false, consumer);
BasicDeliverEventArgs messageOut;
if (consumer.Queue.TryDequeue(out messageOut))
{
var message = (BasicDeliverEventArgs)messageOut;
var messageBody = Encoding.ASCII.GetString(message.Body.Span);
Assert.That(messageBody, Is.EqualTo("hello_world"));
channel.BasicAck(message.DeliveryTag, multiple: false);
}
Assert.That(messageOut, Is.Not.Null);
}
}
public void Assert_Queue_Message_Count_Is(uint count)
{
using (var connection = _connectionFactory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.MessageCount(_queueName).Should().Be(count);
}
}
}
public RabbitMqWrapperSubscriberTests()
{
rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
var logger = Substitute.For <ILogger <RabbitSubscriber> >();
var connection = connectionFactory.CreateConnection();
channel = connection.CreateModel();
sut = new RabbitSubscriber(connectionFactory, logger);
}
private static void SendMessage(RabbitServer rabbitServer, string exchange, string message, IBasicProperties basicProperties = null)
{
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange: exchange, routingKey: null, mandatory: false, basicProperties: basicProperties, body: messageBody);
}
}
private void ConfigureQueueBinding(RabbitServer rabbitServer, string queueName)
{
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
channel.QueueBind(queueName, "", "", null);
}
}
private static void ConfigureQueueBinding(RabbitServer rabbitServer, string exchangeName, string queueName)
{
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using var connection = connectionFactory.CreateConnection();
using var channel = connection.CreateModel();
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Direct);
channel.QueueBind(queueName, exchangeName, null);
}
private void ConfigureQueueBinding(RabbitServer rabbitServer, string exchangeName, string queueName)
{
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.QueueDeclare(queue:queueName,durable:false,exclusive:false,autoDelete:false,arguments:null);
channel.ExchangeDeclare(exchange: exchangeName, type: ExchangeType.Direct);
channel.QueueBind(queueName,exchangeName,null);
}
}
public void TestMigrationMigrationNotPresentAnymore()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare("UnitTest.new_foo", ExchangeType.Direct, true);
channel.QueueDeclare("UnitTest.new_bar", true);
}
var history = new Mock <IRabbitMqHistory>();
history.Setup(x => x.GetAppliedMigrations(It.IsAny <string>())).Returns <string>(prefix =>
new MigrationHistoryRow
{
Prefix = prefix,
AppliedMigrations = new List <MigrationHistoryRowDetails>
{
new MigrationHistoryRowDetails {
Name = "001_TestMigration"
},
new MigrationHistoryRowDetails
{
Name = "002_TestMigration",
Hash = "a6964237ffad49ed9492dca9318f9d793c64aa6d6c7645b7c0db0db9f68d3659",
DownOperations = new List <BaseOperation>
{
new DeleteQueueOperation().SetName("new_bar"),
new DeleteExchangeOperation().SetName("new_foo")
}
}
}
});
MigrationHistoryRow result = null;
history.Setup(x => x.UpdateAppliedMigrations(It.IsAny <MigrationHistoryRow>()))
.Callback <MigrationHistoryRow>(x => result = x);
var migrator = new RabbitMqMigrator(connectionFactory, history.Object);
migrator.UpdateModel("UnitTest");
Assert.AreEqual(0, rabbitServer.Exchanges.Count);
Assert.AreEqual(0, rabbitServer.Queues.Count);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.AppliedMigrations.Count);
Assert.AreEqual("001_TestMigration", result.AppliedMigrations.First().Name);
Assert.IsNotNull(result.AppliedMigrations.First().Hash);
}
public void CreateConnection_ConnectionNotSupplied_ReturnsFakeConnection()
{
// Arrange
var factory = new FakeConnectionFactory();
// Act
var result = factory.CreateConnection();
// Assert
Assert.That(result, Is.Not.Null);
Assert.That(result, Is.InstanceOf <FakeConnection>());
Assert.That(factory.UnderlyingConnection, Is.SameAs(result));
}
public void CreateConnection_ConnectionNotSupplied_ReturnsFakeConnection()
{
// Arrange
var factory = new FakeConnectionFactory();
// Act
var result = factory.CreateConnection();
// Assert
Assert.That(result,Is.Not.Null);
Assert.That(result,Is.InstanceOf<FakeConnection>());
Assert.That(factory.UnderlyingConnection, Is.SameAs(result));
}
public void ReceiveMessagesOnQueueWithBasicProperties()
{
var rabbitServer = new RabbitServer();
ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue");
var basicProperties = new BasicProperties
{
Headers = new Dictionary <string, object>()
{
{ "TestKey", "TestValue" }
},
CorrelationId = Guid.NewGuid().ToString(),
ReplyTo = "TestQueue",
Timestamp = new AmqpTimestamp(123456),
ReplyToAddress = new PublicationAddress("exchangeType", "excahngeName", "routingKey"),
ClusterId = "1",
ContentEncoding = "encoding",
ContentType = "type",
DeliveryMode = 1,
Expiration = "none",
MessageId = "id",
Priority = 1,
Type = "type",
UserId = "1",
AppId = "1"
};
SendMessage(rabbitServer, "my_exchange", "hello_world", basicProperties);
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
// First message
var message = channel.BasicGet("my_queue", autoAck: false);
Assert.That(message, Is.Not.Null);
var messageBody = Encoding.ASCII.GetString(message.Body.Span);
Assert.That(messageBody, Is.EqualTo("hello_world"));
var actualBasicProperties = message.BasicProperties;
actualBasicProperties.Should().BeEquivalentTo(basicProperties);
channel.BasicAck(message.DeliveryTag, multiple: false);
}
}
public void SendToExchangeOnly()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string message = "hello world!";
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange:"my_exchange",routingKey:null,mandatory:false,basicProperties:null,body:messageBody);
}
Assert.That(rabbitServer.Exchanges["my_exchange"].Messages.Count,Is.EqualTo(1));
}
public void SendToExchangeOnly()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string message = "hello world!";
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange: "my_exchange", routingKey: null, mandatory: false, basicProperties: null, body: messageBody);
}
Assert.Single(rabbitServer.Exchanges["my_exchange"].Messages);
}
public void ExecuteFullTest()
{
var operation = GetBasicAddQueueOperation()
.SetMessageTimeToLive(5000)
.SetAutoExpire(15000)
.SetMaxLength(10000)
.SetMaxLengthBytes(10000)
.SetOverflowBehaviour("drop-head")
.SetDeadLetterExchange("foo")
.SetDeadLetterRoutingKey("bla")
.SetMaxPriority(10)
.SetLazyMode()
.SetMasterLocation("server123");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
operation.Execute(connection, string.Empty);
}
Assert.AreEqual(1, server.Queues.Count);
var queue = server.Queues.Values.First();
Assert.AreEqual(10, queue.Arguments.Count);
Assert.IsTrue(queue.Arguments.ContainsKey("x-message-ttl"));
Assert.AreEqual(5000, queue.Arguments["x-message-ttl"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-expires"));
Assert.AreEqual(15000, queue.Arguments["x-expires"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-max-length"));
Assert.AreEqual(10000, queue.Arguments["x-max-length"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-max-length-bytes"));
Assert.AreEqual(10000, queue.Arguments["x-max-length-bytes"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-overflow"));
Assert.AreEqual("drop-head", queue.Arguments["x-overflow"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-dead-letter-exchange"));
Assert.AreEqual("foo", queue.Arguments["x-dead-letter-exchange"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-dead-letter-routing-key"));
Assert.AreEqual("bla", queue.Arguments["x-dead-letter-routing-key"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-max-priority"));
Assert.AreEqual(10, queue.Arguments["x-max-priority"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-queue-mode"));
Assert.AreEqual("lazy", queue.Arguments["x-queue-mode"]);
Assert.IsTrue(queue.Arguments.ContainsKey("x-queue-master-locator"));
Assert.AreEqual("server123", queue.Arguments["x-queue-master-locator"]);
}
public void SendMessageTest(string message, int expected)
{
var rabbitServer = GetConfiguredTestRabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
ConfigureQueueBinding(rabbitServer, queueName);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: false, basicProperties: null, body: messageBody);
}
int actual = rabbitServer.Queues["iq-assessment"].Messages.Count;
Assert.Equal(actual, expected);
}
public void SendToExchangeWithBoundQueue()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
ConfigureQueueBinding(rabbitServer, "my_exchange", "some_queue");
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string message = "hello world!";
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish(exchange: "my_exchange", routingKey: null, mandatory: false, basicProperties: null, body: messageBody);
}
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1));
}
public void ExecuteTest()
{
var addBarQueueOperation = new AddQueueOperation()
.SetName("bar");
var addFooExchangeOperation = new AddExchangeOperation()
.SetName("foo");
var addTstQueueOperation = new AddQueueOperation()
.SetName("tst")
.AddQueueBind("foo", "bar");
var moveDataOperation = new MoveDataToExchangeOperation()
.SetSourceQueueName("bar")
.SetDestinationExchangeName("foo");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
addBarQueueOperation.Execute(connection, string.Empty);
addFooExchangeOperation.Execute(connection, string.Empty);
addTstQueueOperation.Execute(connection, string.Empty);
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare("", ExchangeType.Direct, true);
channel.QueueBind("bar", "", "bar", null);
for (int i = 0; i < 10; i++)
{
var props = channel.CreateBasicProperties();
props.Headers = new Dictionary <string, object>();
channel.BasicPublish("", "bar", false, props, Encoding.UTF8.GetBytes($"message{i}"));
}
}
Assert.AreEqual(10, server.Queues.Values.First(x => x.Name == "bar").Messages.Count);
Assert.AreEqual(0, server.Queues.Values.First(x => x.Name == "tst").Messages.Count);
moveDataOperation.Execute(connection, string.Empty);
Assert.AreEqual(0, server.Queues.Values.First(x => x.Name == "bar").Messages.Count);
Assert.AreEqual(10, server.Queues.Values.First(x => x.Name == "tst").Messages.Count);
}
}
public void ExecuteTest()
{
var addOperation = new AddQueueOperation()
.SetName("bar");
var delOperation = new DeleteQueueOperation()
.SetName("bar");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
addOperation.Execute(connection, string.Empty);
delOperation.Execute(connection, string.Empty);
}
Assert.AreEqual(0, server.Queues.Count);
}
public void ExecuteFullTest()
{
var operation = GetBasicAddExchangeOperation()
.SetAlternativeExchange("foo");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
operation.Execute(connection, string.Empty);
}
Assert.AreEqual(1, server.Exchanges.Count);
var exchange = server.Exchanges.Values.First();
Assert.AreEqual(1, exchange.Arguments.Count);
Assert.IsTrue(exchange.Arguments.Contains("alternate-exchange"));
Assert.AreEqual("foo", exchange.Arguments["alternate-exchange"]);
}
public void ReceiveMessagesOnQueue_AutoAckEnabled()
{
var rabbitServer = new RabbitServer();
ConfigureQueueBinding(rabbitServer, "my_exchange", "my_queue");
SendMessage(rabbitServer, "my_exchange", "hello_world");
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
// First message
var message = channel.BasicGet("my_queue", autoAck: true);
Assert.That(message, Is.Not.Null);
Assert.That(rabbitServer.Queues["my_queue"].Messages.Count == 0);
}
}
public void ConsumeMessageTest(string producerMessage)
{
string expectedResponseMessage = string.Empty;
string actualResponseMessage = string.Empty;
string name;
var rabbitServer = GetConfiguredTestRabbitServer();
SendMessage(rabbitServer, producerMessage);
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using var connection = connectionFactory.CreateConnection();
using var channel = connection.CreateModel();
var consumer = new MessageConsumer(mockConsumerLogger.Object)
{
SettingsDictionary = new Dictionary <string, string>
{
["ProducerMessagePrefix"] = producerMessagePrefix
}
};
var received = channel.BasicGet(queueName, autoAck: true);
var messageBody = Encoding.ASCII.GetString(received.Body.ToArray());
if (consumer.IsValidMessage(messageBody, out name))
{
actualResponseMessage = consumer.BuildResponseMessage(consumerMessagePrefix, name);
expectedResponseMessage = string.Format(consumerMessagePrefix, name);
}
int expectedMessageCount = 0;
int actualMessageCount = rabbitServer.Queues[queueName].Messages.Count;
Assert.NotNull(producerMessage);
Assert.NotNull(actualResponseMessage);
Assert.NotNull(expectedResponseMessage);
Assert.Equal(expectedMessageCount, actualMessageCount);
Assert.Equal(expectedResponseMessage, actualResponseMessage);
}
public void ExecuteFullTest()
{
var exchangeOperation = new AddExchangeOperation()
.SetName("foo")
.SetType(ExchangeType.Topic);
var operation = new AddQueueOperation()
.SetName("bar")
.SetAutoDelete()
.SetDurable(true)
.SetExclusive()
.AddArgument("foo", "foo-bar")
.AddQueueBind("foo", "#");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
exchangeOperation.Execute(connection, string.Empty);
operation.Execute(connection, string.Empty);
}
Assert.AreEqual(1, server.Queues.Count);
var queue = server.Queues.Values.First();
Assert.AreEqual("bar", queue.Name);
Assert.IsTrue(queue.IsAutoDelete);
Assert.IsTrue(queue.IsDurable);
Assert.IsTrue(queue.IsExclusive);
Assert.AreEqual(1, queue.Arguments.Count);
Assert.IsTrue(queue.Arguments.ContainsKey("foo"));
Assert.AreEqual("foo-bar", queue.Arguments["foo"]);
Assert.AreEqual(1, queue.Bindings.Count);
var binding = queue.Bindings.First();
Assert.AreEqual("foo", binding.Value.Exchange.Name);
Assert.AreEqual("bar", binding.Value.Queue.Name);
Assert.AreEqual("#", binding.Value.RoutingKey);
}
public void TestRevertMigrations()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare("UnitTest.foo", ExchangeType.Direct, true);
channel.QueueDeclare("UnitTest.bar", true);
}
var history = new Mock <IRabbitMqHistory>();
history.Setup(x => x.GetAppliedMigrations(It.IsAny <string>())).Returns <string>(prefix =>
new MigrationHistoryRow
{
Prefix = prefix,
AppliedMigrations = new List <MigrationHistoryRowDetails> {
new MigrationHistoryRowDetails {
Name = "001_TestMigration"
}
}
});
MigrationHistoryRow result = null;
history.Setup(x => x.UpdateAppliedMigrations(It.IsAny <MigrationHistoryRow>()))
.Callback <MigrationHistoryRow>(x => result = x);
var migrator = new RabbitMqMigrator(connectionFactory, history.Object);
migrator.RevertAll("UnitTest");
Assert.AreEqual(0, rabbitServer.Exchanges.Count);
Assert.AreEqual(0, rabbitServer.Queues.Count);
Assert.IsNotNull(result);
Assert.AreEqual(0, result.AppliedMigrations.Count);
}
public void ExecuteMinimalTest()
{
var operation = new AddQueueOperation()
.SetName("bar");
var server = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(server);
using (var connection = connectionFactory.CreateConnection())
{
operation.Execute(connection, string.Empty);
}
Assert.AreEqual(1, server.Queues.Count);
var queue = server.Queues.Values.First();
Assert.AreEqual("bar", queue.Name);
Assert.IsFalse(queue.IsAutoDelete);
Assert.IsFalse(queue.IsDurable);
Assert.IsFalse(queue.IsExclusive);
Assert.AreEqual(0, queue.Arguments.Count);
Assert.AreEqual(0, queue.Bindings.Count);
}
public void RabbitMQ_ReceiveMessage()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
using (var connection = connectionFactory.CreateConnection())
{
var helper = new RabbitMQHelper(connection, "test_exchange");
var message = Encoding.UTF8.GetBytes("bob");
helper.PushMessageIntoQueue(message, "my_queue");
// First message
var response = helper.ReadMessageFromQueue("my_queue");
response.Should().NotBeNull();
var messageBody = Encoding.UTF8.GetString(message);
messageBody.Should().Be("bob");
}
}
public void SendingAndGettingMultipleMessages()
{
var rabbitServer = new RabbitServer();
var connectionFactory = new FakeConnectionFactory(rabbitServer);
ConfigureQueueBinding(rabbitServer, "my_exchange", "some_queue");
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
const string message = "hello world!";
var messageBody = Encoding.ASCII.GetBytes(message);
channel.BasicPublish("my_exchange", null, false, channel.CreateBasicProperties(), messageBody);
channel.BasicPublish("my_exchange", null, false, channel.CreateBasicProperties(), messageBody);
var result = channel.BasicGet("some_queue", false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(2));
channel.BasicAck(result.DeliveryTag, false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1));
result = channel.BasicGet("some_queue", false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(1));
channel.BasicAck(result.DeliveryTag, false);
Assert.That(rabbitServer.Queues["some_queue"].Messages.Count, Is.EqualTo(0));
}
}
