Python test suite: compatibility with Python 3.5+

"await" is a keyword as of PEP 492.

test/python_SUITE_data/src/ack.py

@@ -16,7 +16,7 @@ def test_ack_client(self):
                             headers={'prefetch-count': '10'})
         self.conn.send(destination, "test1")
         self.conn.send(destination, "test2")
-        self.assertTrue(self.listener.await(4), "initial message not received")
+        self.assertTrue(self.listener.wait(4), "initial message not received")
         self.assertEquals(2, len(self.listener.messages))
 
         # disconnect with no ack
@@ -31,7 +31,7 @@ def test_ack_client(self):
             self.subscribe_dest(conn2, destination, None,
                                 ack='client',
                                 headers={'prefetch-count': '10'})
-            self.assertTrue(listener2.await(), "message not received again")
+            self.assertTrue(listener2.wait(), "message not received again")
             self.assertEquals(2, len(listener2.messages))
 
             # now ack only the last message - expecting cumulative behaviour
@@ -46,7 +46,7 @@ def test_ack_client(self):
             listener3 = base.WaitableListener()
             conn3.set_listener('', listener3)
             self.subscribe_dest(conn3, destination, None)
-            self.assertFalse(listener3.await(3),
+            self.assertFalse(listener3.wait(3),
                              "unexpected message. ACK not working?")
         finally:
             conn3.disconnect()
@@ -61,7 +61,7 @@ def test_ack_client_individual(self):
                             headers={'prefetch-count': '10'})
         self.conn.send(destination, "test1")
         self.conn.send(destination, "test2")
-        self.assertTrue(self.listener.await(4), "Both initial messages not received")
+        self.assertTrue(self.listener.wait(4), "Both initial messages not received")
         self.assertEquals(2, len(self.listener.messages))
 
         # disconnect without acks
@@ -76,7 +76,7 @@ def test_ack_client_individual(self):
             self.subscribe_dest(conn2, destination, None,
                                 ack='client-individual',
                                 headers={'prefetch-count': '10'})
-            self.assertTrue(listener2.await(2.5), "Did not receive 2 messages")
+            self.assertTrue(listener2.wait(2.5), "Did not receive 2 messages")
             self.assertEquals(2, len(listener2.messages), "Not exactly 2 messages received")
 
             # now ack only the 'test2' message - expecting individual behaviour
@@ -99,7 +99,7 @@ def test_ack_client_individual(self):
             listener3.reset(2) ## expecting a single message, but wait for two
             conn3.set_listener('', listener3)
             self.subscribe_dest(conn3, destination, None)
