public void TestMessageListenerCallsConnectionCloseThrowsIllegalStateException()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
testAmqpPeer.SendMessage("myQueue", "test");
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IMessageConsumer consumer = session.CreateConsumer(destination);
Exception exception = null;
consumer.Listener += message =>
{
try
{
connection.Close();
}
catch (Exception e)
{
exception = e;
}
};
Assert.That(() => exception, Is.Not.Null.After(5000, 100));
consumer.Close();
session.Close();
connection.Close();
}
}
public void TestFailoverPassthroughOfCompletedSyncSend()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer(Address1, User, Password))
{
int messagesReceived = 0;
testPeer.RegisterMessageProcessor("myQueue", context =>
{
messagesReceived++;
context.Complete();
});
testPeer.Open();
NmsConnection connection = EstablishConnection(testPeer);
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
//Do a warmup that succeeds
producer.Send(producer.CreateTextMessage("first"));
producer.Send(producer.CreateTextMessage("second"));
Assert.That(() => messagesReceived, Is.EqualTo(2).After(1000, 100));
connection.Close();
}
}
public void TestCreateProducerInOnMessage()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.RegisterLinkProcessor(new TestLinkProcessor());
testAmqpPeer.Open();
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IQueue outbound = session.GetQueue("ForwardDest");
IMessageConsumer consumer = session.CreateConsumer(destination);
consumer.Listener += message =>
{
IMessageProducer producer = session.CreateProducer(outbound);
producer.Send(message);
producer.Close();
};
consumer.Close();
session.Close();
connection.Close();
}
}
public void TestRemotelyCloseProducer()
{
ManualResetEvent producentClosed = new ManualResetEvent(false);
Mock <INmsConnectionListener> mockConnectionListener = new Mock <INmsConnectionListener>();
mockConnectionListener
.Setup(listener => listener.OnProducerClosed(It.IsAny <NmsMessageProducer>(), It.IsAny <Exception>()))
.Callback(() => { producentClosed.Set(); });
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
TestLinkProcessor testLinkProcessor = new TestLinkProcessor();
testAmqpPeer.RegisterLinkProcessor(testLinkProcessor);
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.AddConnectionListener(mockConnectionListener.Object);
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(destination);
testLinkProcessor.Producer.Link.Close();
Assert.True(producentClosed.WaitOne(TimeSpan.FromMilliseconds(1000)));
Assert.That(() => producer.DisableMessageID, Throws.Exception.InstanceOf <IllegalStateException>());
producer.Close();
session.Close();
connection.Close();
}
}
public void TestFailoverInitialReconnectDelayDoesNotApplyToInitialConnect()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer())
{
// Connect to the first peer
originalPeer.ExpectSaslAnonymous();
originalPeer.ExpectOpen();
originalPeer.ExpectBegin();
int delay = 20000;
Stopwatch watch = new Stopwatch();
watch.Start();
NmsConnection connection = EstablishAnonymousConnection("failover.initialReconnectDelay=" + delay + "&failover.maxReconnectAttempts=1", originalPeer);
connection.Start();
watch.Stop();
Assert.True(watch.ElapsedMilliseconds < delay,
"Initial connect should not have delayed for the specified initialReconnectDelay." + "Elapsed=" + watch.ElapsedMilliseconds + ", delay=" + delay);
Assert.True(watch.ElapsedMilliseconds < 5000, $"Connection took longer than reasonable: {watch.ElapsedMilliseconds}");
// Shut it down
originalPeer.ExpectClose();
connection.Close();
originalPeer.WaitForAllMatchersToComplete(2000);
}
}
public void TestRecoveredMessageShouldNotBeMutated()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
string originalPayload = "testMessage";
testAmqpPeer.Open();
testAmqpPeer.RegisterLinkProcessor(new TestLinkProcessor());
testAmqpPeer.SendMessage("myQueue", originalPayload);
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.ClientAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IMessageConsumer consumer = session.CreateConsumer(destination);
NmsTextMessage message = consumer.Receive() as NmsTextMessage;
Assert.NotNull(message);
message.IsReadOnlyBody = false;
message.Text = message.Text + "Received";
session.Recover();
ITextMessage recoveredMessage = consumer.Receive() as ITextMessage;
Assert.IsNotNull(recoveredMessage);
Assert.AreNotEqual(message.Text, recoveredMessage.Text);
Assert.AreEqual(originalPayload, recoveredMessage.Text);
Assert.AreNotSame(message, recoveredMessage);
consumer.Close();
session.Close();
connection.Close();
}
}
public void TestCreateDurableConsumer()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
TestLinkProcessor testLinkProcessor = new TestLinkProcessor();
testAmqpPeer.RegisterLinkProcessor(testLinkProcessor);
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
string subscriptionName = "mySubscription";
ITopic topic = session.GetTopic(topicName);
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
Assert.NotNull(durableConsumer);
// Expect That Durable Subscriber Attach
Assert.That(() => testLinkProcessor.Consumer, Is.Not.Null.After(200));
Assert.AreEqual(subscriptionName, testLinkProcessor.Consumer.Link.Name);;
Source source = (Source)testLinkProcessor.Consumer.Attach.Source;
Assert.AreEqual((uint)TerminusDurability.UNSETTLED_STATE, source.Durable);
Assert.AreEqual(new Symbol("never"), source.ExpiryPolicy);
Assert.AreEqual(topicName, source.Address);
Assert.IsFalse(source.Dynamic);
connection.Close();
}
}
public void TestFailoverHandlesDropAfterSessionCloseRequested()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer())
{
ManualResetEvent originalConnected = new ManualResetEvent(false);
// Create a peer to connect to
var originalUri = CreatePeerUri(originalPeer);
// Connect to the first peer
originalPeer.ExpectSaslAnonymous();
originalPeer.ExpectOpen();
originalPeer.ExpectBegin();
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.Is <Uri>(uri => originalUri == uri.ToString())))
.Callback(() => { originalConnected.Set(); });
NmsConnection connection = EstablishAnonymousConnection(originalPeer);
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(originalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to peer");
originalPeer.ExpectBegin();
originalPeer.ExpectEnd(sendResponse: false);
originalPeer.DropAfterLastMatcher();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
ManualResetEvent sessionCloseCompleted = new ManualResetEvent(false);
Exception sessionClosedThrew = null;
Task.Run(() =>
{
try
{
session.Close();
}
catch (Exception e)
{
sessionClosedThrew = e;
}
finally
{
sessionCloseCompleted.Set();
}
});
originalPeer.WaitForAllMatchersToComplete(2000);
Assert.IsTrue(sessionCloseCompleted.WaitOne(TimeSpan.FromSeconds(3)), "Session close should have completed by now");
Assert.IsNull(sessionClosedThrew, "Session close should have completed normally");
connection.Close();
}
}
public void TestSetMessageListenerAfterStartAndSend()
{
int messageCount = 4;
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
for (int i = 0; i < messageCount; i++)
{
testAmqpPeer.SendMessage("myQueue", "test" + i);
}
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += message => { };
Assert.That(() => testAmqpPeer.AcceptedMessages.Count(), Is.EqualTo(messageCount).After(2000, 100));
consumer.Close();
session.Close();
connection.Close();
}
}
public void TestRemotelyCloseConsumer()
{
Mock <INmsConnectionListener> mockConnectionListener = new Mock <INmsConnectionListener>();
bool exceptionFired = false;
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
TestLinkProcessor testLinkProcessor = new TestLinkProcessor();
testAmqpPeer.RegisterLinkProcessor(testLinkProcessor);
testAmqpPeer.Open();
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
connection.AddConnectionListener(mockConnectionListener.Object);
connection.ExceptionListener += exception => { exceptionFired = true; };
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
// Create a consumer, then remotely end it afterwards.
IMessageConsumer consumer = session.CreateConsumer(queue);
testLinkProcessor.CloseConsumer();
Assert.That(() => exceptionFired, Is.False.After(200), "Exception listener shouldn't fire with no MessageListener");
// Verify the consumer gets marked closed
mockConnectionListener.Verify(listener => listener.OnConsumerClosed(It.Is <IMessageConsumer>(x => x == consumer), It.IsAny <Exception>()), Times.Once, "consumer never closed.");
session.Close();
connection.Close();
}
}
public void TestCreateProducerAfterConnectionDrops()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer())
using (TestAmqpPeer finalPeer = new TestAmqpPeer())
{
ManualResetEvent originalConnected = new ManualResetEvent(false);
ManualResetEvent finalConnected = new ManualResetEvent(false);
// Create a peer to connect to, then one to reconnect to
var originalUri = CreatePeerUri(originalPeer);
var finalUri = CreatePeerUri(finalPeer);
// Connect to the first peer
originalPeer.ExpectSaslAnonymous();
originalPeer.ExpectOpen();
originalPeer.ExpectBegin();
originalPeer.ExpectBegin();
originalPeer.DropAfterLastMatcher();
NmsConnection connection = EstablishAnonymousConnection(originalPeer, finalPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.Is <Uri>(uri => originalUri == uri.ToString())))
.Callback(() => { originalConnected.Set(); });
connectionListener
.Setup(listener => listener.OnConnectionRestored(It.Is <Uri>(uri => finalUri == uri.ToString())))
.Callback(() => { finalConnected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(originalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to original peer");
// Post Failover Expectations of FinalPeer
finalPeer.ExpectSaslAnonymous();
finalPeer.ExpectOpen();
finalPeer.ExpectBegin();
finalPeer.ExpectBegin();
finalPeer.ExpectSenderAttach();
finalPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true);
finalPeer.ExpectClose();
ISession session = connection.CreateSession();
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
Assert.True(finalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to final peer");
producer.Close();
connection.Close();
finalPeer.WaitForAllMatchersToComplete(1000);
}
}
private void DoRemotelyCloseConsumerWithMessageListenerFiresNMSExceptionListenerTestImpl(Symbol errorType, string errorMessage)
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
ManualResetEvent consumerClosed = new ManualResetEvent(false);
ManualResetEvent exceptionListenerFired = new ManualResetEvent(false);
testPeer.ExpectSaslAnonymous();
testPeer.ExpectOpen();
testPeer.ExpectBegin();
NmsConnection connection = EstablishAnonymousConnection("failover.maxReconnectAttempts=1", testPeer);
connection.ExceptionListener += exception => { exceptionListenerFired.Set(); };
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConsumerClosed(It.IsAny <IMessageConsumer>(), It.IsAny <Exception>()))
.Callback(() => { consumerClosed.Set(); });
connection.AddConnectionListener(connectionListener.Object);
testPeer.ExpectBegin();
testPeer.ExpectBegin(nextOutgoingId: 2);
ISession session1 = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
ISession session2 = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session2.GetQueue("myQueue");
// Create a consumer, then remotely end it afterwards.
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
testPeer.ExpectEnd();
testPeer.RemotelyDetachLastOpenedLinkOnLastOpenedSession(expectDetachResponse: true, closed: true, errorType: errorType, errorMessage: errorMessage, delayBeforeSend: 10);
IMessageConsumer consumer = session2.CreateConsumer(queue);
consumer.Listener += message => { };
// Close first session to allow the receiver remote close timing to be deterministic
session1.Close();
// Verify the consumer gets marked closed
testPeer.WaitForAllMatchersToComplete(1000);
Assert.True(consumerClosed.WaitOne(TimeSpan.FromMilliseconds(2000)), "Consumer closed callback didn't trigger");
Assert.True(exceptionListenerFired.WaitOne(TimeSpan.FromMilliseconds(2000)), "NMS Exception listener should have fired with a MessageListener");
// Try closing it explicitly, should effectively no-op in client.
// The test peer will throw during close if it sends anything.
consumer.Close();
// Shut the connection down
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
private void DoFailoverPassthroughOfFailingSyncSendTestImpl(Outcome failingState)
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
NmsConnection connection = EstablishAnonymousConnection((testPeer));
testPeer.ExpectSaslAnonymous();
testPeer.ExpectOpen();
testPeer.ExpectBegin();
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
// Do a warm up that succeeds
string messageContent1 = "myMessage1";
testPeer.ExpectTransfer(messageMatcher: m => { Assert.AreEqual(messageContent1, (m.BodySection as AmqpValue).Value); });
ITextMessage message1 = session.CreateTextMessage(messageContent1);
producer.Send(message1);
testPeer.WaitForAllMatchersToComplete(1000);
// Create and send a new message, which fails as it is not accepted
Assert.False(failingState is Accepted);
String messageContent2 = "myMessage2";
int delay = 15;
testPeer.ExpectTransfer(messageMatcher: m => Assert.AreEqual(messageContent2, (m.BodySection as AmqpValue).Value),
settled: false,
sendResponseDisposition: true,
responseState: failingState,
responseSettled: true,
stateMatcher: Assert.IsNull,
dispositionDelay: delay);
ITextMessage message2 = session.CreateTextMessage(messageContent2);
DateTime start = DateTime.UtcNow;
Assert.Catch(() => producer.Send(message2), "Expected an exception for this send.");
testPeer.WaitForAllMatchersToComplete(1000);
//Do a final send that succeeds
string messageContent3 = "myMessage3";
testPeer.ExpectTransfer(messageMatcher: m => { Assert.AreEqual(messageContent3, (m.BodySection as AmqpValue).Value); });
ITextMessage message3 = session.CreateTextMessage(messageContent3);
producer.Send(message3);
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestStartMaxReconnectAttemptsTriggeredWhenRemotesAreRejecting()
{
using (TestAmqpPeer firstPeer = new TestAmqpPeer())
using (TestAmqpPeer secondPeer = new TestAmqpPeer())
using (TestAmqpPeer thirdPeer = new TestAmqpPeer())
using (TestAmqpPeer fourthPeer = new TestAmqpPeer())
{
ManualResetEvent failedConnection = new ManualResetEvent(false);
firstPeer.RejectConnect(AmqpError.NOT_FOUND, "Resource could not be located");
secondPeer.RejectConnect(AmqpError.NOT_FOUND, "Resource could not be located");
thirdPeer.RejectConnect(AmqpError.NOT_FOUND, "Resource could not be located");
// This shouldn't get hit, but if it does accept the connect so we don't pass the failed
// to connect assertion.
fourthPeer.ExpectSaslAnonymous();
fourthPeer.ExpectOpen();
fourthPeer.ExpectBegin();
fourthPeer.ExpectClose();
NmsConnection connection = EstablishAnonymousConnection("failover.startupMaxReconnectAttempts=3&failover.reconnectDelay=15&failover.useReconnectBackOff=false",
firstPeer, secondPeer, thirdPeer, fourthPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionFailure(It.IsAny <NMSException>()))
.Callback(() => { failedConnection.Set(); });
connection.AddConnectionListener(connectionListener.Object);
Assert.Catch <NMSException>(() => connection.Start(), "Should not be able to connect");
Assert.True(failedConnection.WaitOne(TimeSpan.FromSeconds(5)));
try
{
connection.Close();
}
catch (NMSException e)
{
}
firstPeer.WaitForAllMatchersToComplete(2000);
secondPeer.WaitForAllMatchersToComplete(2000);
thirdPeer.WaitForAllMatchersToComplete(2000);
// Shut down last peer and verify no connection made to it
fourthPeer.PurgeExpectations();
fourthPeer.Close();
Assert.NotNull(firstPeer.ClientSocket, "Peer 1 should have accepted a TCP connection");
Assert.NotNull(secondPeer.ClientSocket, "Peer 2 should have accepted a TCP connection");
Assert.NotNull(thirdPeer.ClientSocket, "Peer 3 should have accepted a TCP connection");
Assert.IsNull(fourthPeer.ClientSocket, "Peer 4 should not have accepted any TCP connection");
}
}
public void TestFailoverHandlesDropWithModifiedInitialReconnectDelay()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer())
using (TestAmqpPeer finalPeer = new TestAmqpPeer())
{
ManualResetEvent originalConnected = new ManualResetEvent(false);
ManualResetEvent finalConnected = new ManualResetEvent(false);
// Create a peer to connect to, then one to reconnect to
var originalUri = CreatePeerUri(originalPeer);
var finalUri = CreatePeerUri(finalPeer);
// Connect to the first peer
originalPeer.ExpectSaslAnonymous();
originalPeer.ExpectOpen();
originalPeer.ExpectBegin();
originalPeer.ExpectBegin();
originalPeer.DropAfterLastMatcher();
NmsConnection connection = EstablishAnonymousConnection("failover.initialReconnectDelay=1&failover.reconnectDelay=600&failover.maxReconnectAttempts=10", originalPeer, finalPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.Is <Uri>(uri => originalUri == uri.ToString())))
.Callback(() => { originalConnected.Set(); });
connectionListener
.Setup(listener => listener.OnConnectionRestored(It.Is <Uri>(uri => finalUri == uri.ToString())))
.Callback(() => { finalConnected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(originalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to original peer");
// Post Failover Expectations of FinalPeer
finalPeer.ExpectSaslAnonymous();
finalPeer.ExpectOpen();
finalPeer.ExpectBegin();
finalPeer.ExpectBegin();
connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
Assert.True(finalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to final peer");
// Shut it down
finalPeer.ExpectClose();
connection.Close();
finalPeer.WaitForAllMatchersToComplete(1000);
}
}
private void DoRemotelyCloseConsumerWithMessageListenerFiresNMSExceptionListenerTestImpl(bool closeWithError)
{
using (TestAmqpPeer testPeer = new TestAmqpPeer(Address1, User, Password))
{
ManualResetEvent consumerClosed = new ManualResetEvent(false);
ManualResetEvent exceptionListenerFired = new ManualResetEvent(false);
TestLinkProcessor linkProcessor = new TestLinkProcessor();
testPeer.RegisterLinkProcessor(linkProcessor);
testPeer.Open();
NmsConnection connection = EstablishConnection("failover.maxReconnectAttempts=1", testPeer);
connection.ExceptionListener += exception =>
{
exceptionListenerFired.Set();
};
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConsumerClosed(It.IsAny <IMessageConsumer>(), It.IsAny <Exception>()))
.Callback(() => { consumerClosed.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
// Create a consumer, then remotely end it afterwards.
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += message => { };
if (closeWithError)
{
linkProcessor.CloseConsumerWithError();
}
else
{
linkProcessor.CloseConsumer();
}
Assert.True(consumerClosed.WaitOne(TimeSpan.FromMilliseconds(2000)), "Consumer closed callback didn't trigger");
Assert.True(exceptionListenerFired.WaitOne(TimeSpan.FromMilliseconds(2000)), "JMS Exception listener should have fired with a MessageListener");
// Try closing it explicitly, should effectively no-op in client.
// The test peer will throw during close if it sends anything.
consumer.Close();
connection.Close();
}
}
public void TestFailoverPassthroughOfCompletedSyncSend()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
NmsConnection connection = EstablishAnonymousConnection((testPeer));
testPeer.ExpectSaslAnonymous();
testPeer.ExpectOpen();
testPeer.ExpectBegin();
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
// Do a warm up
string messageContent1 = "myMessage1";
testPeer.ExpectTransfer(messageMatcher: m => { Assert.AreEqual(messageContent1, (m.BodySection as AmqpValue).Value); });
ITextMessage message1 = session.CreateTextMessage(messageContent1);
producer.Send(message1);
testPeer.WaitForAllMatchersToComplete(1000);
// Create and send a new message, which is accepted
String messageContent2 = "myMessage2";
int delay = 15;
testPeer.ExpectTransfer(messageMatcher: m => Assert.AreEqual(messageContent2, (m.BodySection as AmqpValue).Value),
settled: false,
sendResponseDisposition: true,
responseState: new Accepted(),
responseSettled: true,
stateMatcher: Assert.IsNull,
dispositionDelay: delay);
testPeer.ExpectClose();
ITextMessage message2 = session.CreateTextMessage(messageContent2);
DateTime start = DateTime.UtcNow;
producer.Send(message2);
TimeSpan elapsed = DateTime.UtcNow - start;
Assert.That(elapsed.TotalMilliseconds, Is.GreaterThanOrEqualTo(delay));
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestCreateConsumerFailsWhenLinkRefused()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer(Address1, User, Password))
{
testPeer.RegisterLinkProcessor(new MockLinkProcessor(context => context.Complete(new Error(new Symbol("error")))));
testPeer.Open();
NmsConnection connection = EstablishConnection(testPeer);
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
ITopic topic = session.GetTopic("myTopic");
Assert.Catch <NMSException>(() => session.CreateConsumer(topic));
connection.Close();
}
}
public void TestSyncReceiveFailsWhenListenerSet()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.RegisterLinkProcessor(new TestLinkProcessor());
testAmqpPeer.Open();
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += message => { };
try
{
consumer.Receive();
Assert.Fail("Should have thrown an exception.");
}
catch (NMSException)
{
}
try
{
consumer.Receive(TimeSpan.FromMilliseconds(1000));
Assert.Fail("Should have thrown an exception.");
}
catch (NMSException)
{
}
try
{
consumer.ReceiveNoWait();
Assert.Fail("Should have thrown an exception.");
}
catch (NMSException)
{
}
consumer.Close();
session.Close();
connection.Close();
}
}
public void TestFailoverPassthroughOfRejectedSyncSend()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer(Address1, User, Password))
{
int counter = 1;
testPeer.RegisterMessageProcessor("myQueue", context =>
{
switch (counter)
{
// accept first and third
case 1:
case 3:
context.Complete();
break;
// fail second
case 2:
context.Complete(new Error(new Symbol("error")));
break;
}
counter++;
});
testPeer.Open();
NmsConnection connection = EstablishConnection(testPeer);
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
//Do a warmup that succeeds
producer.Send(producer.CreateTextMessage("first"));
Assert.Catch(() =>
{
producer.Send(producer.CreateTextMessage("second"));
});
//Do a final send that succeeds
producer.Send(producer.CreateTextMessage("third"));
connection.Close();
}
}
public void TestFailoverEnforcesSendTimeout()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
ManualResetEvent connected = new ManualResetEvent(false);
ManualResetEvent disconnected = new ManualResetEvent(false);
// Connect to the test peer
testPeer.ExpectSaslAnonymous();
testPeer.ExpectOpen();
testPeer.ExpectBegin();
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
testPeer.DropAfterLastMatcher();
NmsConnection connection = EstablishAnonymousConnection("nms.sendTimeout=1000&failover.reconnectDelay=2000&failover.maxReconnectAttempts=60", testPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.IsAny <Uri>()))
.Callback(() => { connected.Set(); });
connectionListener
.Setup(listener => listener.OnConnectionInterrupted(It.IsAny <Uri>()))
.Callback(() => { disconnected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(connected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to peer");
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
Assert.True(disconnected.WaitOne(TimeSpan.FromSeconds(5)), "Should lose connection to peer");
Assert.Catch <NMSException>(() => producer.Send(producer.CreateTextMessage("test")));
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestFailoverDoesNotFailPendingSend()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer())
using (TestAmqpPeer finalPeer = new TestAmqpPeer())
{
originalPeer.ExpectSaslAnonymous();
originalPeer.ExpectOpen();
originalPeer.ExpectBegin();
originalPeer.ExpectBegin();
// Ensure our send blocks in the provider waiting for credit so that on failover
// the message will actually get sent from the Failover bits once we grant some
// credit for the recovered sender.
originalPeer.ExpectSenderAttachWithoutGrantingCredit();
originalPeer.DropAfterLastMatcher(delay: 10); // Wait for sender to get into wait state
// Post Failover Expectations of sender
finalPeer.ExpectSaslAnonymous();
finalPeer.ExpectOpen();
finalPeer.ExpectBegin();
finalPeer.ExpectBegin();
finalPeer.ExpectSenderAttach();
finalPeer.ExpectTransfer(messageMatcher: Assert.IsNotNull);
finalPeer.ExpectClose();
NmsConnection connection = EstablishAnonymousConnection("failover.initialReconnectDelay=25", originalPeer, finalPeer);
ISession session = connection.CreateSession();
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
// Create and transfer a new message
string text = "myMessage";
ITextMessage message = session.CreateTextMessage(text);
Assert.DoesNotThrow(() =>
{
producer.Send(message);
});
connection.Close();
finalPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestCreateProducerAfterConnectionDrops()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer(Address1, User, Password))
using (TestAmqpPeer finalPeer = new TestAmqpPeer(Address2, User, Password))
{
originalPeer.RegisterLinkProcessor(new TestLinkProcessor());
finalPeer.RegisterLinkProcessor(new TestLinkProcessor());
ManualResetEvent originalConnected = new ManualResetEvent(false);
ManualResetEvent finalConnected = new ManualResetEvent(false);
// Create a peer to connect to, then one to reconnect to
originalPeer.Open();
finalPeer.Open();
NmsConnection connection = EstablishConnection(originalPeer, finalPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.Is <Uri>(uri => originalPeer.Address == uri)))
.Callback(() => { originalConnected.Set(); });
connectionListener
.Setup(listener => listener.OnConnectionRestored(It.Is <Uri>(uri => finalPeer.Address == uri)))
.Callback(() => { finalConnected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(originalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to original peer");
originalPeer.Close();
ISession session = connection.CreateSession();
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
Assert.True(finalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to final peer");
producer.Close();
connection.Close();
}
}
public void TestTempDestinationRecreatedAfterConnectionFailsOver()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer(Address1, User, Password))
using (TestAmqpPeer finalPeer = new TestAmqpPeer(Address2, User, Password))
{
originalPeer.RegisterLinkProcessor(new TestLinkProcessor());
finalPeer.RegisterLinkProcessor(new TestLinkProcessor());
ManualResetEvent originalConnected = new ManualResetEvent(false);
ManualResetEvent finalConnected = new ManualResetEvent(false);
// Create a peer to connect to, then one to reconnect to
originalPeer.Open();
finalPeer.Open();
NmsConnection connection = EstablishConnection(originalPeer, finalPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.Is <Uri>(uri => originalPeer.Address == uri)))
.Callback(() => { originalConnected.Set(); });
connectionListener
.Setup(listener => listener.OnConnectionRestored(It.Is <Uri>(uri => finalPeer.Address == uri)))
.Callback(() => { finalConnected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(originalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to original peer");
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
ITemporaryTopic temporaryTopic = session.CreateTemporaryTopic();
originalPeer.Close();
Assert.True(finalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to final peer");
temporaryTopic.Delete();
connection.Close();
}
}
public void TestFailoverHandlesDropThenRejectionCloseAfterConnect()
{
using (TestAmqpPeer originalPeer = new TestAmqpPeer(Address1, User, Password))
using (TestAmqpPeer rejectingPeer = new TestAmqpPeer(Address2, User, Password))
using (TestAmqpPeer finalPeer = new TestAmqpPeer(Address3, User, Password))
{
ManualResetEvent originalConnected = new ManualResetEvent(false);
ManualResetEvent finalConnected = new ManualResetEvent(false);
// Create a peer to connect to, one to fail to reconnect to, and a final one to reconnect to
originalPeer.Open();
finalPeer.Open();
long ird = 0;
long rd = 2000;
NmsConnection connection = EstablishConnection("failover.initialReconnectDelay=" + ird + "&failover.reconnectDelay=" + rd + "&failover.maxReconnectAttempts=10", originalPeer, rejectingPeer, finalPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.Is <Uri>(uri => originalPeer.Address == uri)))
.Callback(() => { originalConnected.Set(); });
connectionListener
.Setup(listener => listener.OnConnectionRestored(It.Is <Uri>(uri => finalPeer.Address == uri)))
.Callback(() => { finalConnected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(originalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to original peer");
Assert.False(finalConnected.WaitOne(TimeSpan.FromMilliseconds(100)), "Should not yet have connected to final peer");
// Close the original peer and wait for things to shake out.
originalPeer.Close();
Assert.True(finalConnected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to final peer");
connection.Close();
}
}
public void TestReceiveMessageWithReceiveZeroTimeout()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
testAmqpPeer.SendMessage("myQueue", "test");
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageConsumer consumer = session.CreateConsumer(queue);
IMessage message = consumer.Receive();
Assert.NotNull(message, "A message should have been received");
session.Close();
connection.Close();
}
}
public void TestNoReceivedNoWaitMessagesWhenConnectionNotStarted()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
testAmqpPeer.SendMessage("myQueue", "test");
NmsConnection connection = (NmsConnection)EstablishConnection();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageConsumer consumer = session.CreateConsumer(queue);
Assert.Null(consumer.ReceiveNoWait());
consumer.Close();
session.Close();
connection.Close();
}
}
public void TestFailoverHandlesDropAfterSessionCloseRequested()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer(Address1, User, Password))
{
ManualResetEvent connected = new ManualResetEvent(false);
testPeer.RegisterLinkProcessor(new MockLinkProcessor(context => context.Complete(new Error(new Symbol("error")))));
testPeer.Open();
NmsConnection connection = EstablishConnection(testPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.IsAny <Uri>()))
.Callback(() => { connected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(connected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to peer");
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
testPeer.Close();
try
{
session.Close();
}
catch (NMSException)
{
}
catch (Exception)
{
Assert.Fail("Session close should have completed normally.");
}
connection.Close();
}
}
public void TestFailoverEnforcesSendTimeout()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer(Address1, User, Password))
{
ManualResetEvent connected = new ManualResetEvent(false);
ManualResetEvent disconnected = new ManualResetEvent(false);
testPeer.RegisterLinkProcessor(new TestLinkProcessor());
testPeer.Open();
NmsConnection connection = EstablishConnection("nms.sendTimeout=1000&failover.reconnectDelay=2000&failover.maxReconnectAttempts=60", testPeer);
Mock <INmsConnectionListener> connectionListener = new Mock <INmsConnectionListener>();
connectionListener
.Setup(listener => listener.OnConnectionEstablished(It.IsAny <Uri>()))
.Callback(() => { connected.Set(); });
connectionListener
.Setup(listener => listener.OnConnectionInterrupted(It.IsAny <Uri>()))
.Callback(() => { disconnected.Set(); });
connection.AddConnectionListener(connectionListener.Object);
connection.Start();
Assert.True(connected.WaitOne(TimeSpan.FromSeconds(5)), "Should connect to peer");
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(queue);
testPeer.Close();
Assert.True(disconnected.WaitOne(TimeSpan.FromSeconds(5)), "Should lose connection to peer");
Assert.Catch <NMSException>(() => producer.Send(producer.CreateTextMessage("test")));
connection.Close();
}
}
public void TestExceptionInOnMessageReleasesInAutoAckMode()
{
using (TestAmqpPeer testAmqpPeer = new TestAmqpPeer(Address, User, Password))
{
testAmqpPeer.Open();
testAmqpPeer.SendMessage("myQueue", "test");
NmsConnection connection = (NmsConnection)EstablishConnection();
connection.Start();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += message => throw new Exception();
Assert.That(() => testAmqpPeer.ReleasedMessages.Count(), Is.EqualTo(1).After(2000, 100));
session.Close();
connection.Close();
}
}