qpid-dispatch git commit: DISPATCH-927 - System test for fix. Makes sure both detaches are echoed back

[gm...@apache.org]

Repository: qpid-dispatch
Updated Branches:
  refs/heads/master 945cac6fd -> 7e4dfd733


DISPATCH-927 - System test for fix. Makes sure both detaches are echoed back


Project: http://git-wip-us.apache.org/repos/asf/qpid-dispatch/repo
Commit: http://git-wip-us.apache.org/repos/asf/qpid-dispatch/commit/7e4dfd73
Tree: http://git-wip-us.apache.org/repos/asf/qpid-dispatch/tree/7e4dfd73
Diff: http://git-wip-us.apache.org/repos/asf/qpid-dispatch/diff/7e4dfd73

Branch: refs/heads/master
Commit: 7e4dfd7334ea994719e178cba78998c1933f60dc
Parents: 945cac6
Author: Fernando Giorgetti <fg...@redhat.com>
Authored: Mon May 7 22:31:36 2018 -0300
Committer: Fernando Giorgetti <fg...@redhat.com>
Committed: Mon May 7 22:37:42 2018 -0300

----------------------------------------------------------------------
 tests/system_tests_link_routes.py | 110 +++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/qpid-dispatch/blob/7e4dfd73/tests/system_tests_link_routes.py
----------------------------------------------------------------------
diff --git a/tests/system_tests_link_routes.py b/tests/system_tests_link_routes.py
index 1f95e4f..da48d6d 100644
--- a/tests/system_tests_link_routes.py
+++ b/tests/system_tests_link_routes.py
@@ -32,6 +32,7 @@ from system_tests_drain_support import DrainMessagesHandler, DrainOneMessageHand
 from qpid_dispatch.management.client import Node
 from qpid_dispatch.management.error import NotFoundStatus
 
+
 class LinkRouteTest(TestCase):
     """
     Tests the linkRoute property of the dispatch router.
@@ -732,6 +733,18 @@ class LinkRouteTest(TestCase):
     def test_same_name_route_senders_through_C(self):
         self._multi_link_send_receive(self.routers[2].addresses[0], self.routers[0].addresses[0], "send_through_C")
 
+    def test_echo_detach_received(self):
+        """
+        Create two receivers to link routed address org.apache.dev
+        Create a sender to the same address that the receiver is listening on and send 100 messages.
+        After the receivers receive 10 messages each, the receivers will detach and expect to receive ten
+        detaches in response.
+
+        """
+        test = EchoDetachReceived(self.routers[2].addresses[0], self.routers[2].addresses[0])
+        test.run()
+        self.assertEqual(None, test.error)
+
 
 class Timeout(object):
     def __init__(self, parent):
@@ -1102,6 +1115,103 @@ class DetachMixedCloseTest(MessagingHandler):
     def run(self):
         Container(self).run()
 
+
+# Test to validate fix for DISPATCH-927
+class EchoDetachReceived(MessagingHandler):
+    def __init__(self, sender_address, recv_address):
+        super(EchoDetachReceived, self).__init__()
+        self.sender_address = sender_address
+        self.recv_address = recv_address
+        self.dest = "org.apache.dev"
+        self.num_msgs = 100
+        self.num_receivers = 10
+        self.msgs_sent = 0
+        self.receiver_conn = None
+        self.sender_conn = None
+        self.sender = None
+        self.receiver_dict = {}
+        self.error = None
+        self.receiver_attaches = 0
+        self.timer = None
+        self.sender_attached = False
+        self.received_msgs_dict = {}
+        self.receiver_detach_dict = {}
+        self.num_detaches_echoed = 0
+
+    @property
+    def msgs_received(self):
+        return sum(self.received_msgs_dict.values())
+
+    def timeout(self):
+
+        self.bail("Timeout Expired: msgs_sent=%d msgs_received=%d, number of detaches received=%d"
+                  % (self.msgs_sent, self.msgs_received, self.num_detaches_echoed))
+
+    def on_start(self, event):
+        self.timer = event.reactor.schedule(TIMEOUT, Timeout(self))
+
+        # Create two separate connections for sender and receivers
+        self.receiver_conn = event.container.connect(self.recv_address)
+        self.sender_conn = event.container.connect(self.sender_address)
+        for i in range(self.num_receivers):
+            name = "R%d" % i
+            self.receiver_dict[name] = event.container.create_receiver(self.receiver_conn, self.dest, name=name)
+            self.received_msgs_dict[name] = 0
+
+    def bail(self, text=None):
+        self.error = text
+        self.sender_conn.close()
+        self.receiver_conn.close()
+        self.timer.cancel()
+
+    def on_link_opened(self, event):
+        if event.receiver:
+            if event.receiver.name in list(self.receiver_dict):
+                self.receiver_attaches+=1
+            # The response receiver attaches have been received. The receiver sent attaches which was link routed
+            # all the way to the 'broker' router and the response attaches have come back.
+            # It is now time to create the sender.
+            if self.receiver_attaches == self.num_receivers:
+                self.sender = event.container.create_sender(self.sender_conn, self.dest)
+
+        elif event.sender:
+            if not self.sender_attached:
+                if event.sender == self.sender:
+                    # The sender attaches were link routed as well and the response attach has been received.
+                    self.sender_attached = True
+
+    def on_sendable(self, event):
+        # The sender will send 100 messages
+        if self.receiver_attaches == self.num_receivers and self.sender_attached:
+            if self.msgs_sent < self.num_msgs:
+                msg = Message(body="Hello World")
+                self.sender.send(msg)
+                self.msgs_sent += 1
+
+    def on_message(self, event):
+        if event.receiver and event.receiver.name in list(self.receiver_dict):
+            self.received_msgs_dict[event.receiver.name] += 1
+
+        if sum(self.received_msgs_dict.values()) == self.num_msgs:
+            # The receivers have received a total of 100 messages. Close the receivers. The detach sent by these
+            # receivers will travel all the way over the link route and the 'broker' router will respond with a
+            # detach
+            for receiver in list(self.receiver_dict):
+                self.receiver_dict[receiver].close()
+
+    def on_link_closed(self, event):
+        if event.receiver.name in list(self.receiver_dict) and event.receiver.name not in list(self.receiver_detach_dict):
+            self.receiver_detach_dict[event.receiver.name] = event.receiver
+            self.num_detaches_echoed += 1
+
+        # Terminate the test only if both detach frames have been received.
+        if all(receiver in list(self.receiver_detach_dict) for receiver in list(self.receiver_dict)):
+            self.bail()
+
+    def run(self):
+        Container(self).run()
+
+
 class TerminusAddrTest(MessagingHandler):
     """
     This tests makes sure that the link route address is visible in the output of qdstat -l command.


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org