| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| using System; |
| using System.Text; |
| using log4net; |
| using Apache.Qpid.Messaging; |
| |
| namespace Apache.Qpid.Integration.Tests.interop.TestCases |
| { |
| /// <summary> |
| /// Implements test case 2, basic P2P. Sends/receives a specified number of messages to a specified route on the |
| /// default direct exchange. Produces reports on the actual number of messages sent/received. |
| /// |
| /// <p><table id="crc"><caption>CRC Card</caption> |
| /// <tr><th> Responsibilities <th> Collaborations |
| /// <tr><td> Supply the name of the test case that this implements. |
| /// <tr><td> Accept/Reject invites based on test parameters. |
| /// <tr><td> Adapt to assigned roles. |
| /// <tr><td> Send required number of test messages. |
| /// <tr><td> Generate test reports. |
| /// </table> |
| /// </summary> |
| public class TestCase2BasicP2P : InteropClientTestCase |
| { |
| /// <summary> Used for debugging. </summary> |
| private static ILog log = LogManager.GetLogger(typeof(TestCase2BasicP2P)); |
| |
| /// <summary> Holds the count of test messages received. </summary> |
| private int messageCount; |
| |
| /// <summary> The role to be played by the test. </summary> |
| private Roles role; |
| |
| /// <summary> The number of test messages to send. </summary> |
| private int numMessages; |
| |
| /// <summary> The routing key to send them to on the default direct exchange. </summary> |
| private string sendDestination; |
| |
| /// <summary> The connection to send the test messages on. </summary> |
| private IConnection connection; |
| |
| /// <summary> The session to send the test messages on. </summary> |
| private IChannel channel; |
| |
| /// <summary> The producer to send the test messages with. </summary> |
| private IMessagePublisher publisher; |
| |
| /// <summary> |
| /// Should provide the name of the test case that this class implements. The exact names are defined in the |
| /// interop testing spec. |
| /// </summary> |
| /// |
| /// <returns> The name of the test case that this implements. </returns> |
| public String GetName() |
| { |
| log.Debug("public String GetName(): called"); |
| |
| return "TC2_BasicP2P"; |
| } |
| |
| /// <summary> |
| /// Determines whether the test invite that matched this test case is acceptable. |
| /// </summary> |
| /// |
| /// <param name="inviteMessage"> The invitation to accept or reject. </param> |
| /// |
| /// <returns> <tt>true</tt> to accept the invitation, <tt>false</tt> to reject it. </returns> |
| public bool AcceptInvite(IMessage inviteMessage) |
| { |
| log.Debug("public boolean AcceptInvite(Message inviteMessage = " + inviteMessage + "): called"); |
| |
| // All invites are acceptable. |
| return true; |
| } |
| |
| /// <summary> |
| /// Assigns the role to be played by this test case. The test parameters are fully specified in the |
| /// assignment message. When this method return the test case will be ready to execute. |
| /// </summary> |
| /// |
| /// <param name="role"> The role to be played; sender or receiver. </param> |
| /// <param name="assignRoleMessage"> The role assingment message, contains the full test parameters. </param> |
| public void AssignRole(Roles role, IMessage assignRoleMessage) |
| { |
| log.Debug("public void AssignRole(Roles role = " + role + ", Message assignRoleMessage = " + assignRoleMessage |
| + "): called"); |
| |
| // Reset the message count for a new test. |
| messageCount = 0; |
| |
| // Take note of the role to be played. |
| this.role = role; |
| |
| // Create a new connection to pass the test messages on. |
| connection = |
| TestClient.CreateConnection(TestClient.brokerUrl, TestClient.virtualHost); |
| channel = connection.CreateChannel(false, AcknowledgeMode.AutoAcknowledge); |
| |
| // Extract and retain the test parameters. |
| numMessages = assignRoleMessage.Headers.GetInt("P2P_NUM_MESSAGES"); |
| string queueAndKeyName = assignRoleMessage.Headers.GetString("P2P_QUEUE_AND_KEY_NAME"); |
| channel.DeclareQueue(queueAndKeyName, false, true, true); |
| channel.Bind(queueAndKeyName, ExchangeNameDefaults.DIRECT, queueAndKeyName); |
| sendDestination = queueAndKeyName; |
| |
| log.Debug("numMessages = " + numMessages); |
| log.Debug("sendDestination = " + sendDestination); |
| log.Debug("role = " + role); |
| |
| switch (role) |
| { |
| // Check if the sender role is being assigned, and set up a message producer if so. |
| case Roles.SENDER: |
| publisher = channel.CreatePublisherBuilder() |
| .WithExchangeName(ExchangeNameDefaults.DIRECT) |
| .WithRoutingKey(sendDestination) |
| .Create(); |
| break; |
| |
| // Otherwise the receiver role is being assigned, so set this up to listen for messages. |
| case Roles.RECEIVER: |
| IMessageConsumer consumer = channel.CreateConsumerBuilder(sendDestination).Create(); |
| consumer.OnMessage += new MessageReceivedDelegate(OnMessage); |
| |
| break; |
| } |
| |
| connection.Start(); |
| } |
| |
| /// <summary> Performs the test case actions. </summary> |
| public void Start() |
| { |
| log.Debug("public void start(): called"); |
| |
| // Check that the sender role is being performed. |
| if (role == Roles.SENDER) |
| { |
| IMessage testMessage = channel.CreateTextMessage("test"); |
| |
| for (int i = 0; i < numMessages; i++) |
| { |
| publisher.Send(testMessage); |
| |
| // Increment the message count. |
| messageCount++; |
| } |
| } |
| } |
| |
| /// <summary> |
| /// Gets a report on the actions performed by the test case in its assigned role. |
| /// </summary> |
| /// |
| /// <param name="session"> The session to create the report message in. </param> |
| /// |
| /// <returns> The report message. </returns> |
| public IMessage GetReport(IChannel channel) |
| { |
| log.Debug("public Message GetReport(IChannel channel): called"); |
| |
| // Close the test connection. |
| //connection.Stop(); |
| |
| // Generate a report message containing the count of the number of messages passed. |
| IMessage report = channel.CreateMessage(); |
| //report.Headers.SetString("CONTROL_TYPE", "REPORT"); |
| report.Headers.SetInt("MESSAGE_COUNT", messageCount); |
| |
| return report; |
| } |
| |
| /// <summary> |
| /// Counts incoming test messages. |
| /// </summary> |
| /// |
| /// <param name="message"> The incoming test message. </param> |
| public void OnMessage(IMessage message) |
| { |
| log.Debug("public void OnMessage(IMessage message = " + message + "): called"); |
| |
| // Increment the message count. |
| messageCount++; |
| } |
| } |
| } |