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