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