public void TestTransactionalLowLevel() { var template = new RabbitTemplate(); var connectionFactory = new CachingConnectionFactory(); connectionFactory.Port = BrokerTestUtils.GetPort(); template.ConnectionFactory = connectionFactory; var blockingQueueConsumer = new BlockingQueueConsumer(connectionFactory, new DefaultMessagePropertiesConverter(), new ActiveObjectCounter<BlockingQueueConsumer>(), AcknowledgeModeUtils.AcknowledgeMode.Auto, true, 1, queue.Name); blockingQueueConsumer.Start(); connectionFactory.Dispose(); // TODO: make this into a proper assertion. An exception can be thrown here by the Rabbit client and printed to // stderr without being rethrown (so hard to make a test fail). blockingQueueConsumer.Stop(); Assert.IsNull(template.ReceiveAndConvert(queue.Name)); }
public void TestWithListener() { var mocker = new AutoMoqer(); var mockConnectionFactory = mocker.GetMock<RabbitMQ.Client.ConnectionFactory>(); var mockConnection = mocker.GetMock<RabbitMQ.Client.IConnection>(); mockConnectionFactory.Setup(c => c.CreateConnection()).Returns(mockConnection.Object); var called = new AtomicInteger(0); var connectionFactory = new CachingConnectionFactory(mockConnectionFactory.Object); var mockConnectionListener = new Mock<IConnectionListener>(); mockConnectionListener.Setup(m => m.OnCreate(It.IsAny<IConnection>())).Callback((IConnection conn) => called.IncrementValueAndReturn()); mockConnectionListener.Setup(m => m.OnClose(It.IsAny<IConnection>())).Callback((IConnection conn) => called.DecrementValueAndReturn()); connectionFactory.ConnectionListeners = new List<IConnectionListener>() { mockConnectionListener.Object }; var con = connectionFactory.CreateConnection(); Assert.AreEqual(1, called.Value); con.Close(); Assert.AreEqual(1, called.Value); mockConnection.Verify(c => c.Close(), Times.Never()); connectionFactory.CreateConnection(); Assert.AreEqual(1, called.Value); connectionFactory.Dispose(); Assert.AreEqual(0, called.Value); mockConnection.Verify(c => c.Close(), Times.AtLeastOnce()); mockConnectionFactory.Verify(c => c.CreateConnection(), Times.Exactly(1)); }
public void TestWithConnectionFactoryDestroy() { var mocker = new AutoMoqer(); var mockConnectionFactory = mocker.GetMock<RabbitMQ.Client.ConnectionFactory>(); var mockConnection = mocker.GetMock<RabbitMQ.Client.IConnection>(); var mockChannel1 = new Mock<IModel>(); var mockChannel2 = new Mock<IModel>(); Assert.AreNotSame(mockChannel1, mockChannel2); mockConnectionFactory.Setup(c => c.CreateConnection()).Returns(mockConnection.Object); mockConnection.Setup(c => c.CreateModel()).ReturnsInOrder(mockChannel1.Object, mockChannel2.Object); mockConnection.Setup(c => c.IsOpen).Returns(true); // Called during physical close mockChannel1.Setup(c => c.IsOpen).Returns(true); mockChannel2.Setup(c => c.IsOpen).Returns(true); var ccf = new CachingConnectionFactory(mockConnectionFactory.Object); ccf.ChannelCacheSize = 2; var con = ccf.CreateConnection(); // This will return a proxy that surpresses calls to close var channel1 = con.CreateChannel(false); var channel2 = con.CreateChannel(false); // Should be ignored, and add last into channel cache. channel1.Close(); channel2.Close(); // remove first entry in cache (channel1) var ch1 = con.CreateChannel(false); // remove first entry in cache (channel2) var ch2 = con.CreateChannel(false); Assert.AreSame(ch1, channel1); Assert.AreSame(ch2, channel2); var target1 = ((IChannelProxy)ch1).GetTargetChannel(); var target2 = ((IChannelProxy)ch2).GetTargetChannel(); // make sure mokito returned different mocks for the channel Assert.AreNotSame(target1, target2); ch1.Close(); ch2.Close(); con.Close(); // should be ignored ccf.Dispose(); // should call close on connection and channels in cache mockConnection.Verify(c => c.CreateModel(), Times.Exactly(2)); mockConnection.Verify(c => c.Close(), Times.Exactly(1)); // verify(mockChannel1).close(); mockChannel2.Verify(c => c.Close(), Times.Exactly(1)); // After destroy we can get a new connection var con1 = ccf.CreateConnection(); Assert.AreNotSame(con, con1); // This will return a proxy that surpresses calls to close var channel3 = con.CreateChannel(false); Assert.AreNotSame(channel3, channel1); Assert.AreNotSame(channel3, channel2); }
/// <summary>The apply.</summary> /// <returns>The System.Boolean.</returns> public bool Apply() { // Check at the beginning, so this can be used as a static field if (this.assumeOnline) { Assume.That(BrokerOnline.Get(this.port)); } else { Assume.That(BrokerOffline.Get(this.port)); } var connectionFactory = new CachingConnectionFactory(); try { connectionFactory.Port = this.port; if (!string.IsNullOrWhiteSpace(this.hostName)) { connectionFactory.Host = this.hostName; } var admin = new RabbitAdmin(connectionFactory); var exchange = new FederatedExchange("fedDirectRuleTest"); exchange.BackingType = "direct"; exchange.UpstreamSet = "upstream-set"; admin.DeclareExchange(exchange); admin.DeleteExchange("fedDirectRuleTest"); BrokerOffline.AddOrUpdate(this.port, false); if (!this.assumeOnline) { Assume.That(BrokerOffline.Get(this.port)); } } catch (Exception e) { Logger.Warn(m => m("Not executing tests because federated connectivity test failed"), e); BrokerOnline.AddOrUpdate(this.port, false); if (this.assumeOnline) { Assume.That(e == null, "An exception occurred."); return false; } } finally { connectionFactory.Dispose(); } return true; // return super.apply(base, method, target); }
public void TestDoubleDeclarationOfExclusiveQueue() { // Expect exception because the queue is locked when it is declared a second time. var connectionFactory1 = new CachingConnectionFactory(); connectionFactory1.Port = BrokerTestUtils.GetPort(); var connectionFactory2 = new CachingConnectionFactory(); connectionFactory2.Port = BrokerTestUtils.GetPort(); var queue = new Queue("test.queue", false, true, true); this.rabbitAdmin.DeleteQueue(queue.Name); new RabbitAdmin(connectionFactory1).DeclareQueue(queue); try { new RabbitAdmin(connectionFactory2).DeclareQueue(queue); } catch (Exception ex) { Assert.True(ex is AmqpIOException, "Expecting an AmqpIOException"); } finally { // Need to release the connection so the exclusive queue is deleted connectionFactory1.Dispose(); } }
public void TestDoubleDeclarationOfAutodeleteQueue() { // No error expected here: the queue is autodeleted when the last consumer is cancelled, but this one never has // any consumers. var connectionFactory1 = new CachingConnectionFactory(); connectionFactory1.Port = BrokerTestUtils.GetPort(); var connectionFactory2 = new CachingConnectionFactory(); connectionFactory2.Port = BrokerTestUtils.GetPort(); var queue = new Queue("test.queue", false, false, true); new RabbitAdmin(connectionFactory1).DeclareQueue(queue); new RabbitAdmin(connectionFactory2).DeclareQueue(queue); connectionFactory1.Dispose(); connectionFactory2.Dispose(); }
/// <summary> /// Applies this instance. /// </summary> /// <returns>Something here.</returns> /// <remarks></remarks> public bool Apply() { // Check at the beginning, so this can be used as a static field if (this.assumeOnline) { Assume.That(brokerOnline[this.port] == true); } else { Assume.That(brokerOffline[this.port] == true); } var connectionFactory = new CachingConnectionFactory(); try { connectionFactory.Port = this.port; if (StringUtils.HasText(this.hostName)) { connectionFactory.Host = this.hostName; } var admin = new RabbitAdmin(connectionFactory); foreach (var queue in this.queues) { var queueName = queue.Name; if (this.purge) { logger.Debug("Deleting queue: " + queueName); // Delete completely - gets rid of consumers and bindings as well admin.DeleteQueue(queueName); } if (this.IsDefaultQueue(queueName)) { // Just for test probe. admin.DeleteQueue(queueName); } else { admin.DeclareQueue(queue); } } if (brokerOffline.ContainsKey(this.port)) { brokerOffline[this.port] = false; } else { brokerOffline.Add(this.port, false); } if (!this.assumeOnline) { Assume.That(brokerOffline[this.port] == true); } } catch (Exception e) { logger.Warn("Not executing tests because basic connectivity test failed", e); if (brokerOnline.ContainsKey(this.port)) { brokerOnline[this.port] = false; } else { brokerOnline.Add(this.port, false); } if (this.assumeOnline) { // Assume.That(!(e is Exception)); } } finally { connectionFactory.Dispose(); } return true; // return base.Apply(base, method, target); }
/// <summary> /// Applies this instance. /// </summary> /// <returns>Something here.</returns> public bool Apply() { // Check at the beginning, so this can be used as a static field if (this.assumeOnline) { Assume.That(brokerOnline[this.port]); } else { Assume.That(brokerOffline[this.port]); } var connectionFactory = new CachingConnectionFactory(); try { connectionFactory.Port = this.port; if (!string.IsNullOrWhiteSpace(this.hostName)) { connectionFactory.Host = this.hostName; } var admin = new RabbitAdmin(connectionFactory); foreach (var queue in this.queues) { var queueName = queue.Name; if (this.purge) { Logger.Debug("Deleting queue: " + queueName); // Delete completely - gets rid of consumers and bindings as well try { admin.DeleteQueue(queueName); } catch (Exception ex) { Logger.Warn("Could not delete queue. Assuming it didn't exist.", ex); } } if (this.IsDefaultQueue(queueName)) { // Just for test probe. try { admin.DeleteQueue(queueName); } catch (Exception ex) { Logger.Warn("Could not delete queue. Assuming it didn't exist.", ex); } } else { admin.DeclareQueue(queue); } } brokerOffline.AddOrUpdate(this.port, false); if (!this.assumeOnline) { Assume.That(brokerOffline[this.port]); } } catch (Exception e) { Logger.Warn("Not executing tests because basic connectivity test failed", e); brokerOnline.AddOrUpdate(this.port, false); if (this.assumeOnline) { return false; // Assume.That(!(e is Exception)); } } finally { connectionFactory.Dispose(); } return true; // return base.Apply(base, method, target); }