public void TestReceiveBody <T>(T inputValue) { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = EstablishNMSContext(testPeer); testPeer.ExpectBegin(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(CreateMessageWithValueContent(inputValue)); testPeer.ExpectDisposition(true, _ => { }); IQueue destination = context.GetQueue("myQueue"); var consumer = context.CreateConsumer(destination); T body = consumer.ReceiveBody <T>(); Assert.AreEqual(inputValue, body); Assert.AreNotSame(inputValue, body); testPeer.ExpectEnd(); testPeer.ExpectClose(); context.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
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 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 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 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 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 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 TestNoReceivedMessagesWhenConnectionNotStarted() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue destination = await session.GetQueueAsync("myQueue"); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), count: 3); IMessageConsumer consumer = await session.CreateConsumerAsync(destination); // Wait for a message to arrive then try and receive it, which should not happen // since the connection is not started. Assert.Null(await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(100))); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestExceptionInOnMessageReleasesInAutoAckMode() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = await EstablishNMSContextAsync(testPeer); await context.StartAsync(); testPeer.ExpectBegin(); IQueue queue = await context.GetQueueAsync("myQueue"); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: new Amqp.Message() { BodySection = new AmqpValue() { Value = null } }, count: 1); testPeer.ExpectDispositionThatIsReleasedAndSettled(); var consumer = await context.CreateConsumerAsync(queue); consumer.Listener += message => throw new Exception(); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectEnd(); testPeer.ExpectClose(); await context.CloseAsync(); testPeer.WaitForAllMatchersToComplete(10000); } }
public async Task TestIncomingExpiredMessageGetsFiltered() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue queue = await session.GetQueueAsync("myQueue"); // Expected the consumer to attach and send credit, then send it an // already-expired message followed by a live message. testPeer.ExpectReceiverAttach(); string expiredMsgContent = "already-expired"; Amqp.Message message = CreateExpiredMessage(expiredMsgContent); testPeer.ExpectLinkFlowRespondWithTransfer(message: message); string liveMsgContent = "valid"; testPeer.SendTransferToLastOpenedLinkOnLastOpenedSession(message: new Amqp.Message() { BodySection = new AmqpValue() { Value = liveMsgContent } }, nextIncomingId: 2); IMessageConsumer consumer = await session.CreateConsumerAsync(queue); // Call receive, expect the first message to be filtered due to expiry, // and the second message to be given to the test app and accepted. Action <DeliveryState> modifiedMatcher = state => { var modified = state as Modified; Assert.IsNotNull(modified); Assert.IsTrue(modified.DeliveryFailed); Assert.IsTrue(modified.UndeliverableHere); }; testPeer.ExpectDisposition(settled: true, stateMatcher: modifiedMatcher, firstDeliveryId: 1, lastDeliveryId: 1); testPeer.ExpectDisposition(settled: true, stateMatcher: Assert.IsInstanceOf <Accepted>, firstDeliveryId: 2, lastDeliveryId: 2); IMessage m = await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(3000)); Assert.NotNull(m, "Message should have been received"); Assert.IsInstanceOf <ITextMessage>(m); Assert.AreEqual(liveMsgContent, (m as ITextMessage).Text, "Unexpected message content"); // Verify the other message is not there. Will drain to be sure there are no messages. Assert.IsNull(await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(10)), "Message should not have been received"); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(3000); } }
public void TestCloseDurableSubscriberWithUnackedAndUnconsumedPrefetchedMessages() { 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); int messageCount = 5; // Create a consumer and fill the prefetch with some messages, // which we will consume some of but ack none of. testPeer.ExpectDurableSubscriberAttach(topicName, subscriptionName); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), count: messageCount); IMessageConsumer durableConsumer = session.CreateDurableConsumer(topic, subscriptionName, null, false); int consumeCount = 2; IMessage receivedMessage = null; for (int i = 1; i <= consumeCount; i++) { receivedMessage = durableConsumer.Receive(); Assert.NotNull(receivedMessage); Assert.IsInstanceOf <NmsTextMessage>(receivedMessage); } // Expect the messages that were not delivered to be released. for (int i = 1; i <= consumeCount; i++) { testPeer.ExpectDispositionThatIsAcceptedAndSettled(); } receivedMessage.Acknowledge(); testPeer.ExpectDetach(expectClosed: false, sendResponse: true, replyClosed: false); for (int i = consumeCount + 1; i <= messageCount; i++) { testPeer.ExpectDispositionThatIsReleasedAndSettled(); } testPeer.ExpectEnd(); durableConsumer.Close(); session.Close(); testPeer.ExpectClose(); connection.Close(); testPeer.WaitForAllMatchersToComplete(3000); } }
public async Task TestIncomingExpiredMessageGetsConsumedWhenFilterDisabledAsync() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer, "?nms.localMessageExpiry=false"); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue queue = await session.GetQueueAsync("myQueue"); // Expected the consumer to attach and send credit, then send it an // already-expired message followed by a live message. testPeer.ExpectReceiverAttach(); string expiredMsgContent = "already-expired"; Amqp.Message message = CreateExpiredMessage(expiredMsgContent); testPeer.ExpectLinkFlowRespondWithTransfer(message: message); string liveMsgContent = "valid"; testPeer.SendTransferToLastOpenedLinkOnLastOpenedSession(message: new Amqp.Message() { BodySection = new AmqpValue() { Value = liveMsgContent } }, nextIncomingId: 2); IMessageConsumer consumer = await session.CreateConsumerAsync(queue); // Add message listener, expect both messages as the filter is disabled testPeer.ExpectDisposition(settled: true, stateMatcher: Assert.IsInstanceOf <Accepted>, firstDeliveryId: 1, lastDeliveryId: 1); testPeer.ExpectDisposition(settled: true, stateMatcher: Assert.IsInstanceOf <Accepted>, firstDeliveryId: 2, lastDeliveryId: 2); CountdownEvent success = new CountdownEvent(2); consumer.Listener += m => { if (expiredMsgContent.Equals(((ITextMessage)m).Text) || liveMsgContent.Equals(((ITextMessage)m).Text)) { success.Signal(); } }; Assert.IsTrue(success.Wait(TimeSpan.FromSeconds(5)), "Didn't get expected messages"); testPeer.WaitForAllMatchersToComplete(3000); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(3000); } }
public async Task TestIncomingExpiredMessageGetsConsumedWhenFilterDisabled() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer, "?nms.localMessageExpiry=false"); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue queue = await session.GetQueueAsync("myQueue"); // Expected the consumer to attach and send credit, then send it an // already-expired message followed by a live message. testPeer.ExpectReceiverAttach(); string expiredMsgContent = "already-expired"; Amqp.Message message = CreateExpiredMessage(expiredMsgContent); testPeer.ExpectLinkFlowRespondWithTransfer(message: message); string liveMsgContent = "valid"; testPeer.SendTransferToLastOpenedLinkOnLastOpenedSession(message: new Amqp.Message() { BodySection = new AmqpValue() { Value = liveMsgContent } }, nextIncomingId: 2); IMessageConsumer consumer = await session.CreateConsumerAsync(queue); // Call receive, expect the expired message as we disabled local expiry. testPeer.ExpectDisposition(settled: true, stateMatcher: Assert.IsInstanceOf <Accepted>, firstDeliveryId: 1, lastDeliveryId: 1); IMessage m = await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(3000)); Assert.NotNull(m, "Message should have been received"); Assert.IsInstanceOf <ITextMessage>(m); Assert.AreEqual(expiredMsgContent, ((ITextMessage)m).Text, "Unexpected message content"); // Verify the other message is there testPeer.ExpectDisposition(settled: true, stateMatcher: Assert.IsInstanceOf <Accepted>, firstDeliveryId: 2, lastDeliveryId: 2); m = await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(3000)); Assert.NotNull(m, "Message should have been received"); Assert.IsInstanceOf <ITextMessage>(m); Assert.AreEqual(liveMsgContent, ((ITextMessage)m).Text, "Unexpected message content"); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(3000); } }
public async Task TestMessageListenerClosesItsConsumer() { var latch = new ManualResetEvent(false); var exceptionListenerFired = new ManualResetEvent(false); using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); connection.ExceptionListener += _ => exceptionListenerFired.Set(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue destination = await session.GetQueueAsync("myQueue"); await connection.StartAsync(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), 1); IMessageConsumer consumer = await session.CreateConsumerAsync(destination); testPeer.ExpectLinkFlow(drain: true, sendDrainFlowResponse: true, creditMatcher: credit => Assert.AreEqual(99, credit)); // Not sure if expected credit is right testPeer.ExpectDispositionThatIsAcceptedAndSettled(); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); Exception exception = null; consumer.Listener += message => { try { consumer.Close(); latch.Set(); } catch (Exception e) { exception = e; } }; Assert.True(latch.WaitOne(TimeSpan.FromMilliseconds(1000)), "Process not completed within given timeout"); Assert.IsNull(exception, "No error expected during close"); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectClose(); await connection.CloseAsync(); Assert.False(exceptionListenerFired.WaitOne(20), "Exception listener shouldn't have fired"); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestMessageListenerCallsSessionCloseThrowsIllegalStateException() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue destination = await session.GetQueueAsync("myQueue"); await connection.StartAsync(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), 1); IMessageConsumer consumer = await session.CreateConsumerAsync(destination); testPeer.ExpectDispositionThatIsAcceptedAndSettled(); ManualResetEvent latch = new ManualResetEvent(false); Exception exception = null; consumer.Listener += message => { try { session.Close(); } catch (Exception e) { exception = e; } latch.Set(); }; Assert.True(latch.WaitOne(3000), "Messages not received within given timeout."); Assert.IsNotNull(exception); Assert.IsInstanceOf <IllegalStateException>(exception); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); await consumer.CloseAsync(); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
public void TestMessageListenerCallsSessionCloseThrowsIllegalStateException() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = EstablishNMSContext(testPeer); context.Start(); testPeer.ExpectBegin(); IQueue destination = context.GetQueue("myQueue"); context.Start(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), 1); var consumer = context.CreateConsumer(destination); testPeer.ExpectDispositionThatIsAcceptedAndSettled(); ManualResetEvent latch = new ManualResetEvent(false); Exception exception = null; consumer.Listener += message => { try { context.Close(); } catch (Exception e) { exception = e; } latch.Set(); }; Assert.True(latch.WaitOne(3000), "Messages not received within given timeout."); Assert.IsNotNull(exception); Assert.IsInstanceOf <IllegalStateException>(exception); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); consumer.Close(); testPeer.ExpectEnd(); // testPeer.ExpectClose(); context.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestConnectionStartStop() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { int msgCount = 10; IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.ClientAcknowledge); IQueue queue = await session.GetQueueAsync("myQueue"); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithNullContent(), count: msgCount); var consumer = await session.CreateConsumerAsync(queue); for (int i = 0; i < 5; i++) { IMessage message = await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(1000)); Assert.IsNotNull(message); } // stop the connection, consumers shouldn't receive any more messages await connection.StopAsync(); // No messages should arrive to consumer as connection has been stopped Assert.IsNull(await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(100)), "Message arrived despite the fact, that the connection was stopped."); // restart the connection await connection.StartAsync(); // The second batch of messages should be delivered for (int i = 0; i < 5; i++) { IMessage message = await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(1000)); Assert.IsNotNull(message); } testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
private async Task DoReceiveMessageDeliveryTime(object setDeliveryTimeAnnotation, DateTime?expectedDeliveryTime) { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); var session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); var queue = await session.GetQueueAsync("myQueue"); var message = CreateMessageWithNullContent(); if (setDeliveryTimeAnnotation != null) { message.MessageAnnotations = message.MessageAnnotations ?? new MessageAnnotations(); message.MessageAnnotations[SymbolUtil.NMS_DELIVERY_TIME] = setDeliveryTimeAnnotation; } testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message); testPeer.ExpectDisposition(true, (deliveryState) => { }); DateTime startingTimeFrom = DateTime.UtcNow; var messageConsumer = await session.CreateConsumerAsync(queue); var receivedMessage = await messageConsumer.ReceiveAsync(TimeSpan.FromMilliseconds(3000)); DateTime receivingTime = DateTime.UtcNow; testPeer.WaitForAllMatchersToComplete(3000); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(3000); Assert.IsNotNull(receivedMessage); if (expectedDeliveryTime != null) { Assert.AreEqual(receivedMessage.NMSDeliveryTime, expectedDeliveryTime.Value); } else { Assert.LessOrEqual(receivedMessage.NMSDeliveryTime, receivingTime); Assert.GreaterOrEqual(receivedMessage.NMSDeliveryTime, startingTimeFrom); } } }
public async Task TestClientAcknowledgeMessagesAsync() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { int msgCount = 3; IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.ClientAcknowledge); IQueue queue = await session.GetQueueAsync("myQueue"); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithNullContent(), count: msgCount); IMessageConsumer consumer = await session.CreateConsumerAsync(queue); CountdownEvent latch = new CountdownEvent(3); IMessage lastReceivedMessage = null; consumer.Listener += message => { lastReceivedMessage = message; latch.Signal(); }; Assert.True(latch.Wait(2000)); for (int i = 0; i < msgCount; i++) { testPeer.ExpectDispositionThatIsAcceptedAndSettled(); } await lastReceivedMessage.AcknowledgeAsync(); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestRecoveredMessageShouldNotBeMutated() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.ClientAcknowledge); IQueue destination = await session.GetQueueAsync("myQueue"); string originalPayload = "testMessage"; testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: new Amqp.Message { BodySection = new AmqpValue() { Value = originalPayload } }, count: 1); IMessageConsumer consumer = await session.CreateConsumerAsync(destination); NmsTextMessage message = await consumer.ReceiveAsync() as NmsTextMessage; Assert.NotNull(message); message.IsReadOnlyBody = false; message.Text = message.Text + "Received"; await session.RecoverAsync(); ITextMessage recoveredMessage = await consumer.ReceiveAsync() as ITextMessage; Assert.IsNotNull(recoveredMessage); Assert.AreNotEqual(message.Text, recoveredMessage.Text); Assert.AreEqual(originalPayload, recoveredMessage.Text); Assert.AreNotSame(message, recoveredMessage); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestSetMessageListenerAfterStartAndSend() { int messageCount = 4; CountdownEvent latch = new CountdownEvent(messageCount); using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue destination = await session.GetQueueAsync("myQueue"); await connection.StartAsync(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), messageCount); IMessageConsumer consumer = await session.CreateConsumerAsync(destination); for (int i = 0; i < messageCount; i++) { testPeer.ExpectDispositionThatIsAcceptedAndSettled(); } consumer.Listener += message => latch.Signal(); Assert.True(latch.Wait(4000), "Messages not received within given timeout. Count remaining: " + latch.CurrentCount); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); await consumer.CloseAsync(); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestSessionCloseWaitsForAsyncDeliveryToComplete() { ManualResetEvent latch = new ManualResetEvent(false); using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue destination = await session.GetQueueAsync("myQueue"); await connection.StartAsync(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), count: 1); IMessageConsumer consumer = await session.CreateConsumerAsync(destination); testPeer.ExpectDispositionThatIsAcceptedAndSettled(); consumer.Listener += _ => { latch.Set(); Task.Delay(TimeSpan.FromMilliseconds(100)).GetAwaiter().GetResult(); }; Assert.True(latch.WaitOne(TimeSpan.FromMilliseconds(3000)), "Messages not received within given timeout."); testPeer.ExpectEnd(); await session.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestCreateProducerInOnMessage() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue destination = await session.GetQueueAsync("myQueue"); IQueue outbound = await session.GetQueueAsync("ForwardDest"); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), 1); testPeer.ExpectSenderAttach(); testPeer.ExpectTransfer(messageMatcher: Assert.NotNull); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); testPeer.ExpectDispositionThatIsAcceptedAndSettled(); IMessageConsumer consumer = await session.CreateConsumerAsync(destination); consumer.Listener += message => { IMessageProducer producer = session.CreateProducer(outbound); producer.Send(message); producer.Close(); }; testPeer.WaitForAllMatchersToComplete(10_000); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(2000); } }
public void TestSetMessageListenerAfterStartAndSend() { int messageCount = 4; CountdownEvent latch = new CountdownEvent(messageCount); using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = EstablishNMSContext(testPeer); context.Start(); testPeer.ExpectBegin(); IQueue destination = context.GetQueue("myQueue"); context.Start(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), messageCount); var consumer = context.CreateConsumer(destination); for (int i = 0; i < messageCount; i++) { testPeer.ExpectDispositionThatIsAcceptedAndSettled(); } consumer.Listener += message => latch.Signal(); Assert.True(latch.Wait(4000), "Messages not received within given timeout. Count remaining: " + latch.CurrentCount); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); consumer.Close(); testPeer.ExpectEnd(); testPeer.ExpectClose(); context.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
public void TestConsumerCloseWaitsForAsyncDeliveryToComplete() { ManualResetEvent latch = new ManualResetEvent(false); using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = EstablishNMSContext(testPeer); context.Start(); testPeer.ExpectBegin(); IQueue destination = context.GetQueue("myQueue"); context.Start(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), count: 1); var consumer = context.CreateConsumer(destination); testPeer.ExpectDispositionThatIsAcceptedAndSettled(); consumer.Listener += _ => { latch.Set(); Task.Delay(TimeSpan.FromMilliseconds(100)).GetAwaiter().GetResult(); }; Assert.True(latch.WaitOne(TimeSpan.FromMilliseconds(3000)), "Messages not received within given timeout."); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); consumer.Close(); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectEnd(); testPeer.ExpectClose(); context.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
public void TestClientAcknowledgeMessages() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { int msgCount = 3; 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: msgCount); IMessageConsumer consumer = session.CreateConsumer(queue); IMessage lastReceivedMessage = null; for (int i = 0; i < msgCount; i++) { lastReceivedMessage = consumer.Receive(); Assert.NotNull(lastReceivedMessage, "Message " + i + " was not received"); } for (int i = 0; i < msgCount; i++) { testPeer.ExpectDispositionThatIsAcceptedAndSettled(); } lastReceivedMessage.Acknowledge(); testPeer.WaitForAllMatchersToComplete(2000); testPeer.ExpectClose(); connection.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
public void TestCreateProducerInOnMessage() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = EstablishNMSContext(testPeer); context.Start(); testPeer.ExpectBegin(); IQueue destination = context.GetQueue("myQueue"); IQueue outbound = context.GetQueue("ForwardDest"); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithContent(), 1); testPeer.ExpectSenderAttach(); testPeer.ExpectTransfer(messageMatcher: Assert.NotNull); testPeer.ExpectDetach(expectClosed: true, sendResponse: true, replyClosed: true); testPeer.ExpectDispositionThatIsAcceptedAndSettled(); var consumer = context.CreateConsumer(destination); consumer.Listener += message => { var producer = context.CreateProducer(); producer.Send(outbound, message); producer.Close(); }; testPeer.WaitForAllMatchersToComplete(10_000); testPeer.ExpectEnd(); testPeer.ExpectClose(); context.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
public void TestRecoveredMessageShouldNotBeMutated() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = EstablishNMSContext(testPeer, acknowledgementMode: AcknowledgementMode.ClientAcknowledge); context.Start(); testPeer.ExpectBegin(); IQueue destination = context.GetQueue("myQueue"); string originalPayload = "testMessage"; testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: new Amqp.Message { BodySection = new AmqpValue() { Value = originalPayload } }, count: 1); var consumer = context.CreateConsumer(destination); NmsTextMessage message = consumer.Receive() as NmsTextMessage; Assert.NotNull(message); message.IsReadOnlyBody = false; message.Text = message.Text + "Received"; context.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); testPeer.ExpectEnd(); testPeer.ExpectClose(); context.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
public void TestReceiveBodyNoWait <T>(T inputValue) { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { var context = EstablishNMSContext(testPeer); ManualResetEvent beforeFlow = new ManualResetEvent(false); testPeer.ExpectBegin(); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(CreateMessageWithValueContent(inputValue), 1, false, false, false, false, (credit) => { beforeFlow.WaitOne(); }, 1); testPeer.ExpectDisposition(true, _ => { }); IQueue destination = context.GetQueue("myQueue"); var consumer = context.CreateConsumer(destination); T initialBody = consumer.ReceiveBodyNoWait <T>(); // Assert initially its null Assert.AreEqual(default(T), initialBody); // Release and allow link to flow beforeFlow.Set(); // Give short time to arrive Thread.Sleep(100); T body = consumer.ReceiveBodyNoWait <T>(); Assert.AreEqual(inputValue, body); Assert.AreNotSame(inputValue, body); testPeer.ExpectEnd(); testPeer.ExpectClose(); context.Close(); testPeer.WaitForAllMatchersToComplete(2000); } }
public async Task TestAutoAcknowledgeMessages() { using (TestAmqpPeer testPeer = new TestAmqpPeer()) { int msgCount = 6; IConnection connection = await EstablishConnectionAsync(testPeer); await connection.StartAsync(); testPeer.ExpectBegin(); ISession session = await connection.CreateSessionAsync(AcknowledgementMode.AutoAcknowledge); IQueue queue = await session.GetQueueAsync("myQueue"); testPeer.ExpectReceiverAttach(); testPeer.ExpectLinkFlowRespondWithTransfer(message: CreateMessageWithNullContent(), count: msgCount); IMessageConsumer consumer = await session.CreateConsumerAsync(queue); for (int i = 0; i < msgCount; i++) { testPeer.ExpectDispositionThatIsAcceptedAndSettled(); } for (int i = 0; i < msgCount; i++) { Assert.NotNull(await consumer.ReceiveAsync(TimeSpan.FromMilliseconds(3000)), $"Message {i} not received within given timeout."); } testPeer.WaitForAllMatchersToComplete(3000); testPeer.ExpectClose(); await connection.CloseAsync(); testPeer.WaitForAllMatchersToComplete(3000); } }