public void TestWithinInvoke()
{
var connectionFactory = new Mock <Connection.IConnectionFactory>();
var connection = new Mock <Connection.IConnection>();
connectionFactory.Setup((f) => f.CreateConnection()).Returns(connection.Object);
var channel1 = new Mock <RC.IModel>();
var channel2 = new Mock <RC.IModel>();
connection.SetupSequence((c) => c.CreateChannel(false)).Returns(channel1.Object).Returns(channel2.Object);
var declareOk = new RC.QueueDeclareOk("foo", 0, 0);
channel1.Setup((c) => c.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >())).Returns(declareOk);
var template = new RabbitTemplate(connectionFactory.Object);
var admin = new RabbitAdmin(template);
template.Invoke <object>((o) =>
{
admin.DeclareQueue();
admin.DeclareQueue();
admin.DeclareQueue();
admin.DeclareQueue();
return(null);
});
connection.Verify((c) => c.CreateChannel(false), Times.Once);
channel1.Verify((c) => c.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()), Times.Exactly(4));
channel1.Verify((c) => c.Close(), Times.Once);
channel2.VerifyNoOtherCalls();
}
public void TestDoubleDeclarationOfExclusiveQueue()
{
services.AddRabbitConnectionFactory("connectionFactory1", (p, f) =>
{
f.Host = "localhost";
});
services.AddRabbitConnectionFactory("connectionFactory2", (p, f) =>
{
f.Host = "localhost";
});
provider = services.BuildServiceProvider();
var queue = new Queue("test.queue", false, true, true);
var rabbitAdmin = provider.GetRabbitAdmin();
rabbitAdmin.DeleteQueue(queue.QueueName);
var context = provider.GetApplicationContext();
var admin1 = new RabbitAdmin(context, context.GetService <IConnectionFactory>("connectionFactory1"));
admin1.DeclareQueue(queue);
try
{
var admin2 = new RabbitAdmin(context, context.GetService <IConnectionFactory>("connectionFactory2"));
Assert.Throws <RabbitIOException>(() => admin2.DeclareQueue(queue));
}
finally
{
var cf1 = context.GetService <IConnectionFactory>("connectionFactory1");
var cf2 = context.GetService <IConnectionFactory>("connectionFactory2");
cf1.Destroy();
cf2.Destroy();
}
}
public void TestDoubleDeclarationOfAutodeleteQueue()
{
services.AddRabbitConnectionFactory("connectionFactory1", (p, f) =>
{
f.Host = "localhost";
});
services.AddRabbitConnectionFactory("connectionFactory2", (p, f) =>
{
f.Host = "localhost";
});
provider = services.BuildServiceProvider();
var queue = new Queue("test.queue", false, false, true);
var context = provider.GetApplicationContext();
var cf1 = context.GetService <IConnectionFactory>("connectionFactory1");
var cf2 = context.GetService <IConnectionFactory>("connectionFactory2");
var admin1 = new RabbitAdmin(context, cf1);
admin1.DeclareQueue(queue);
var admin2 = new RabbitAdmin(context, cf2);
admin2.DeclareQueue(queue);
cf1.Destroy();
cf2.Destroy();
}
private uint MessageCount(RabbitAdmin rabbitAdmin, string queueName)
{
var info = rabbitAdmin.GetQueueInfo(queueName);
Assert.NotNull(info);
return(info.MessageCount);
}
public void TestAddRemove()
{
var queue = new Queue("foo");
var cf = new Mock <IConnectionFactory>();
var admin1 = new RabbitAdmin(cf.Object);
var admin2 = new RabbitAdmin(cf.Object);
queue.SetAdminsThatShouldDeclare(admin1, admin2);
Assert.Equal(2, queue.DeclaringAdmins.Count);
queue.SetAdminsThatShouldDeclare(admin1);
Assert.Single(queue.DeclaringAdmins);
queue.SetAdminsThatShouldDeclare(new object[] { null });
Assert.Empty(queue.DeclaringAdmins);
queue.SetAdminsThatShouldDeclare(admin1, admin2);
Assert.Equal(2, queue.DeclaringAdmins.Count);
queue.SetAdminsThatShouldDeclare();
Assert.Empty(queue.DeclaringAdmins);
queue.SetAdminsThatShouldDeclare(admin1, admin2);
Assert.Equal(2, queue.DeclaringAdmins.Count);
queue.SetAdminsThatShouldDeclare(null);
Assert.Empty(queue.DeclaringAdmins);
queue.SetAdminsThatShouldDeclare(admin1, admin2);
Assert.Equal(2, queue.DeclaringAdmins.Count);
queue.SetAdminsThatShouldDeclare((object[])null);
Assert.Empty(queue.DeclaringAdmins);
Assert.Throws <InvalidOperationException>(() => queue.SetAdminsThatShouldDeclare(null, admin1));
}
public void TestAvoidHangAMQP_508()
{
var cf = new CachingConnectionFactory("localhost");
var admin = new RabbitAdmin(cf);
var bytes = new byte[300];
var longName = Encoding.UTF8.GetString(bytes).Replace('\u0000', 'x');
try
{
admin.DeclareQueue(new Queue(longName));
throw new Exception("expected exception");
}
catch (Exception)
{
// Ignore
}
var goodName = "foobar";
var name = admin.DeclareQueue(new Queue(goodName));
Assert.Null(admin.GetQueueProperties(longName));
Assert.NotNull(admin.GetQueueProperties(goodName));
admin.DeleteQueue(goodName);
cf.Destroy();
}
public void TestSkipBecauseShouldntDeclare()
{
var services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
services.AddLogging(b =>
{
b.AddDebug();
b.AddConsole();
});
services.AddSingleton <IConfiguration>(config);
services.AddRabbitHostingServices();
var cf = new Mock <IConnectionFactory>();
var conn = new Mock <IConnection>();
var channel = new Mock <RC.IModel>();
cf.Setup((f) => f.CreateConnection()).Returns(conn.Object);
cf.SetupGet((f) => f.ServiceName).Returns(CachingConnectionFactory.DEFAULT_SERVICE_NAME);
conn.Setup((c) => c.CreateChannel(false)).Returns(channel.Object);
conn.Setup((c) => c.IsOpen).Returns(true);
channel.Setup((c) => c.IsOpen).Returns(true);
channel.Setup((c) => c.QueueDeclare("foo", It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()))
.Returns(() => new RC.QueueDeclareOk("foo", 0, 0));
var listener = new AtomicReference <IConnectionListener>();
cf.Setup((f) => f.AddConnectionListener(It.IsAny <IConnectionListener>()))
.Callback <IConnectionListener>((l) => listener.Value = l);
var queue = new Queue("foo")
{
ShouldDeclare = false
};
services.AddRabbitQueue(queue);
var exchange = new DirectExchange("bar")
{
ShouldDeclare = false
};
services.AddRabbitExchange(exchange);
var binding = new Binding("baz", "foo", Binding.DestinationType.QUEUE, "bar", "foo", null)
{
ShouldDeclare = false
};
services.AddRabbitBinding(binding);
var provider = services.BuildServiceProvider();
var context = provider.GetApplicationContext();
var admin = new RabbitAdmin(context, cf.Object);
Assert.NotNull(listener.Value);
listener.Value.OnCreate(conn.Object);
channel.Verify(c => c.QueueDeclare("foo", It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()), Times.Never);
channel.Verify(c => c.ExchangeDeclare("bar", "direct", It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()), Times.Never);
channel.Verify(c => c.QueueBind("foo", "bar", "foo", It.IsAny <IDictionary <string, object> >()), Times.Never);
}
public BatchingRabbitTemplateTest(ITestOutputHelper testOutputHelper)
{
connectionFactory = new CachingConnectionFactory("localhost");
var admin = new RabbitAdmin(connectionFactory);
admin.DeclareQueue(new Queue(ROUTE));
this.testOutputHelper = testOutputHelper;
}
public async Task TestMasterLocator()
{
var factory = new RC.ConnectionFactory
{
Uri = new Uri("amqp://*****:*****@localhost:5672/")
};
var cf = new CachingConnectionFactory(factory);
var admin = new RabbitAdmin(cf);
var queue = new AnonymousQueue();
admin.DeclareQueue(queue);
var client = new HttpClient();
var authToken = Encoding.ASCII.GetBytes("guest:guest");
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authToken));
var result = await client.GetAsync("http://localhost:15672/api/queues/%3F/" + queue.QueueName);
var n = 0;
while (n++ < 100 && result.StatusCode == HttpStatusCode.NotFound)
{
await Task.Delay(100);
result = await client.GetAsync("http://localhost:15672/api/queues/%2F/" + queue.QueueName);
}
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
var content = await result.Content.ReadAsStringAsync();
Assert.Contains("x-queue-master-locator", content);
Assert.Contains("client-local", content);
queue = new AnonymousQueue
{
MasterLocator = null
};
admin.DeclareQueue(queue);
result = await client.GetAsync("http://localhost:15672/api/queues/%3F/" + queue.QueueName);
n = 0;
while (n++ < 100 && result.StatusCode == HttpStatusCode.NotFound)
{
await Task.Delay(100);
result = await client.GetAsync("http://localhost:15672/api/queues/%2F/" + queue.QueueName);
}
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
content = await result.Content.ReadAsStringAsync();
Assert.DoesNotContain("x-queue-master-locator", content);
Assert.DoesNotContain("client-local", content);
cf.Destroy();
}
private void CleanQueuesAndExchanges(RabbitAdmin rabbitAdmin)
{
rabbitAdmin.DeleteQueue("testq.nonDur");
rabbitAdmin.DeleteQueue("testq.ad");
rabbitAdmin.DeleteQueue("testq.excl");
rabbitAdmin.DeleteQueue("testq.all");
rabbitAdmin.DeleteExchange("testex.nonDur");
rabbitAdmin.DeleteExchange("testex.ad");
rabbitAdmin.DeleteExchange("testex.all");
}
public void TestNoDeclareWithCachedConnections()
{
var services = new ServiceCollection();
var config = new ConfigurationBuilder().Build();
services.AddLogging(b =>
{
b.AddDebug();
b.AddConsole();
});
services.AddSingleton <IConfiguration>(config);
services.AddRabbitHostingServices();
var mockConnectionFactory = new Mock <RC.IConnectionFactory>();
var mockConnections = new List <RC.IConnection>();
var mockChannels = new List <RC.IModel>();
var connectionNumber = new AtomicInteger(-1);
var channelNumber = new AtomicInteger(-1);
mockConnectionFactory.Setup(f => f.CreateConnection(It.IsAny <string>()))
.Callback(() =>
{
var connection = new Mock <RC.IConnection>();
var connectionNum = connectionNumber.IncrementAndGet();
mockConnections.Add(connection.Object);
connection.Setup(c => c.IsOpen).Returns(true);
connection.Setup(c => c.ToString()).Returns("mockConnection" + connectionNum);
connection.Setup(c => c.CreateModel())
.Callback(() =>
{
var channel = new Mock <RC.IModel>();
mockChannels.Add(channel.Object);
channel.Setup(c => c.IsOpen).Returns(true);
var channelNum = channelNumber.IncrementAndGet();
channel.Setup(c => c.ToString()).Returns("mockChannel" + channelNum);
})
.Returns(() => mockChannels[channelNumber.Value]);
})
.Returns(() => mockConnections[connectionNumber.Value]);
var ccf = new CachingConnectionFactory(mockConnectionFactory.Object, false, CachingConnectionFactory.CachingMode.CONNECTION);
var queue = new Queue("foo");
services.AddRabbitQueue(queue);
var provider = services.BuildServiceProvider();
var context = provider.GetApplicationContext();
var admin = new RabbitAdmin(context, ccf);
ccf.CreateConnection().Close();
ccf.Destroy();
Assert.Empty(mockChannels);
}
public void TestNestedTxBinding()
{
var mockConnectionFactory = new Mock <RC.IConnectionFactory>();
var mockConnection = new Mock <RC.IConnection>();
var mockChannel1 = new Mock <RC.IModel>();
var mockChannel2 = new Mock <RC.IModel>();
mockChannel1.Setup((c) => c.IsOpen).Returns(true);
mockChannel2.Setup((c) => c.IsOpen).Returns(true);
mockConnection.Setup((c) => c.IsOpen).Returns(true);
mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())).Returns(mockConnection.Object);
mockConnection.SetupSequence((c) => c.CreateModel()).Returns(mockChannel1.Object).Returns(mockChannel2.Object);
mockChannel1.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties());
mockChannel2.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties());
mockChannel1.Setup((c) => c.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()))
.Returns(() => new RC.QueueDeclareOk("foo", 0, 0));
var ccf = new CachingConnectionFactory(mockConnectionFactory.Object);
var rabbitTemplate = new RabbitTemplate(ccf)
{
IsChannelTransacted = true
};
var admin = new RabbitAdmin(rabbitTemplate);
var mockContext = new Mock <IApplicationContext>();
mockContext.Setup((c) => c.GetServices <IQueue>()).Returns(new List <IQueue>()
{
new Config.Queue("foo")
});
admin.ApplicationContext = mockContext.Object;
var templateChannel = new AtomicReference <RC.IModel>();
var transTemplate = new TransactionTemplate(new TestTransactionManager());
transTemplate.Execute <bool>((s) =>
{
return(rabbitTemplate.Execute <bool>((c) =>
{
templateChannel.Value = ((IChannelProxy)c).TargetChannel;
return true;
}));
});
mockChannel1.Verify((c) => c.TxSelect());
mockChannel1.Verify((c) => c.QueueDeclare(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >()));
mockChannel1.Verify((c) => c.TxCommit());
Assert.Same(templateChannel.Value, mockChannel1.Object);
}
public async Task TestGetQueueProperties()
{
var serviceCollection = CreateContainer();
serviceCollection.AddRabbitConnectionFactory <SingleConnectionFactory>((p, f) =>
{
f.Host = "localhost";
});
var provider = serviceCollection.BuildServiceProvider();
var applicationContext = provider.GetService <IApplicationContext>();
var connectionFactory = applicationContext.GetService <IConnectionFactory>();
var rabbitAdmin = new RabbitAdmin(applicationContext, connectionFactory);
var queueName = "test.properties." + DateTimeOffset.Now.ToUnixTimeMilliseconds();
try
{
rabbitAdmin.DeclareQueue(new Config.Queue(queueName));
var template = new RabbitTemplate(connectionFactory);
template.ConvertAndSend(queueName, "foo");
var n = 0;
while (n++ < 100 && MessageCount(rabbitAdmin, queueName) == 0)
{
await Task.Delay(100);
}
Assert.True(n < 100);
var channel = connectionFactory.CreateConnection().CreateChannel(false);
var consumer = new RC.DefaultBasicConsumer(channel);
RC.IModelExensions.BasicConsume(channel, queueName, true, consumer);
n = 0;
while (n++ < 100 && MessageCount(rabbitAdmin, queueName) > 0)
{
await Task.Delay(100);
}
Assert.True(n < 100);
var props = rabbitAdmin.GetQueueProperties(queueName);
Assert.True(props.TryGetValue(RabbitAdmin.QUEUE_CONSUMER_COUNT, out var consumerCount));
Assert.Equal(1U, consumerCount);
channel.Close();
}
finally
{
rabbitAdmin.DeleteQueue(queueName);
connectionFactory.Destroy();
}
}
public void TestTemporaryLogs()
{
var serviceCollection = CreateContainer();
serviceCollection.AddRabbitQueue(new Config.Queue("testq.nonDur", false, false, false));
serviceCollection.AddRabbitQueue(new Config.Queue("testq.ad", true, false, true));
serviceCollection.AddRabbitQueue(new Config.Queue("testq.excl", true, true, false));
serviceCollection.AddRabbitQueue(new Config.Queue("testq.all", false, true, true));
serviceCollection.AddRabbitExchange(new Config.DirectExchange("testex.nonDur", false, false));
serviceCollection.AddRabbitExchange(new Config.DirectExchange("testex.ad", true, true));
serviceCollection.AddRabbitExchange(new Config.DirectExchange("testex.all", false, true));
serviceCollection.AddRabbitConnectionFactory <SingleConnectionFactory>((p, f) =>
{
f.Host = "localhost";
});
var provider = serviceCollection.BuildServiceProvider();
var applicationContext = provider.GetService <IApplicationContext>();
var connectionFactory = applicationContext.GetService <IConnectionFactory>();
var logs = new List <string>();
var mockLogger = new Mock <ILogger>();
mockLogger.Setup((l) => l.Log(It.IsAny <LogLevel>(), It.IsAny <EventId>(), It.IsAny <It.IsAnyType>(), It.IsAny <Exception>(), (Func <It.IsAnyType, Exception, string>)It.IsAny <object>()))
.Callback(new InvocationAction(invocation =>
{
logs.Add(invocation.Arguments[2].ToString());
}));
var rabbitAdmin = new RabbitAdmin(applicationContext, connectionFactory, mockLogger.Object);
try
{
connectionFactory.CreateConnection().Close();
logs.Sort();
Assert.NotEmpty(logs);
Assert.Contains("(testex.ad), durable:True, auto-delete:True", logs[0]);
Assert.Contains("(testex.all), durable:False, auto-delete:True", logs[1]);
Assert.Contains("(testex.nonDur), durable:False, auto-delete:False", logs[2]);
Assert.Contains("(testq.ad) durable:True, auto-delete:True, exclusive:False", logs[3]);
Assert.Contains("(testq.all) durable:False, auto-delete:True, exclusive:True", logs[4]);
Assert.Contains("(testq.excl) durable:True, auto-delete:False, exclusive:True", logs[5]);
Assert.Contains("(testq.nonDur) durable:False, auto-delete:False, exclusive:False", logs[6]);
}
finally
{
CleanQueuesAndExchanges(rabbitAdmin);
connectionFactory.Destroy();
}
}
public void TestNoFailOnStartupWithMissingBroker()
{
var serviceCollection = CreateContainer();
serviceCollection.AddRabbitQueue(new Config.Queue("foo"));
serviceCollection.AddRabbitConnectionFactory <SingleConnectionFactory>((p, f) =>
{
f.Host = "foo";
f.Port = 434343;
});
var provider = serviceCollection.BuildServiceProvider();
var applicationContext = provider.GetService <IApplicationContext>();
var connectionFactory = applicationContext.GetService <IConnectionFactory>();
var rabbitAdmin = new RabbitAdmin(applicationContext, connectionFactory)
{
AutoStartup = true
};
connectionFactory.Destroy();
}
public void TestFailOnFirstUseWithMissingBroker()
{
var serviceCollection = CreateContainer();
serviceCollection.AddRabbitQueue(new Config.Queue("foo"));
serviceCollection.AddRabbitConnectionFactory <SingleConnectionFactory>((p, f) =>
{
f.Host = "localhost";
f.Port = 434343;
});
var provider = serviceCollection.BuildServiceProvider();
var applicationContext = provider.GetService <IApplicationContext>();
var connectionFactory = applicationContext.GetService <IConnectionFactory>();
var rabbitAdmin = new RabbitAdmin(applicationContext, connectionFactory)
{
AutoStartup = true
};
Assert.Throws <RabbitConnectException>(() => rabbitAdmin.DeclareQueue());
connectionFactory.Destroy();
}
public void TestIgnoreDeclarationExceptionsTimeout()
{
var rabbitConnectionFactory = new Mock <RC.IConnectionFactory>();
var toBeThrown = new TimeoutException("test");
rabbitConnectionFactory.Setup((c) => c.CreateConnection(It.IsAny <string>())).Throws(toBeThrown);
var ccf = new CachingConnectionFactory(rabbitConnectionFactory.Object);
var admin = new RabbitAdmin(ccf)
{
IgnoreDeclarationExceptions = true
};
admin.DeclareQueue(new AnonymousQueue("test"));
var lastEvent = admin.LastDeclarationExceptionEvent;
Assert.Same(admin, lastEvent.Source);
Assert.Same(toBeThrown, lastEvent.Exception.InnerException);
Assert.IsType <AnonymousQueue>(lastEvent.Declarable);
admin.DeclareQueue();
lastEvent = admin.LastDeclarationExceptionEvent;
Assert.Same(admin, lastEvent.Source);
Assert.Same(toBeThrown, lastEvent.Exception.InnerException);
Assert.Null(lastEvent.Declarable);
admin.DeclareExchange(new DirectExchange("foo"));
lastEvent = admin.LastDeclarationExceptionEvent;
Assert.Same(admin, lastEvent.Source);
Assert.Same(toBeThrown, lastEvent.Exception.InnerException);
Assert.IsType <DirectExchange>(lastEvent.Declarable);
admin.DeclareBinding(new Binding("foo", "foo", DestinationType.QUEUE, "bar", "baz", null));
lastEvent = admin.LastDeclarationExceptionEvent;
Assert.Same(admin, lastEvent.Source);
Assert.Same(toBeThrown, lastEvent.Exception.InnerException);
Assert.IsType <Binding>(lastEvent.Declarable);
}
public void Dispose()
{
var admin = new RabbitAdmin(connectionFactory);
admin.DeleteQueue(ROUTE);
}
