/// <summary> /// Creates the connection factory. /// </summary> /// <returns>The connection factory.</returns> protected override IConnectionFactory CreateConnectionFactory() { var connectionFactory = new SingleConnectionFactory(); connectionFactory.Port = BrokerTestUtils.GetPort(); return(connectionFactory); }
public void TestEvaluateDirectReplyToWithIOExceptionDeclareFailed() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var mockConnection = new Mock <RC.IConnection>(); var mockChannel = new Mock <RC.IModel>(); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())).Returns(mockConnection.Object); mockConnection.Setup((c) => c.IsOpen).Returns(true); mockConnection.Setup((c) => c.CreateModel()).Returns(mockChannel.Object); mockChannel.Setup((c) => c.IsOpen).Returns(true); mockChannel.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); mockChannel.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)); mockChannel.Setup((c) => c.QueueDeclarePassive(Address.AMQ_RABBITMQ_REPLY_TO)).Throws(new ShutdownSignalException(new RC.ShutdownEventArgs(RC.ShutdownInitiator.Peer, RabbitUtils.NotFound, string.Empty, RabbitUtils.Queue_ClassId, RabbitUtils.Declare_MethodId))); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { ReplyTimeout = 1 }; template.ConvertSendAndReceive <object>("foo"); Assert.True(template._evaluatedFastReplyTo); Assert.False(template._usingFastReplyTo); }
public void DontHangConsumerThread() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var mockConnection = new Mock <RC.IConnection>(); var mockChannel = new Mock <RC.IModel>(); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())).Returns(mockConnection.Object); mockConnection.Setup((c) => c.IsOpen).Returns(true); mockConnection.Setup((c) => c.CreateModel()).Returns(mockChannel.Object); mockChannel.Setup((c) => c.IsOpen).Returns(true); mockChannel.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); var consumer = new AtomicReference <RC.IBasicConsumer>(); mockChannel.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)); mockChannel.Setup((c) => c.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <RC.IBasicConsumer>())) .Callback <string, bool, string, bool, bool, IDictionary <string, object>, RC.IBasicConsumer>((arg1, arg2, arg3, arg4, arg5, arg6, arg7) => consumer.Value = arg7); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { ReplyTimeout = 1 }; var payload = EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!"); var input = Message.Create(payload, new MessageHeaders()); template.DoSendAndReceiveWithTemporary("foo", "bar", input, null, default); // used to hang here because of the SynchronousQueue and doSendAndReceive() already exited consumer.Value.HandleBasicDeliver("foo", 1ul, false, "foo", "bar", new MockRabbitBasicProperties(), new byte[0]); }
public void TestRetry() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var count = new AtomicInteger(); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())) .Callback(() => count.IncrementAndGet()) .Throws(new AuthenticationFailureException("foo")); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { RetryTemplate = new PollyRetryTemplate(new Dictionary <Type, bool>(), 3, true, 1, 1, 1) }; try { template.ConvertAndSend("foo", "bar", "baz"); } catch (RabbitAuthenticationException e) { Assert.Contains("foo", e.InnerException.Message); } Assert.Equal(3, count.Value); }
public void TestShutdownWhileWaitingForReply() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var mockConnection = new Mock <RC.IConnection>(); var mockChannel1 = new Mock <RC.IModel>(); mockChannel1.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); mockChannel1.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 listener = new AtomicReference <EventHandler <RC.ShutdownEventArgs> >(); var shutdownLatch = new CountdownEvent(1); mockChannel1.SetupAdd((m) => m.ModelShutdown += It.IsAny <EventHandler <RC.ShutdownEventArgs> >()) .Callback <EventHandler <RC.ShutdownEventArgs> >((handler) => { listener.Value = handler; shutdownLatch.Signal(); }); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { ReplyTimeout = 60_000 }; var input = Message.Create(EncodingUtils.GetDefaultEncoding().GetBytes("Hello, world!"), new MessageHeaders()); Task.Run(() => { try { shutdownLatch.Wait(TimeSpan.FromSeconds(10)); } catch (Exception) { // Ignore } listener.Value.Invoke(null, new RC.ShutdownEventArgs(RC.ShutdownInitiator.Peer, (ushort)RabbitUtils.NotFound, string.Empty)); }); try { template.DoSendAndReceiveWithTemporary("foo", "bar", input, null, default); throw new Exception("Expected exception"); } catch (RabbitException e) { var cause = e.InnerException; Assert.IsType <ShutdownSignalException>(cause); } }
public void TestNoFailOnStartupWithMissingBroker() { var connectionFactory = new SingleConnectionFactory("foo"); connectionFactory.Port = 434343; var applicationContext = new GenericApplicationContext(); applicationContext.ObjectFactory.RegisterSingleton("foo", new Queue("queue")); var rabbitAdmin = new RabbitAdmin(connectionFactory); rabbitAdmin.ApplicationContext = applicationContext; rabbitAdmin.AutoStartup = true; rabbitAdmin.AfterPropertiesSet(); }
public void TestGetQueues() { AbstractConnectionFactory connectionFactory = new SingleConnectionFactory(); connectionFactory.Port = BrokerTestUtils.GetAdminPort(); Queue queue = new RabbitAdmin(connectionFactory).DeclareQueue(); Assert.AreEqual("/", connectionFactory.VirtualHost); List <QueueInfo> queues = this.brokerAdmin.GetQueues(); Assert.AreEqual(queue.Name, queues[0].Name); }
public void TestSendAndReceiveTransactedWithUncachedConnection() { var singleConnectionFactory = new SingleConnectionFactory("localhost"); var template = new RabbitTemplate(singleConnectionFactory) { IsChannelTransacted = true }; template.ConvertAndSend(ROUTE, "message"); var result = template.ReceiveAndConvert <string>(ROUTE); Assert.Equal("message", result); result = template.ReceiveAndConvert <string>(ROUTE); Assert.Null(result); singleConnectionFactory.Destroy(); }
public void TestNoFailOnStartupWithMissingBroker() { var serviceCollection = new ServiceCollection(); serviceCollection.AddRabbitQueue(new Config.Queue("foo")); var connectionFactory = new SingleConnectionFactory("foo") { Port = 434343 }; var applicationContext = GetApplicationContext(serviceCollection); var rabbitAdmin = new RabbitAdmin(applicationContext, connectionFactory) { AutoStartup = true }; connectionFactory.Destroy(); }
public void OtpTemplate() { var selfNodeName = "rabbit-monitor"; var peerNodeName = NODE_NAME; var cf = new SingleConnectionFactory(selfNodeName, peerNodeName); cf.AfterPropertiesSet(); var template = new ErlangTemplate(cf); template.AfterPropertiesSet(); var number = (long)template.ExecuteAndConvertRpc("erlang", "abs", -161803399); Assert.AreEqual(161803399, number); cf.Dispose(); }
public void TestFailOnFirstUseWithMissingBroker() { var serviceCollection = new ServiceCollection(); serviceCollection.AddRabbitQueue(new Config.Queue("foo")); var connectionFactory = new SingleConnectionFactory("localhost") { Port = 434343 }; var applicationContext = GetApplicationContext(serviceCollection); var rabbitAdmin = new RabbitAdmin(applicationContext, connectionFactory) { AutoStartup = true }; Assert.Throws <AmqpConnectException>(() => rabbitAdmin.DeclareQueue()); connectionFactory.Destroy(); }
public void TestTemporaryLogs() { var serviceCollection = new ServiceCollection(); 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)); var connectionFactory = new SingleConnectionFactory("localhost"); var applicationContext = GetApplicationContext(serviceCollection); 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 async Task TestGetQueueProperties() { var serviceCollection = new ServiceCollection(); var connectionFactory = new SingleConnectionFactory("localhost"); var applicationContext = GetApplicationContext(serviceCollection); 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 DefaultBasicConsumer(channel); channel.BasicConsume(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(); } }
/// <summary>Mains the specified args.</summary> /// <param name="args">The args.</param> public static void Main(string[] args) { var connectionFactory = new SingleConnectionFactory("localhost"); connectionFactory.UserName = "******"; connectionFactory.Password = "******"; var template = new RabbitTemplate(); template.ConnectionFactory = connectionFactory; template.ChannelTransacted = true; template.AfterPropertiesSet(); var routingKey = TestConstants.ROUTING_KEY; QueueUtils.DeclareTestQueue(template, routingKey); // Send message SendMessages(template, TestConstants.EXCHANGE_NAME, routingKey, TestConstants.NUM_MESSAGES); }
public void TestFailOnFirstUseWithMissingBroker() { var connectionFactory = new SingleConnectionFactory("foo"); connectionFactory.Port = 434343; var applicationContext = new GenericApplicationContext(); applicationContext.ObjectFactory.RegisterSingleton("foo", new Queue("queue")); var rabbitAdmin = new RabbitAdmin(connectionFactory); rabbitAdmin.ApplicationContext = applicationContext; rabbitAdmin.AutoStartup = true; rabbitAdmin.AfterPropertiesSet(); try { rabbitAdmin.DeclareQueue(); } catch (Exception ex) { Assert.True(ex is AmqpIOException, "Expecting an AmqpIOException"); } }
public void TestRecovery() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var count = new AtomicInteger(); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())) .Callback(() => count.IncrementAndGet()) .Throws(new AuthenticationFailureException("foo")); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { RetryTemplate = new PollyRetryTemplate(new Dictionary <Type, bool>(), 3, true, 1, 1, 1) }; var recoverInvoked = new AtomicBoolean(); template.RecoveryCallback = new TestRecoveryRecoveryCallback(recoverInvoked); template.ConvertAndSend("foo", "bar", "baz"); Assert.Equal(3, count.Value); Assert.True(recoverInvoked.Value); }
public void TestEvaluateDirectReplyToOK() { var mockConnectionFactory = new Mock <RC.IConnectionFactory>(); var mockConnection = new Mock <RC.IConnection>(); var mockChannel = new Mock <RC.IModel>(); mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>())).Returns(mockConnection.Object); mockConnection.Setup((c) => c.IsOpen).Returns(true); mockConnection.Setup((c) => c.CreateModel()).Returns(mockChannel.Object); mockChannel.Setup((c) => c.IsOpen).Returns(true); mockChannel.Setup((c) => c.CreateBasicProperties()).Returns(new MockRabbitBasicProperties()); mockChannel.Setup((c) => c.QueueDeclarePassive(Address.AMQ_RABBITMQ_REPLY_TO)) .Returns(() => new RC.QueueDeclareOk(Address.AMQ_RABBITMQ_REPLY_TO, 0, 0)); var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); var template = new RabbitTemplate(connectionFactory) { ReplyTimeout = 1 }; template.ConvertSendAndReceive <object>("foo"); Assert.True(template._evaluatedFastReplyTo); Assert.True(template._usingFastReplyTo); }
public void SessionCallbackWithinSynchronizedTransaction() { SingleConnectionFactory scf = new SingleConnectionFactory(mockConnectionFactory); NmsTemplate template = CreateTemplate(); template.ConnectionFactory = scf; mockConnection.Start(); LastCall.On(mockConnection).Repeat.Times(2); // We're gonna call getTransacted 3 times, i.e. 2 more times. Expect.Call(mockSession.Transacted).Return(UseTransactedSession).Repeat.Twice(); if (UseTransactedTemplate) { mockSession.Commit(); LastCall.On(mockSession).Repeat.Once(); } mockSession.Close(); LastCall.On(mockSession).Repeat.Once(); mockConnection.Stop(); LastCall.On(mockConnection).Repeat.Once(); mockConnection.Close(); LastCall.On(mockConnection).Repeat.Once(); mocks.ReplayAll(); TransactionSynchronizationManager.InitSynchronization(); try { template.Execute(session => { bool b = session.Transacted; return(null); }); template.Execute(session => { bool b = session.Transacted; return(null); }); Assert.AreSame(mockSession, ConnectionFactoryUtils.GetTransactionalSession(scf, null, false)); Assert.AreSame(mockSession, ConnectionFactoryUtils.GetTransactionalSession(scf, scf.CreateConnection(), false)); //In Java this test was doing 'double-duty' and testing TransactionAwareConnectionFactoryProxy, which has //not been implemented in .NET template.Execute(session => { bool b = session.Transacted; return(null); }); IList synchs = TransactionSynchronizationManager.Synchronizations; Assert.AreEqual(1, synchs.Count); ITransactionSynchronization synch = (ITransactionSynchronization)synchs[0]; synch.BeforeCommit(false); synch.BeforeCompletion(); synch.AfterCommit(); synch.AfterCompletion(TransactionSynchronizationStatus.Unknown); } finally { TransactionSynchronizationManager.ClearSynchronization(); //Assert.IsTrue(TransactionSynchronizationManager.ResourceDictionary.Count == 0); //Assert.IsFalse(TransactionSynchronizationManager.SynchronizationActive); scf.Dispose(); } Assert.IsTrue(TransactionSynchronizationManager.ResourceDictionary.Count == 0); mocks.VerifyAll(); }
public void TestChannelAwareMessageListenerDontExpose() { var mockConnectionFactory = new Mock <ConnectionFactory>(); var mockConnection = new Mock <IConnection>(); var onlyChannel = new Mock <IModel>(); onlyChannel.Setup(m => m.IsOpen).Returns(true); onlyChannel.Setup(m => m.CreateBasicProperties()).Returns(() => new BasicProperties()); var singleConnectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); mockConnectionFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(m => m.IsOpen).Returns(true); var tooManyChannels = new AtomicReference <Exception>(); var done = false; mockConnection.Setup(m => m.CreateModel()).Returns( () => { if (!done) { done = true; return(onlyChannel.Object); } tooManyChannels.LazySet(new Exception("More than one channel requested")); var internalChannel = new Mock <IModel>(); internalChannel.Setup(m => m.IsOpen).Returns(true); return(internalChannel.Object); }); var consumer = new BlockingCollection <IBasicConsumer>(1); onlyChannel.Setup(m => m.BasicConsume(It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <IBasicConsumer>())).Callback <string, bool, IBasicConsumer>( (a1, a2, a3) => consumer.Add(a3)); var commitLatch = new CountdownEvent(1); onlyChannel.Setup(m => m.TxCommit()).Callback( () => { if (commitLatch.CurrentCount > 0) { commitLatch.Signal(); } }); var latch = new CountdownEvent(1); var exposed = new AtomicReference <IModel>(); var container = new SimpleMessageListenerContainer(singleConnectionFactory); var mockListener = new Mock <IChannelAwareMessageListener>(); mockListener.Setup(m => m.OnMessage(It.IsAny <Message>(), It.IsAny <IModel>())).Callback <Message, IModel>( (message, channel) => { exposed.LazySet(channel); var rabbitTemplate = new RabbitTemplate(singleConnectionFactory); rabbitTemplate.ChannelTransacted = true; // should use same channel as container rabbitTemplate.ConvertAndSend("foo", "bar", "baz"); if (latch.CurrentCount > 0) { latch.Signal(); } }); container.MessageListener = mockListener.Object; container.QueueNames = new[] { "queue" }; container.ChannelTransacted = true; container.ExposeListenerChannel = false; container.ShutdownTimeout = 100; container.TransactionManager = DummyTxManager.Instance(); container.AfterPropertiesSet(); container.Start(); IBasicConsumer currentConsumer; consumer.TryTake(out currentConsumer, this.timeout); Assert.IsNotNull(currentConsumer, "Timed out getting consumer."); currentConsumer.HandleBasicDeliver("qux", 1, false, "foo", "bar", new BasicProperties(), new byte[] { 0 }); Assert.IsTrue(latch.Wait(new TimeSpan(0, 0, 10))); var e = tooManyChannels.Value; if (e != null) { throw e; } mockConnection.Verify(m => m.CreateModel(), Times.Once()); Assert.IsTrue(commitLatch.Wait(new TimeSpan(0, 0, 10))); onlyChannel.Verify(m => m.TxCommit(), Times.Once()); onlyChannel.Verify(m => m.BasicPublish(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <IBasicProperties>(), It.IsAny <byte[]>()), Times.Once()); // verify close() was never called on the channel onlyChannel.Verify(m => m.Close(), Times.Never()); container.Stop(); container.Dispose(); container = null; Assert.AreSame(onlyChannel.Object, exposed.Value); }
public SharedConnectionProxy(SingleConnectionFactory factory, IConnection target, ILogger logger = null) { _logger = logger; _factory = factory; Target = target; }
/// <summary>Initializes a new instance of the <see cref="SharedConnectionProxy"/> class.</summary> /// <param name="target">The target.</param> /// <param name="outer">The outer.</param> public SharedConnectionProxy(IConnection target, SingleConnectionFactory outer) { this.target = target; this.outer = outer; }
/// <summary> /// Creates the connection factory. /// </summary> /// <returns>The connection factory.</returns> protected override IConnectionFactory CreateConnectionFactory() { var connectionFactory = new SingleConnectionFactory(); connectionFactory.Port = BrokerTestUtils.GetPort(); return connectionFactory; }
public void TestChannelAwareMessageListener() { var mockConnectionFactory = new Mock<ConnectionFactory>(); var mockConnection = new Mock<IConnection>(); var onlyChannel = new Mock<IModel>(); onlyChannel.Setup(m => m.IsOpen).Returns(true); onlyChannel.Setup(m => m.CreateBasicProperties()).Returns(() => new BasicProperties()); var singleConnectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); mockConnectionFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(m => m.IsOpen).Returns(true); var tooManyChannels = new AtomicReference<Exception>(); var done = false; mockConnection.Setup(m => m.CreateModel()).Returns( () => { if (!done) { done = true; return onlyChannel.Object; } tooManyChannels.LazySet(new Exception("More than one channel requested")); var internalChannel = new Mock<IModel>(); internalChannel.Setup(m => m.IsOpen).Returns(true); return internalChannel.Object; }); var consumer = new BlockingCollection<IBasicConsumer>(1); onlyChannel.Setup(m => m.BasicConsume(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<IBasicConsumer>())).Callback<string, bool, IBasicConsumer>( (a1, a2, a3) => consumer.Add(a3)); var commitLatch = new CountdownEvent(1); onlyChannel.Setup(m => m.TxCommit()).Callback( () => { if (commitLatch.CurrentCount > 0) { commitLatch.Signal(); } }); var latch = new CountdownEvent(1); var exposed = new AtomicReference<IModel>(); var container = new SimpleMessageListenerContainer(singleConnectionFactory); var mockListener = new Mock<IChannelAwareMessageListener>(); mockListener.Setup(m => m.OnMessage(It.IsAny<Message>(), It.IsAny<IModel>())).Callback<Message, IModel>( (message, channel) => { exposed.LazySet(channel); var rabbitTemplate = new RabbitTemplate(singleConnectionFactory); rabbitTemplate.ChannelTransacted = true; // should use same channel as container rabbitTemplate.ConvertAndSend("foo", "bar", "baz"); if (latch.CurrentCount > 0) { latch.Signal(); } }); container.MessageListener = mockListener.Object; container.QueueNames = new[] { "queue" }; container.ChannelTransacted = true; container.ShutdownTimeout = 100; container.TransactionManager = DummyTxManager.Instance(); container.AfterPropertiesSet(); container.Start(); IBasicConsumer currentConsumer; consumer.TryTake(out currentConsumer, this.timeout); Assert.IsNotNull(currentConsumer, "Timed out getting consumer."); currentConsumer.HandleBasicDeliver("qux", 1, false, "foo", "bar", new BasicProperties(), new byte[] { 0 }); Assert.IsTrue(latch.Wait(new TimeSpan(0, 0, 10))); var e = tooManyChannels.Value; if (e != null) { throw e; } mockConnection.Verify(m => m.CreateModel(), Times.Once()); Assert.IsTrue(commitLatch.Wait(new TimeSpan(0, 0, 10))); onlyChannel.Verify(m => m.TxCommit(), Times.Once()); onlyChannel.Verify(m => m.BasicPublish(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<IBasicProperties>(), It.IsAny<byte[]>()), Times.Once()); // verify close() was never called on the channel onlyChannel.Verify(m => m.Close(), Times.Never()); container.Stop(); container.Dispose(); container = null; Assert.AreSame(onlyChannel.Object, exposed.Value); }
public void TestGetQueues() { AbstractConnectionFactory connectionFactory = new SingleConnectionFactory(); connectionFactory.Port = BrokerTestUtils.GetAdminPort(); Queue queue = new RabbitAdmin(connectionFactory).DeclareQueue(); Assert.AreEqual("/", connectionFactory.VirtualHost); List<QueueInfo> queues = this.brokerAdmin.GetQueues(); Assert.AreEqual(queue.Name, queues[0].Name); }
public void TestChannelAwareMessageListenerDontExpose() { var mockConnectionFactory = new Mock<ConnectionFactory>(); var mockConnection = new Mock<IConnection>(); var firstChannel = new Mock<IModel>(); firstChannel.Setup(m => m.IsOpen).Returns(true); firstChannel.Setup(m => m.CreateBasicProperties()).Returns(() => new BasicProperties()); var secondChannel = new Mock<IModel>(); secondChannel.Setup(m => m.IsOpen).Returns(true); secondChannel.Setup(m => m.CreateBasicProperties()).Returns(() => new BasicProperties()); var singleConnectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object); mockConnectionFactory.Setup(m => m.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(m => m.IsOpen).Returns(true); var tooManyChannels = new BlockingCollection<Exception>(1); var done = false; mockConnection.Setup(m => m.CreateModel()).Returns( () => { if (!done) { done = true; return firstChannel.Object; } return secondChannel.Object; }); var consumer = new BlockingCollection<IBasicConsumer>(1); firstChannel.Setup(m => m.BasicConsume(It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<IBasicConsumer>())).Callback<string, bool, IBasicConsumer>( (a1, a2, a3) => consumer.Add(a3)); var commitLatch = new CountdownEvent(1); firstChannel.Setup(m => m.TxCommit()).Callback(() => commitLatch.Signal()); var latch = new CountdownEvent(1); var exposed = new AtomicReference<IModel>(); var container = new SimpleMessageListenerContainer(singleConnectionFactory); var mockListener = new Mock<IChannelAwareMessageListener>(); mockListener.Setup(m => m.OnMessage(It.IsAny<Message>(), It.IsAny<IModel>())).Callback<Message, IModel>( (message, channel) => { exposed.LazySet(channel); var rabbitTemplate = new RabbitTemplate(singleConnectionFactory); rabbitTemplate.ChannelTransacted = true; // should use same channel as container rabbitTemplate.ConvertAndSend("foo", "bar", "baz"); latch.Signal(); }); container.MessageListener = mockListener.Object; container.QueueNames = new[] { "queue" }; container.ChannelTransacted = true; container.ExposeListenerChannel = false; container.ShutdownTimeout = 100; container.AfterPropertiesSet(); container.Start(); IBasicConsumer currentConsumer; consumer.TryTake(out currentConsumer, timeout); Assert.IsNotNull(currentConsumer, "Timed out getting consumer."); currentConsumer.HandleBasicDeliver("qux", 1, false, "foo", "bar", new BasicProperties(), new byte[] { 0 }); Assert.IsTrue(latch.Wait(new TimeSpan(0, 0, 10))); var e = tooManyChannels.Count; if (e > 0) { throw tooManyChannels.Take(); } // once for listener, once for exposed + 0 for template (used bound) mockConnection.Verify(m => m.CreateModel(), Times.Exactly(2)); Assert.IsTrue(commitLatch.Wait(new TimeSpan(0, 0, 10))); firstChannel.Verify(m => m.TxCommit(), Times.Once()); secondChannel.Verify(m => m.TxCommit(), Times.Once()); secondChannel.Verify(m => m.BasicPublish(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<bool>(), It.IsAny<IBasicProperties>(), It.IsAny<byte[]>()), Times.Once()); Assert.AreSame(secondChannel.Object, exposed.Value); firstChannel.Verify(m => m.Close(), Times.Never()); secondChannel.Verify(m => m.Close(), Times.Once()); container.Stop(); }