public void TestURIForPrefetchHandling(int queuePreFetch, int queueBrowserPrefetch, int topicPrefetch, int durableTopicPrefetch, int maximumPendingMessageLimit)
{
string testuri = string.Format("activemq:tcp://${{activemqhost}}:61616" +
"?nms.PrefetchPolicy.queuePrefetch={0}" +
"&nms.PrefetchPolicy.queueBrowserPrefetch={1}" +
"&nms.PrefetchPolicy.topicPrefetch={2}" +
"&nms.PrefetchPolicy.durableTopicPrefetch={3}" +
"&nms.PrefetchPolicy.maximumPendingMessageLimit={4}",
queuePreFetch, queueBrowserPrefetch, topicPrefetch, durableTopicPrefetch, maximumPendingMessageLimit);
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(testuri));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
Connection amqConnection = connection as Connection;
Assert.AreEqual(queuePreFetch, amqConnection.PrefetchPolicy.QueuePrefetch);
Assert.AreEqual(queueBrowserPrefetch, amqConnection.PrefetchPolicy.QueueBrowserPrefetch);
Assert.AreEqual(topicPrefetch, amqConnection.PrefetchPolicy.TopicPrefetch);
Assert.AreEqual(durableTopicPrefetch, amqConnection.PrefetchPolicy.DurableTopicPrefetch);
Assert.AreEqual(maximumPendingMessageLimit, amqConnection.PrefetchPolicy.MaximumPendingMessageLimit);
connection.Close();
}
}
public void FailoverTransportFailOnProcessingReceivedMessageTest()
{
string uri = "failover:(tcp://${activemqhost}:61616)";
IConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
connection.ConnectionInterruptedListener +=
new ConnectionInterruptedListener(TransportInterrupted);
connection.ConnectionResumedListener +=
new ConnectionResumedListener(TransportResumed);
connection.Start();
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue("Test?consumer.prefetchSize=1");
PurgeQueue(connection, destination);
PutMsgIntoQueue(session, destination);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Listener += OnMessage;
BreakConnection();
WaitForMessagesToArrive();
}
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
}
public void TestConfigureRecoveryPolicyLoggerUsingDefaultLogger(string location, bool autoCreate)
{
string testuri = string.Format("activemq:tcp://${{activemqhost}}:61616" +
"?nms.RecoveryPolicy.RecoveryLogger.Location={0}" +
"&nms.RecoveryPolicy.RecoveryLogger.AutoCreateLocation={1}",
location, autoCreate);
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(testuri));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
NetTxConnection netTxConnection = connection as NetTxConnection;
Assert.IsNotNull(netTxConnection);
NetTxRecoveryPolicy policy = netTxConnection.RecoveryPolicy;
Assert.AreEqual("file", policy.RecoveryLoggerType);
RecoveryFileLogger logger = policy.RecoveryLogger as RecoveryFileLogger;
Assert.IsNotNull(logger);
Assert.AreEqual(location, logger.Location);
Assert.AreEqual(autoCreate, logger.AutoCreateLocation);
}
}
public void TestMaxInactivityDuration()
{
string testuri = "activemq:tcp://${activemqhost}:61616" +
"?wireFormat.maxInactivityDurationInitialDelay=5000" +
"&wireFormat.maxInactivityDuration=10000" +
"&connection.asyncClose=false";
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(testuri));
using (IConnection connection = factory.CreateConnection("", ""))
{
connection.Start();
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IDestination destination = SessionUtil.GetDestination(session, DESTINATION_NAME);
using (IMessageConsumer consumer = session.CreateConsumer(destination))
using (IMessageProducer producer = session.CreateProducer(destination))
{
SendMessage(producer);
IMessage receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.AreEqual(CORRELATION_ID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
// Go inactive...
Thread.Sleep(TimeSpan.FromSeconds(30));
// Send another message.
SendMessage(producer);
receivedMsg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.AreEqual(CORRELATION_ID, receivedMsg.NMSCorrelationID, "Invalid correlation ID.");
}
}
}
}
public async Task TestProducerSendWithExpiry()
{
// Uri uri = new Uri(string.Format("tcp://localhost"));
// Uris uri = new Uri(string.Format("mock://localhost:61616?transport.respondToMessages=false"));
string uri = "tcp://${activemqhost}:61616?transport.useLogging=true";
IConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri));
// ConnectionFactory factory = new ConnectionFactory(uri);
using (IConnection connection = await factory.CreateConnectionAsync())
using (ISession session = await connection.CreateSessionAsync())
{
IDestination destination = await session.GetTopicAsync("Test");
using (IMessageProducer producer = await session.CreateProducerAsync(destination))
{
ITextMessage message = await session.CreateTextMessageAsync("Hello World");
message.NMSTimeToLive = TimeSpan.FromSeconds(175);
await producer.SendAsync(message);
// ITextMessage message2 = await session.CreateTextMessageAsync("Hello World");
// // message2.NMSTimeToLive = TimeSpan.FromSeconds(175);
// await producer.SendAsync(message2);
}
}
}
private void Receive(int numberOfMessages)
{
IConnectionFactory connectionFactory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(BrokerUri));
using (IConnection connection = connectionFactory.CreateConnection())
{
connection.Start();
connection.ConnectionInterruptedListener += OnConnectionInterrupted;
connection.ConnectionResumedListener += OnConnectionResumed;
using (ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge))
{
IQueue queue = session.GetQueue(Queue);
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
for (int i = 0; i < numberOfMessages; i++)
{
IMessage message = consumer.Receive(TimeSpan.FromMilliseconds(5000));
Assert.IsNotNull(message);
Tracer.Debug("Received message.");
received++;
}
}
}
connection.ConnectionInterruptedListener -= OnConnectionInterrupted;
connection.ConnectionResumedListener -= OnConnectionResumed;
}
}
public void FailStartupMaxReconnectAttempts()
{
// Connect to valid machine, but on invalid port that doesn't have a broker listening.
string uri = "failover:(tcp://localhost:31313)?transport.StartupMaxReconnectAttempts=3";
IConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri));
IConnection failConnection = factory.CreateConnection();
try
{
failConnection.Start();
Assert.Fail("Should not have connected to broker.");
}
catch (Apache.NMS.ActiveMQ.ConnectionClosedException)
{
}
finally
{
try
{
failConnection.Stop();
}
catch (Apache.NMS.ActiveMQ.ConnectionClosedException)
{
Assert.Fail("Connection closed exception thrown while closing a connection.");
}
finally
{
failConnection.Dispose();
}
}
}
public void TestConnection()
{
IConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionUri));
using (connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, "queue://TEST.test.in");
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Connection amqConnection = connection as Connection;
connection.ExceptionListener += ConnectionException;
consumer.Listener += OnMessage;
TcpFaultyTransport transport = amqConnection.ITransport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(transport);
transport.OnewayCommandPreProcessor += FailOnKeepAlive;
Thread.Sleep(TimeSpan.FromSeconds(2));
connection.Start();
Assert.IsTrue(exceptionOccuredEvent.WaitOne(TimeSpan.FromSeconds(30 * 3)),
"Exception didnt occured within waiting time");
}
}
}
private void Send(int numberOfMessages)
{
IConnectionFactory connectionFactory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(BrokerUri));
using (IConnection connection = connectionFactory.CreateConnection())
{
connection.Start();
using (ISession session = connection.CreateSession())
{
IQueue queue = session.GetQueue(Queue);
using (IMessageProducer producer = session.CreateProducer(queue))
{
producer.DeliveryMode = MsgDeliveryMode.Persistent;
ITextMessage message = producer.CreateTextMessage(TextMessage);
for (int i = 0; i < numberOfMessages; i++)
{
producer.Send(message);
Tracer.Debug("Sent message.");
sent++;
}
}
}
}
}
public void TestURI(string connectionURI)
{
{
Uri uri = URISupport.CreateCompatibleUri(NMSTestSupport.ReplaceEnvVar(connectionURI));
NetTxConnectionFactory factory = new NetTxConnectionFactory(uri);
Assert.IsNotNull(factory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
using (ISession session = connection.CreateSession())
{
IDestination destination = session.CreateTemporaryTopic();
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.Close();
}
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Close();
}
session.Close();
}
connection.Close();
}
}
{
NetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
Assert.IsNotNull(factory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
using (ISession session = connection.CreateSession())
{
Assert.IsNotNull(session as INetTxSession);
IDestination destination = session.CreateTemporaryTopic();
using (IMessageProducer producer = session.CreateProducer(destination))
{
producer.Close();
}
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
consumer.Close();
}
session.Close();
}
connection.Close();
}
}
}
public async Task TestURI(string connectionURI)
{
{
Uri uri = URISupport.CreateCompatibleUri(NMSTestSupport.ReplaceEnvVar(connectionURI));
ConnectionFactory factory = new ConnectionFactory(uri);
Assert.IsNotNull(factory);
using (IConnection connection = await factory.CreateConnectionAsync("", ""))
{
Assert.IsNotNull(connection);
using (ISession session = await connection.CreateSessionAsync())
{
IDestination destination = await session.CreateTemporaryTopicAsync();
using (IMessageProducer producer = await session.CreateProducerAsync(destination))
{
await producer.CloseAsync();
}
using (IMessageConsumer consumer = await session.CreateConsumerAsync(destination))
{
await consumer.CloseAsync();
}
await session.CloseAsync();
}
await connection.CloseAsync();
}
}
{
ConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
Assert.IsNotNull(factory);
using (IConnection connection = await factory.CreateConnectionAsync("", ""))
{
Assert.IsNotNull(connection);
using (ISession session = await connection.CreateSessionAsync())
{
IDestination destination = await session.CreateTemporaryTopicAsync();
using (IMessageProducer producer = await session.CreateProducerAsync(destination))
{
await producer.CloseAsync();
}
using (IMessageConsumer consumer = await session.CreateConsumerAsync(destination))
{
await consumer.CloseAsync();
}
await session.CloseAsync();
}
await connection.CloseAsync();
}
}
}
public void TestConfigureRecoveryPolicyLoggerTypeWithInvalidType(
[Values("tcp://${activemqhost}:61616?nms.RecoveryPolicy.RecoveryLoggerType=invalid")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (IConnection connection = factory.CreateConnection()){}
}
public void FailoverWithShortLivedProducerTest()
{
string uri = "failover:(tcpfaulty://${activemqhost}:61616?transport.useLogging=true)";
IConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
connection.ConnectionInterruptedListener +=
new ConnectionInterruptedListener(TransportInterrupted);
connection.ConnectionResumedListener +=
new ConnectionResumedListener(TransportResumed);
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
PurgeQueue(connection, destination);
}
Tracer.Debug("Test is putting " + MSG_COUNT + " messages on the queue: " + destinationName);
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
IDestination destination = session.GetQueue(destinationName);
PutMsgIntoQueue(session, destination, false);
tcpFaulty.Close();
PutMsgIntoQueue(session, destination, false);
session.Commit();
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
Tracer.Debug("Test is attempting to read " + MSG_COUNT +
" messages from the queue: " + destinationName);
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
IMessageConsumer consumer = session.CreateConsumer(destination);
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNotNull(msg, "Should receive message[" + (i + 1) + "] after commit failed once.");
}
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
}
public void TestTransactedProduceAndConsume(
[Values("tcp://${activemqhost}:61616")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
connection.Start();
using (INetTxSession session = connection.CreateNetTxSession())
{
IDestination destination = session.CreateTemporaryQueue();
using (IMessageProducer producer = session.CreateProducer(destination))
{
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
Assert.IsNotNull(Transaction.Current);
for (int i = 0; i < MSG_COUNT; ++i)
{
producer.Send(session.CreateTextMessage("Hello World"));
}
scoped.Complete();
}
}
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Thread.Sleep(100);
using (TransactionScope scoped = new TransactionScope(TransactionScopeOption.RequiresNew, TransactionScopeAsyncFlowOption.Enabled))
{
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNotNull(msg, "Message was null for index: " + i);
}
scoped.Complete();
}
}
// No more messages should be in the Q, non rolled back or otherwise.
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Thread.Sleep(100);
IMessage msg = consumer.Receive(TimeSpan.FromMilliseconds(2000));
Assert.IsNull(msg, "Message was not null.");
}
session.Close();
}
connection.Close();
}
}
public void TestURI(string connectionURI)
{
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
}
}
public void TestURIFailures_NMSConnectionException(string connectionURI)
{
Assert.Throws <NMSConnectionException>(() =>
{
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
connection.Close();
}
});
}
public void TestConnectionStarts(string connectionURI)
{
NMS.Tracer.Trace = new NmsConsoleTracer();
IConnectionFactory factory = new ConnectionFactory(
NMSTestSupport.ReplaceEnvVar(connectionURI));
Assert.IsNotNull(factory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
// This should trigger a CONNECT frame and CONNACK response.
connection.Start();
}
}
public void TestURIForRedeliverPolicyHandling()
{
string uri1 = "stomp:tcp://${activemqhost}:61613" +
"?nms.RedeliveryPolicy.BackOffMultiplier=10" +
"&nms.RedeliveryPolicy.InitialRedeliveryDelay=2000" +
"&nms.RedeliveryPolicy.UseExponentialBackOff=true" +
"&nms.RedeliveryPolicy.UseCollisionAvoidance=true" +
"&nms.RedeliveryPolicy.CollisionAvoidancePercent=20";
string uri2 = "stomp:tcp://${activemqhost}:61613" +
"?nms.RedeliveryPolicy.backOffMultiplier=50" +
"&nms.RedeliveryPolicy.initialRedeliveryDelay=4000" +
"&nms.RedeliveryPolicy.useExponentialBackOff=false" +
"&nms.RedeliveryPolicy.useCollisionAvoidance=false" +
"&nms.RedeliveryPolicy.collisionAvoidancePercent=10";
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri1));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
Connection amqConnection = connection as Connection;
Assert.AreEqual(10, amqConnection.RedeliveryPolicy.BackOffMultiplier);
Assert.AreEqual(2000, amqConnection.RedeliveryPolicy.InitialRedeliveryDelay);
Assert.AreEqual(true, amqConnection.RedeliveryPolicy.UseExponentialBackOff);
Assert.AreEqual(true, amqConnection.RedeliveryPolicy.UseCollisionAvoidance);
Assert.AreEqual(20, amqConnection.RedeliveryPolicy.CollisionAvoidancePercent);
}
factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri2));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
Connection amqConnection = connection as Connection;
Assert.AreEqual(50, amqConnection.RedeliveryPolicy.BackOffMultiplier);
Assert.AreEqual(4000, amqConnection.RedeliveryPolicy.InitialRedeliveryDelay);
Assert.AreEqual(false, amqConnection.RedeliveryPolicy.UseExponentialBackOff);
Assert.AreEqual(false, amqConnection.RedeliveryPolicy.UseCollisionAvoidance);
Assert.AreEqual(10, amqConnection.RedeliveryPolicy.CollisionAvoidancePercent);
}
}
public void TestURIForPrefetchHandling()
{
string uri1 = "activemq:tcp://${activemqhost}:61616" +
"?nms.PrefetchPolicy.queuePrefetch=1" +
"&nms.PrefetchPolicy.queueBrowserPrefetch=2" +
"&nms.PrefetchPolicy.topicPrefetch=3" +
"&nms.PrefetchPolicy.durableTopicPrefetch=4" +
"&nms.PrefetchPolicy.maximumPendingMessageLimit=5";
string uri2 = "activemq:tcp://${activemqhost}:61616" +
"?nms.PrefetchPolicy.queuePrefetch=112" +
"&nms.PrefetchPolicy.queueBrowserPrefetch=212" +
"&nms.PrefetchPolicy.topicPrefetch=312" +
"&nms.PrefetchPolicy.durableTopicPrefetch=412" +
"&nms.PrefetchPolicy.maximumPendingMessageLimit=512";
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri1));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
Connection amqConnection = connection as Connection;
Assert.AreEqual(1, amqConnection.PrefetchPolicy.QueuePrefetch);
Assert.AreEqual(2, amqConnection.PrefetchPolicy.QueueBrowserPrefetch);
Assert.AreEqual(3, amqConnection.PrefetchPolicy.TopicPrefetch);
Assert.AreEqual(4, amqConnection.PrefetchPolicy.DurableTopicPrefetch);
Assert.AreEqual(5, amqConnection.PrefetchPolicy.MaximumPendingMessageLimit);
}
factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri2));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
Connection amqConnection = connection as Connection;
Assert.AreEqual(112, amqConnection.PrefetchPolicy.QueuePrefetch);
Assert.AreEqual(212, amqConnection.PrefetchPolicy.QueueBrowserPrefetch);
Assert.AreEqual(312, amqConnection.PrefetchPolicy.TopicPrefetch);
Assert.AreEqual(412, amqConnection.PrefetchPolicy.DurableTopicPrefetch);
Assert.AreEqual(512, amqConnection.PrefetchPolicy.MaximumPendingMessageLimit);
}
}
public void TestConnectionFactoryParseParams(
[Values("tcp://${activemqhost}:61616", "activemq:tcp://${activemqhost}:61616")]
string baseConnectionURI,
[Values(AcknowledgementMode.ClientAcknowledge, AcknowledgementMode.AutoAcknowledge)]
AcknowledgementMode ackMode,
[Values(true, false)]
bool asyncSend,
[Values(true, false)]
bool alwaysSyncSend,
[Values(true, false)]
bool asyncClose,
[Values(true, false)]
bool copyMessageOnSend,
[Values(3000, 1000)]
int requestTimeout,
[Values(true, false)]
bool sendAcksAsync,
[Values(true, false)]
bool dispatchAsync)
{
string connectionURI = string.Format("{0}?" +
"connection.AckMode={1}&" +
"connection.AsyncSend={2}&" +
"connection.AlwaysSyncSend={3}&" +
"connection.AsyncClose={4}&" +
"connection.CopyMessageOnSend={5}&" +
"connection.RequestTimeout={6}&" +
"connection.SendAcksAsync={7}&" +
"connection.DispatchAsync={8}",
baseConnectionURI, ackMode, asyncSend, alwaysSyncSend, asyncClose, copyMessageOnSend, requestTimeout, sendAcksAsync, dispatchAsync);
NetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
using (Connection connection = factory.CreateConnection() as Connection)
{
Assert.AreEqual(ackMode, connection.AcknowledgementMode);
Assert.AreEqual(asyncSend, connection.AsyncSend);
Assert.AreEqual(alwaysSyncSend, connection.AlwaysSyncSend);
Assert.AreEqual(asyncClose, connection.AsyncClose);
Assert.AreEqual(copyMessageOnSend, connection.CopyMessageOnSend);
Assert.AreEqual(requestTimeout, connection.RequestTimeout.TotalMilliseconds);
Assert.AreEqual(sendAcksAsync, connection.SendAcksAsync);
Assert.AreEqual(dispatchAsync, connection.DispatchAsync);
}
}
public void TestInactivityMonitorThreadLeak(
[Values(0, 1000)]
int inactivityDuration)
{
Process currentProcess = Process.GetCurrentProcess();
Tracer.InfoFormat("Beginning thread count: {0}, handle count: {1}", currentProcess.Threads.Count, currentProcess.HandleCount);
string testuri = string.Format("activemq:tcp://${{activemqhost}}:61616?wireFormat.maxInactivityDuration={0}", inactivityDuration);
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(testuri));
// We measure the initial resource counts, and then allow a certain fudge factor for the resources
// to fluctuate at run-time. We allow for a certain amount of fluctuation, but if the counts
// grow outside the safe boundaries of delayed garbage collection, then we fail the test.
currentProcess = Process.GetCurrentProcess();
int beginThreadCount = currentProcess.Threads.Count;
int beginHandleCount = currentProcess.HandleCount;
int maxThreadGrowth = 10;
int maxHandleGrowth = 500;
for (int i = 0; i < 200; i++)
{
using (IConnection connection = factory.CreateConnection("ResourceLeakTest", "Password"))
{
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, "topic://TEST.NMSResourceLeak");
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
connection.Start();
}
}
}
currentProcess = Process.GetCurrentProcess();
int endThreadCount = currentProcess.Threads.Count;
int endHandleCount = currentProcess.HandleCount;
Assert.Less(endThreadCount, beginThreadCount + maxThreadGrowth, string.Format("Thread count grew beyond maximum of {0} on iteration #{1}.", maxThreadGrowth, i));
Assert.Less(endHandleCount, beginHandleCount + maxHandleGrowth, string.Format("Handle count grew beyond maximum of {0} on iteration #{1}.", maxHandleGrowth, i));
}
}
public void TestConnectionFactorySetParams(
[Values("tcp://${activemqhost}:61616", "activemq:tcp://${activemqhost}:61616")]
string connectionURI,
[Values(AcknowledgementMode.ClientAcknowledge, AcknowledgementMode.AutoAcknowledge)]
AcknowledgementMode ackMode,
[Values(true, false)]
bool asyncSend,
[Values(true, false)]
bool alwaysSyncSend,
[Values(true, false)]
bool asyncClose,
[Values(true, false)]
bool copyMessageOnSend,
[Values(3000, 1000)]
int requestTimeout,
[Values(true, false)]
bool sendAcksAsync,
[Values(true, false)]
bool dispatchAsync)
{
NetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
factory.AcknowledgementMode = ackMode;
factory.AsyncSend = asyncSend;
factory.AlwaysSyncSend = alwaysSyncSend;
factory.AsyncClose = asyncClose;
factory.CopyMessageOnSend = copyMessageOnSend;
factory.RequestTimeout = requestTimeout;
factory.SendAcksAsync = sendAcksAsync;
factory.DispatchAsync = dispatchAsync;
using (Connection connection = factory.CreateConnection() as Connection)
{
Assert.AreEqual(ackMode, connection.AcknowledgementMode);
Assert.AreEqual(asyncSend, connection.AsyncSend);
Assert.AreEqual(alwaysSyncSend, connection.AlwaysSyncSend);
Assert.AreEqual(asyncClose, connection.AsyncClose);
Assert.AreEqual(copyMessageOnSend, connection.CopyMessageOnSend);
Assert.AreEqual(requestTimeout, connection.RequestTimeout.TotalMilliseconds);
Assert.AreEqual(sendAcksAsync, connection.SendAcksAsync);
Assert.AreEqual(dispatchAsync, connection.DispatchAsync);
}
}
public void TestMessageDeliveredAfterCommitFailsAndRollback()
{
string uri = "failover:(tcpfaulty://${activemqhost}:61616?transport.useLogging=true)";
IConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
DeleteQueue(connection, destination);
PutOneMsgIntoQueue(session, destination);
}
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnCommitTransportHook;
IMessageConsumer consumer = session.CreateConsumer(session.GetQueue(destinationName));
IMessage message = consumer.Receive(TimeSpan.FromSeconds(30));
Assert.IsNotNull(message, "Message was not delivered");
Tracer.Debug("Commiting transaction");
try
{
Tracer.Info("Now attempting to commit the transaction");
session.Commit();
}
catch (Exception ex)
{
Tracer.InfoFormat("Commit failed as expected. {0}", ex.Message);
}
message = consumer.Receive(TimeSpan.FromSeconds(30));
Assert.IsNotNull(message, "message was not redilivered");
}
}
}
public void TestIndividualAcksWithClosedConsumerAndAuditSync()
{
const int MSG_COUNT = 20;
const string QUEUE_NAME = "TEST.TestIndividualAcksWithClosedConsumerAndAuditSync";
ProduceSomeMessages(MSG_COUNT, QUEUE_NAME);
string uri = "failover:(tcp://${activemqhost}:61616)";
IConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri));
using (IConnection connection = factory.CreateConnection() as Connection)
using (ISession session = connection.CreateSession(AcknowledgementMode.IndividualAcknowledge))
using (IQueue queue = session.GetQueue(QUEUE_NAME))
{
connection.Start();
// Consume all messages with no ACK
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage message = consumer.Receive(TimeSpan.FromMilliseconds(3000));
Assert.NotNull(message);
Tracer.DebugFormat("Received message: {0}", message.NMSMessageId);
}
}
// Consumer the same batch again.
using (IMessageConsumer consumer = session.CreateConsumer(queue))
{
for (int i = 0; i < MSG_COUNT; ++i)
{
IMessage message = consumer.Receive(TimeSpan.FromMilliseconds(3000));
Assert.NotNull(message);
Tracer.DebugFormat("Received message: {0}", message.NMSMessageId);
}
}
session.DeleteDestination(queue);
}
}
public void TestConfigureRecoveryPolicyLoggerType(
[Values("tcp://${activemqhost}:61616?nms.RecoveryPolicy.RecoveryLoggerType=file")]
string baseConnectionURI)
{
INetTxConnectionFactory factory = new NetTxConnectionFactory(NMSTestSupport.ReplaceEnvVar(baseConnectionURI));
using (INetTxConnection connection = factory.CreateNetTxConnection())
{
NetTxConnection netTxConnection = connection as NetTxConnection;
Assert.IsNotNull(netTxConnection);
NetTxRecoveryPolicy policy = netTxConnection.RecoveryPolicy;
Assert.AreEqual("file", policy.RecoveryLoggerType);
RecoveryFileLogger logger = policy.RecoveryLogger as RecoveryFileLogger;
Assert.IsNotNull(logger);
Assert.AreEqual(Directory.GetCurrentDirectory(), logger.Location);
}
}
public void TestURIForPrefetchHandlingOfAll(int allPreFetch)
{
string testuri = string.Format("activemq:tcp://${{activemqhost}}:61616" +
"?nms.PrefetchPolicy.all={0}", allPreFetch);
NMSConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(testuri));
Assert.IsNotNull(factory);
Assert.IsNotNull(factory.ConnectionFactory);
using (IConnection connection = factory.CreateConnection("", ""))
{
Assert.IsNotNull(connection);
Connection amqConnection = connection as Connection;
Assert.AreEqual(allPreFetch, amqConnection.PrefetchPolicy.QueuePrefetch);
Assert.AreEqual(allPreFetch, amqConnection.PrefetchPolicy.QueueBrowserPrefetch);
Assert.AreEqual(allPreFetch, amqConnection.PrefetchPolicy.TopicPrefetch);
Assert.AreEqual(allPreFetch, amqConnection.PrefetchPolicy.DurableTopicPrefetch);
connection.Close();
}
}
public void InvalidClientIdExceptionTest()
{
Uri uri = URISupport.CreateCompatibleUri(NMSTestSupport.ReplaceEnvVar(connectionURI));
ConnectionFactory factory = new ConnectionFactory(uri);
Assert.IsNotNull(factory);
using (IConnection connection = factory.CreateConnection())
{
connection.ClientId = "FOO";
connection.Start();
try
{
IConnection connection2 = factory.CreateConnection();
connection2.ClientId = "FOO";
connection2.Start();
Assert.Fail("Should throw an InvalidSelectorException");
}
catch (InvalidClientIDException)
{
}
}
}
public void TestConnection()
{
IConnectionFactory factory = new NMSConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionUri));
using (connection = factory.CreateConnection())
using (ISession session = connection.CreateSession())
{
IDestination destination = SessionUtil.GetDestination(session, "queue://TEST.test.in");
using (IMessageConsumer consumer = session.CreateConsumer(destination))
{
Connection amqConnection = connection as Connection;
connection.ExceptionListener += ConnectionException;
consumer.Listener += OnMessage;
TcpFaultyTransport transport = amqConnection.ITransport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(transport);
transport.OnewayCommandPreProcessor += FailOnKeepAlive;
Thread.Sleep(TimeSpan.FromSeconds(2));
connection.Start();
int count = 30;
while (count-- > 0)
{
if (!connectionClosed)
{
Thread.Sleep(TimeSpan.FromSeconds(3));
}
}
Assert.IsTrue(connectionClosed);
}
}
}
public void TestConnectUsingBasicTransport(
[Values("tcpfaulty://${activemqhost}:61616", "activemq:tcpfaulty://${activemqhost}:61616")]
string connectionURI)
{
ConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(connectionURI));
using (Connection connection = factory.CreateConnection() as Connection)
{
ITransport transport = connection.ITransport.Narrow(typeof(TcpFaultyTransport)) as ITransport;
Assert.IsNotNull(transport);
TcpFaultyTransport testee = transport as TcpFaultyTransport;
testee.OnewayCommandPreProcessor += new CommandHandler(this.OnPreProcessCommand);
testee.OnewayCommandPostProcessor += new CommandHandler(this.OnPostProcessCommand);
using (ISession session = connection.CreateSession())
{
Assert.IsTrue(session.Transacted == false);
}
Assert.IsTrue(this.preProcessorFired);
Assert.IsTrue(this.postProcessorFired);
}
}
public void FailoverBeforeCommitSentTest()
{
string uri = "failover:(tcpfaulty://${activemqhost}:61616?transport.useLogging=true)";
IConnectionFactory factory = new ConnectionFactory(NMSTestSupport.ReplaceEnvVar(uri));
using (connection = factory.CreateConnection() as Connection)
{
connection.ConnectionInterruptedListener +=
new ConnectionInterruptedListener(TransportInterrupted);
connection.ConnectionResumedListener +=
new ConnectionResumedListener(TransportResumed);
connection.Start();
ITransport transport = (connection as Connection).ITransport;
TcpFaultyTransport tcpFaulty = transport.Narrow(typeof(TcpFaultyTransport)) as TcpFaultyTransport;
Assert.IsNotNull(tcpFaulty);
tcpFaulty.OnewayCommandPreProcessor += this.FailOnCommitTransportHook;
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
PurgeQueue(connection, destination);
}
Tracer.Debug("Test is putting " + MSG_COUNT + " messages on the queue: " + destinationName);
using (ISession session = connection.CreateSession(AcknowledgementMode.Transactional))
{
IDestination destination = session.GetQueue(destinationName);
PutMsgIntoQueue(session, destination, false);
try
{
session.Commit();
Assert.Fail("Should have thrown a TransactionRolledBackException");
}
catch (TransactionRolledBackException)
{
}
catch
{
Assert.Fail("Should have thrown a TransactionRolledBackException");
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
Tracer.Debug("Test is attempting to read a message from" +
destinationName + " but no messages are expected");
using (ISession session = connection.CreateSession())
{
IDestination destination = session.GetQueue(destinationName);
IMessageConsumer consumer = session.CreateConsumer(destination);
IMessage msg = consumer.Receive(TimeSpan.FromSeconds(5));
Assert.IsNull(msg, "Should not receive a message after commit failed.");
}
}
Assert.IsTrue(this.interrupted);
Assert.IsTrue(this.resumed);
}