public void TestSendingMessageNonPersistentSetsBatchableFalse()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
IMessageProducer producer = session.CreateProducer(destination);
testPeer.ExpectTransfer(messageMatcher: Assert.IsNotNull,
stateMatcher: Assert.IsNull,
settled: false,
sendResponseDisposition: true,
responseState: new Accepted(),
responseSettled: true,
batchable: false);
IMessage message = session.CreateMessage();
producer.Send(message: message, deliveryMode: MsgDeliveryMode.NonPersistent, MsgPriority.Normal, NMSConstants.defaultTimeToLive);
testPeer.WaitForAllMatchersToComplete(1000);
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestSyncReceiveFailsWhenListenerSet()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
IMessageConsumer consumer = session.CreateConsumer(destination);
consumer.Listener += message => { };
Assert.Catch <NMSException>(() => consumer.Receive(), "Should have thrown an exception.");
Assert.Catch <NMSException>(() => consumer.Receive(TimeSpan.FromMilliseconds(1000)), "Should have thrown an exception.");
Assert.Catch <NMSException>(() => consumer.ReceiveNoWait(), "Should have thrown an exception.");
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(2000);
}
}
public void TestAutoAcknowledgeMessagesAsync()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
int msgCount = 6;
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithNullContent(), count: msgCount);
IMessageConsumer consumer = session.CreateConsumer(queue);
for (int i = 0; i < msgCount; i++)
{
testPeer.ExpectDispositionThatIsAcceptedAndSettled();
}
consumer.Listener += (message) => { };
testPeer.WaitForAllMatchersToComplete(3000);
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(3000);
}
}
public void TestReceiveMessageWithReceiveZeroTimeout()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlowRespondWithTransfer(message: new Amqp.Message()
{
BodySection = new AmqpValue()
{
Value = null
}
}, count: 1);
testPeer.ExpectDispositionThatIsAcceptedAndSettled();
IMessageConsumer consumer = session.CreateConsumer(queue);
IMessage message = consumer.Receive();
Assert.NotNull(message, "A message should have been received");
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(10000);
}
}
public void TestCloseDurableTopicSubscriberDetachesWithCloseFalse()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
string subscriptionName = "mySubscription";
ITopic topic = session.GetTopic(topicName);
testPeer.ExpectDurableSubscriberAttach(topicName, subscriptionName);
testPeer.ExpectLinkFlow();
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
testPeer.ExpectDetach(expectClosed: false, sendResponse: true, replyClosed: false);
durableConsumer.Close();
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestCreateSharedDurableConsumer()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer);
await connection.StartAsync();
testPeer.ExpectBegin();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
ITopic topic = await session.GetTopicAsync(topicName);
string subscriptionName = "mySubscription";
testPeer.ExpectSharedDurableSubscriberAttach(topicName, subscriptionName);
testPeer.ExpectLinkFlow();
IMessageConsumer durableConsumer = await session.CreateSharedDurableConsumerAsync(topic, subscriptionName, null); //, false);
Assert.NotNull(durableConsumer, "MessageConsumer object was null");
testPeer.ExpectClose();
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestCantDeleteTemporaryQueueWithConsumers()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer);
await connection.StartAsync();
testPeer.ExpectBegin();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
string dynamicAddress = "myTempTopicAddress";
testPeer.ExpectTempTopicCreationAttach(dynamicAddress);
ITemporaryTopic topic = await session.CreateTemporaryTopicAsync();
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
IMessageConsumer consumer = await session.CreateConsumerAsync(topic);
Assert.CatchAsync <IllegalStateException>(async() => await topic.DeleteAsync(), "should not be able to delete temporary topic with active consumers");
testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true);
await consumer.CloseAsync();
// Now it should be allowed
testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true);
await topic.DeleteAsync();
testPeer.ExpectClose();
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(2000);
}
}
public async Task TestDefaultDeliveryModeProducesDurableMessages()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await base.EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue queue = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(queue);
// Create and transfer a new message
testPeer.ExpectTransfer(message => Assert.IsTrue(message.Header.Durable));
testPeer.ExpectClose();
ITextMessage textMessage = await session.CreateTextMessageAsync();
await producer.SendAsync(textMessage);
Assert.AreEqual(MsgDeliveryMode.Persistent, textMessage.NMSDeliveryMode);
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestSendingMessageSetsNMSDestination()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue destination = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(destination);
string text = "myMessage";
ITextMessage message = await session.CreateTextMessageAsync(text);
testPeer.ExpectTransfer(m => Assert.AreEqual(text, (m.BodySection as AmqpValue).Value));
testPeer.ExpectClose();
Assert.IsNull(message.NMSDestination, "Should not yet have a NMSDestination");
await producer.SendAsync(message);
Assert.AreEqual(destination, message.NMSDestination, "Should have had NMSDestination set");
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestSendWorksAfterConnectionStopped()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
var context = await EstablishNMSContextAsync(testPeer);
await context.StartAsync();
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
IQueue destination = await context.GetQueueAsync("myQueue");
var producer = await context.CreateProducerAsync();
testPeer.ExpectTransfer(Assert.IsNotNull);
await context.StopAsync();
await producer.SendAsync(destination, await context.CreateMessageAsync());
testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true);
testPeer.ExpectEnd();
testPeer.ExpectClose();
await producer.CloseAsync();
await context.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestDefaultDeliveryModeProducesDurableMessages()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
var context = await base.EstablishNMSContextAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
IQueue queue = await context.GetQueueAsync("myQueue");
var producer = await context.CreateProducerAsync();
// Create and transfer a new message
testPeer.ExpectTransfer(message => Assert.IsTrue(message.Header.Durable));
testPeer.ExpectEnd();
testPeer.ExpectClose();
ITextMessage textMessage = await context.CreateTextMessageAsync();
await producer.SendAsync(queue, textMessage);
Assert.AreEqual(MsgDeliveryMode.Persistent, textMessage.NMSDeliveryMode);
await context.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestNonDefaultPriorityProducesMessagesWithPriorityFieldAndSetsNMSPriority()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
var context = await EstablishNMSContextAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
IQueue destination = await context.GetQueueAsync("myQueue");
var producer = await context.CreateProducerAsync();
byte priority = 9;
testPeer.ExpectTransfer(m => Assert.AreEqual(priority, m.Header.Priority));
testPeer.ExpectEnd();
testPeer.ExpectClose();
ITextMessage message = await context.CreateTextMessageAsync();
Assert.AreEqual(MsgPriority.BelowNormal, message.NMSPriority);
producer.DeliveryMode = MsgDeliveryMode.Persistent;
producer.Priority = (MsgPriority)priority;
producer.TimeToLive = NMSConstants.defaultTimeToLive;
await producer.SendAsync(destination, message);
Assert.AreEqual((MsgPriority)priority, message.NMSPriority);
await context.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestCreateConsumerWithEmptySelector()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
testPeer.ExpectClose();
IQueue queue = session.GetQueue("myQueue");
session.CreateConsumer(queue, "");
session.CreateConsumer(queue, "", noLocal: false);
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestCreateDurableConsumer()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
string topicName = "myTopic";
ITopic topic = session.GetTopic(topicName);
string subscriptionName = "mySubscription";
testPeer.ExpectDurableSubscriberAttach(topicName, subscriptionName);
testPeer.ExpectLinkFlow();
IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false);
Assert.NotNull(durableConsumer, "MessageConsumer object was null");
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestProducerWorkWithAsyncAwait()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await base.EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue queue = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(queue);
// Create and transfer a new message, explicitly setting the deliveryMode on the
// message (which applications shouldn't) to NON_PERSISTENT and sending it to check
// that the producer ignores this value and sends the message as PERSISTENT(/durable)
testPeer.ExpectTransfer(message => Assert.IsTrue(message.Header.Durable));
testPeer.ExpectClose();
ITextMessage textMessage = await session.CreateTextMessageAsync();
textMessage.NMSDeliveryMode = MsgDeliveryMode.NonPersistent;
Assert.AreEqual(MsgDeliveryMode.NonPersistent, textMessage.NMSDeliveryMode);
await producer.SendAsync(textMessage);
Assert.AreEqual(MsgDeliveryMode.Persistent, textMessage.NMSDeliveryMode);
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestCloseSender()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await base.EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue queue = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync();
testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true);
testPeer.ExpectClose();
await producer.CloseAsync();
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestSentAsync()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await base.EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue queue = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(queue);
// Create and transfer a new message
String text = "myMessage";
testPeer.ExpectTransfer(messageMatcher: m => Assert.AreEqual(text, (m.BodySection as AmqpValue).Value),
settled: false,
sendResponseDisposition: true,
responseState: new Accepted(),
responseSettled: true,
stateMatcher: Assert.IsNull,
dispositionDelay: 10); // 10ms should be enough
testPeer.ExpectClose();
ITextMessage message = await session.CreateTextMessageAsync(text);
await producer.SendAsync(message);
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestMessagesAreProducedWithProperDefaultPriorityWhenNoPrioritySpecified()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue destination = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(destination);
byte priority = 4;
testPeer.ExpectTransfer(m => Assert.AreEqual(priority, m.Header.Priority));
testPeer.ExpectClose();
ITextMessage message = await session.CreateTextMessageAsync();
Assert.AreEqual(MsgPriority.BelowNormal, message.NMSPriority);
await producer.SendAsync(message);
Assert.AreEqual((MsgPriority)priority, message.NMSPriority);
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestCreateConsumer()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer);
await connection.StartAsync();
testPeer.ExpectBegin();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
testPeer.ExpectClose();
IQueue queue = await session.GetQueueAsync("myQueue");
await session.CreateConsumerAsync(queue);
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public async Task TestNonDefaultPriorityProducesMessagesWithPriorityFieldAndSetsNMSPriority()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue destination = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(destination);
byte priority = 9;
testPeer.ExpectTransfer(m => Assert.AreEqual(priority, m.Header.Priority));
testPeer.ExpectClose();
ITextMessage message = await session.CreateTextMessageAsync();
Assert.AreEqual(MsgPriority.BelowNormal, message.NMSPriority);
await producer.SendAsync(message, MsgDeliveryMode.Persistent, (MsgPriority)priority, NMSConstants.defaultTimeToLive);
Assert.AreEqual((MsgPriority)priority, message.NMSPriority);
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
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 async Task TestSentTextMessageCanBeModified()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await base.EstablishConnectionAsync(testPeer);
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue queue = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(queue);
// Create and transfer a new message
String text = "myMessage";
testPeer.ExpectTransfer(x => Assert.AreEqual(text, (x.BodySection as AmqpValue).Value));
testPeer.ExpectClose();
ITextMessage message = await session.CreateTextMessageAsync(text);
await producer.SendAsync(message);
Assert.AreEqual(text, message.Text);
message.Text = text + text;
Assert.AreEqual(text + text, message.Text);
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestExceptionInOnMessageReleasesInAutoAckMode()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue queue = session.GetQueue("myQueue");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlowRespondWithTransfer(message: new Amqp.Message()
{
BodySection = new AmqpValue()
{
Value = null
}
}, count: 1);
testPeer.ExpectDispositionThatIsReleasedAndSettled();
IMessageConsumer consumer = session.CreateConsumer(queue);
consumer.Listener += message => throw new Exception();
testPeer.WaitForAllMatchersToComplete(2000);
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(10000);
}
}
public async Task TestSendWhenLinkCreditIsZeroAndTimeout()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer, optionsString : "nms.sendTimeout=500");
testPeer.ExpectBegin();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue queue = await session.GetQueueAsync("myQueue");
ITextMessage message = await session.CreateTextMessageAsync("text");
// Expect the producer to attach. Don't send any credit so that the client will
// block on a send and we can test our timeouts.
testPeer.ExpectSenderAttachWithoutGrantingCredit();
testPeer.ExpectClose();
IMessageProducer producer = await session.CreateProducerAsync(queue);
Assert.CatchAsync <Exception>(async() => await producer.SendAsync(message), "Send should time out.");
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestNoReceivedNoWaitMessagesWhenConnectionNotStarted()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.AutoAcknowledge);
IQueue destination = session.GetQueue("myQueue");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), count: 3);
IMessageConsumer consumer = session.CreateConsumer(destination);
// Wait for a message to arrive then try and receive it, which should not happen
// since the connection is not started.
Assert.Null(consumer.ReceiveNoWait());
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(2000);
}
}
public async Task TestSendTimesOutWhenNoDispositionArrives()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer, optionsString : "nms.sendTimeout=500");
testPeer.ExpectBegin();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue queue = await session.GetQueueAsync("myQueue");
ITextMessage message = await session.CreateTextMessageAsync("text");
// Expect the producer to attach and grant it some credit, it should send
// a transfer which we will not send any response for which should cause the
// send operation to time out.
testPeer.ExpectSenderAttach();
testPeer.ExpectTransferButDoNotRespond(messageMatcher: Assert.NotNull);
testPeer.ExpectClose();
IMessageProducer producer = await session.CreateProducerAsync(queue);
Assert.CatchAsync <Exception>(async() => await producer.SendAsync(message), "Send should time out.");
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestAcknowledgeIndividualMessagesAsync()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
int msgCount = 6;
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.IndividualAcknowledge);
IQueue queue = session.GetQueue("myQueue");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlowRespondWithTransfer(
message: CreateMessageWithNullContent(),
count: msgCount,
drain: false,
nextIncomingId: 1,
addMessageNumberProperty: true,
sendDrainFlowResponse: false,
sendSettled: false,
creditMatcher: credit => Assert.Greater(credit, msgCount));
IMessageConsumer consumer = session.CreateConsumer(queue);
CountdownEvent latch = new CountdownEvent(msgCount);
List <ITextMessage> messages = new List <ITextMessage>();
consumer.Listener += message =>
{
messages.Add((ITextMessage)message);
latch.Signal();
};
Assert.True(latch.Wait(TimeSpan.FromMilliseconds(1000)), $"Should receive: {msgCount}, but received: {messages.Count}");
Action <DeliveryState> dispositionMatcher = state => { Assert.AreEqual(state.Descriptor.Code, MessageSupport.ACCEPTED_INSTANCE.Descriptor.Code); };
// Acknowledge the messages in a random order and verify the individual dispositions have expected delivery state.
Random random = new Random();
for (int i = 0; i < msgCount; i++)
{
var message = messages[random.Next(msgCount - i)];
messages.Remove(message);
uint deliveryNumber = (uint)message.Properties.GetInt(TestAmqpPeer.MESSAGE_NUMBER) + 1;
testPeer.ExpectDisposition(settled: true, stateMatcher: dispositionMatcher, firstDeliveryId: deliveryNumber, lastDeliveryId: deliveryNumber);
message.Acknowledge();
testPeer.WaitForAllMatchersToComplete(3000);
}
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(3000);
}
}
public async Task TestSendWorksAfterConnectionStopped()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = await EstablishConnectionAsync(testPeer);
await connection.StartAsync();
testPeer.ExpectBegin();
testPeer.ExpectSenderAttach();
ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge);
IQueue destination = await session.GetQueueAsync("myQueue");
IMessageProducer producer = await session.CreateProducerAsync(destination);
testPeer.ExpectTransfer(Assert.IsNotNull);
await connection.StopAsync();
await producer.SendAsync(await session.CreateMessageAsync());
testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true);
testPeer.ExpectClose();
await producer.CloseAsync();
await connection.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
public void TestAcknowledgeFailsAfterSessionIsClosed()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
IConnection connection = EstablishConnection(testPeer);
connection.Start();
testPeer.ExpectBegin();
ISession session = connection.CreateSession(AcknowledgementMode.ClientAcknowledge);
IQueue queue = session.GetQueue("myQueue");
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithNullContent(), count: 1);
testPeer.ExpectEnd();
IMessageConsumer consumer = session.CreateConsumer(queue);
IMessage receivedMessage = consumer.Receive(TimeSpan.FromSeconds(6));
Assert.NotNull(receivedMessage, "Message was not received");
session.Close();
Assert.Catch <NMSException>(() => receivedMessage.Acknowledge(), "Should not be able to acknowledge the message after session closed");
testPeer.ExpectClose();
connection.Close();
testPeer.WaitForAllMatchersToComplete(3000);
}
}
public async Task TestCreateConsumerWithEmptySelector()
{
using (TestAmqpPeer testPeer = new TestAmqpPeer())
{
var context = await EstablishNMSContextAsync(testPeer);
await context.StartAsync();
testPeer.ExpectBegin();
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
testPeer.ExpectReceiverAttach();
testPeer.ExpectLinkFlow();
testPeer.ExpectEnd();
testPeer.ExpectClose();
IQueue queue = await context.GetQueueAsync("myQueue");
await context.CreateConsumerAsync(queue, "");
await context.CreateConsumerAsync(queue, "", noLocal : false);
await context.CloseAsync();
testPeer.WaitForAllMatchersToComplete(1000);
}
}