-            self.assertFalse(listener3.await(2.5),
+            self.assertFalse(listener3.wait(2.5),
                              "Expected to see only one message. ACK not working?")
             self.assertEquals(1, len(listener3.messages), "Expecting exactly one message")
             self.assertEquals("test1", listener3.messages[0]['message'], "Unexpected message remains")
@@ -113,7 +113,7 @@ def test_ack_client_tx(self):
         self.listener.reset()
         self.subscribe_dest(self.conn, destination, None, ack='client')
         self.conn.send(destination, "test")
-        self.assertTrue(self.listener.await(3), "initial message not received")
+        self.assertTrue(self.listener.wait(3), "initial message not received")
         self.assertEquals(1, len(self.listener.messages))
 
         # disconnect with no ack
@@ -127,7 +127,7 @@ def test_ack_client_tx(self):
             conn2.set_listener('', listener2)
             conn2.begin(transaction=tx)
             self.subscribe_dest(conn2, destination, None, ack='client')
-            self.assertTrue(listener2.await(), "message not received again")
+            self.assertTrue(listener2.wait(), "message not received again")
             self.assertEquals(1, len(listener2.messages))
 
             # now ack
@@ -145,7 +145,7 @@ def test_ack_client_tx(self):
             listener3 = base.WaitableListener()
             conn3.set_listener('', listener3)
             self.subscribe_dest(conn3, destination, None)
-            self.assertFalse(listener3.await(3),
+            self.assertFalse(listener3.wait(3),
                              "unexpected message. TX ACK not working?")
         finally:
             conn3.disconnect()
@@ -162,7 +162,7 @@ def test_topic_prefetch(self):
         for x in range(10):
             self.conn.send(destination, "test" + str(x))
 
-        self.assertFalse(self.listener.await(3),
+        self.assertFalse(self.listener.wait(3),
                          "Should not have been able to see 6 messages")
         self.assertEquals(5, len(self.listener.messages))
 
@@ -174,12 +174,12 @@ def test_nack(self):
                             ack='client-individual')
         self.conn.send(destination, "nack-test")
 
-        self.assertTrue(self.listener.await(), "Not received message")
+        self.assertTrue(self.listener.wait(), "Not received message")
         message_id = self.listener.messages[0]['headers'][self.ack_id_source_header]
         self.listener.reset()
 
         self.nack_message(self.conn, message_id, None)
-        self.assertTrue(self.listener.await(), "Not received message after NACK")
+        self.assertTrue(self.listener.wait(), "Not received message after NACK")
         message_id = self.listener.messages[0]['headers'][self.ack_id_source_header]
         self.ack_message(self.conn, message_id, None)
 
@@ -195,12 +195,12 @@ def test_nack_multi(self):
         self.conn.send(destination, "nack-test1")
         self.conn.send(destination, "nack-test2")
 
-        self.assertTrue(self.listener.await(), "Not received messages")
+        self.assertTrue(self.listener.wait(), "Not received messages")
         message_id = self.listener.messages[1]['headers'][self.ack_id_source_header]
         self.listener.reset(2)
 
         self.nack_message(self.conn, message_id, None)
-        self.assertTrue(self.listener.await(), "Not received message again")
+        self.assertTrue(self.listener.wait(), "Not received message again")
         message_id = self.listener.messages[1]['headers'][self.ack_id_source_header]
         self.ack_message(self.conn, message_id, None)
 
@@ -211,12 +211,12 @@ def test_nack_without_requeueing(self):
                             ack='client-individual')
         self.conn.send(destination, "nack-test")
 
-        self.assertTrue(self.listener.await(), "Not received message")
+        self.assertTrue(self.listener.wait(), "Not received message")
         message_id = self.listener.messages[0]['headers'][self.ack_id_source_header]
         self.listener.reset()
 
         self.conn.send_frame("NACK", {self.ack_id_header: message_id, "requeue": False})
-        self.assertFalse(self.listener.await(4), "Received message after NACK with requeue = False")
+        self.assertFalse(self.listener.wait(4), "Received message after NACK with requeue = False")
 
 class TestAck11(TestAck):
 

test/python_SUITE_data/src/amqp_headers.py

@@ -23,7 +23,7 @@ def test_headers_to_stomp(self):
         amqp_chan.basic_publish(exchange='', routing_key=queueName, body='Hello World!', properties=amqp_props)
 
         # check if we receive the message from the STOMP subscription
-        self.assertTrue(self.listener.await(2), "initial message not received")
+        self.assertTrue(self.listener.wait(2), "initial message not received")
         self.assertEquals(1, len(self.listener.messages))
         msg = self.listener.messages[0]
         self.assertEquals('Hello World!', msg['message'])

test/python_SUITE_data/src/base.py

@@ -88,7 +88,7 @@ def create_subscriber_connection(self, dest):
        listener = WaitableListener()
        conn.set_listener('', listener)
        self.subscribe_dest(conn, dest, None, receipt="sub.receipt")
-       listener.await()
+       listener.wait()
        self.assertEquals(1, len(listener.receipts))
        listener.reset()
        return conn, listener
@@ -114,7 +114,7 @@ def simple_test_send_rec(self, dest, headers={}):
         self.subscribe_dest(self.conn, dest, None)
         self.conn.send(dest, "foo", headers=headers)
 
-        self.assertTrue(self.listener.await(), "Timeout, no message received")
+        self.assertTrue(self.listener.wait(), "Timeout, no message received")
 
         # assert no errors
         if len(self.listener.errors) > 0:
@@ -128,9 +128,9 @@ def simple_test_send_rec(self, dest, headers={}):
 
    def assertListener(self, errMsg, numMsgs=0, numErrs=0, numRcts=0, timeout=10):
         if numMsgs + numErrs + numRcts > 0:
-            self._assertTrue(self.listener.await(timeout), errMsg + " (#awaiting)")
+            self._assertTrue(self.listener.wait(timeout), errMsg + " (#awaiting)")
         else:
-            self._assertFalse(self.listener.await(timeout), errMsg + " (#awaiting)")
+            self._assertFalse(self.listener.wait(timeout), errMsg + " (#awaiting)")
         self._assertEquals(numMsgs, len(self.listener.messages), errMsg + " (#messages)")
         self._assertEquals(numErrs, len(self.listener.errors), errMsg + " (#errors)")
         self._assertEquals(numRcts, len(self.listener.receipts), errMsg + " (#receipts)")
@@ -203,8 +203,8 @@ def reset(self, count=1):
         if self.debug:
             self.print_state('(reset listener--new state)')
 
-    def await(self, timeout=10):
-        return self.latch.await(timeout)
+    def wait(self, timeout=10):
+        return self.latch.wait(timeout)
 
     def print_state(self, hdr="", full=False):
         print(hdr)
@@ -233,7 +233,7 @@ def countdown(self):
          self.cond.notify_all()
       self.cond.release()
 
-   def await(self, timeout=None):
+   def wait(self, timeout=None):
       try:
          self.cond.acquire()
          if self.count == 0:

test/python_SUITE_data/src/connect_options.py

@@ -19,7 +19,7 @@ def test_implicit_connect(self):
                             receipt='implicit')
 
         try:
-            self.assertTrue(listener.await(5))
+            self.assertTrue(listener.wait(5))
             self.assertEquals(1, len(listener.receipts),
                               'Missing receipt. Likely not connected')
             self.assertEquals('implicit', listener.receipts[0]['headers']['receipt-id'])
@@ -37,7 +37,7 @@ def test_default_user(self):
         new_conn.start()
         new_conn.connect()
         try:
-            self.assertFalse(listener.await(3)) # no error back
+            self.assertFalse(listener.wait(3)) # no error back
             self.assertTrue(new_conn.is_connected())
         finally:
             new_conn.disconnect()