Clarify semantic of waits in connection tests.

Author: aaugustin

tests/asyncio/test_connection.py

@@ -49,56 +49,54 @@ async def asyncTearDown(self):
 
     # Test helpers built upon RecordingProtocol and InterceptingConnection.
 
-    async def assertFrameSent(self, frame):
-        """Check that a single frame was sent."""
-        # Let the remote side process messages.
+    async def wait_for_remote_side(self):
+        """Wait for the remote side to process messages."""
         # Two runs of the event loop are required for answering pings.
         await asyncio.sleep(0)
         await asyncio.sleep(0)
+
+    async def assertFrameSent(self, frame):
+        """Check that a single frame was sent."""
+        await self.wait_for_remote_side()
         self.assertEqual(self.remote_connection.protocol.get_frames_rcvd(), [frame])
 
     async def assertFramesSent(self, frames):
         """Check that several frames were sent."""
-        # Let the remote side process messages.
-        # Two runs of the event loop are required for answering pings.
-        await asyncio.sleep(0)
-        await asyncio.sleep(0)
+        await self.wait_for_remote_side()
         self.assertEqual(self.remote_connection.protocol.get_frames_rcvd(), frames)
 
     async def assertNoFrameSent(self):
         """Check that no frame was sent."""
-        # Run the event loop twice for consistency with assertFrameSent.
-        await asyncio.sleep(0)
-        await asyncio.sleep(0)
+        await self.wait_for_remote_side()
         self.assertEqual(self.remote_connection.protocol.get_frames_rcvd(), [])
 
     @contextlib.asynccontextmanager
     async def delay_frames_rcvd(self, delay):
         """Delay frames before they're received by the connection."""
         with self.remote_connection.delay_frames_sent(delay):
             yield
-            await asyncio.sleep(MS)  # let the remote side process messages
+            await self.wait_for_remote_side()
 
     @contextlib.asynccontextmanager
     async def delay_eof_rcvd(self, delay):
         """Delay EOF before it's received by the connection."""
         with self.remote_connection.delay_eof_sent(delay):
             yield
-            await asyncio.sleep(MS)  # let the remote side process messages
+            await self.wait_for_remote_side()
 
     @contextlib.asynccontextmanager
     async def drop_frames_rcvd(self):
         """Drop frames before they're received by the connection."""
         with self.remote_connection.drop_frames_sent():
             yield
-            await asyncio.sleep(MS)  # let the remote side process messages
+            await self.wait_for_remote_side()
 
     @contextlib.asynccontextmanager
     async def drop_eof_rcvd(self):
         """Drop EOF before it's received by the connection."""
         with self.remote_connection.drop_eof_sent():
             yield
-            await asyncio.sleep(MS)  # let the remote side process messages
+            await self.wait_for_remote_side()
 
     # Test __aenter__ and __aexit__.
 
@@ -1009,9 +1007,8 @@ async def test_keepalive_times_out(self, getrandbits):
         async with self.drop_frames_rcvd():
             self.connection.start_keepalive()
             # 4 ms: keepalive() sends a ping frame.
-            await asyncio.sleep(4 * MS)
-            # Exiting the context manager sleeps for 1 ms.
             # 4.x ms: a pong frame is dropped.
+            await asyncio.sleep(5 * MS)
         # 6 ms: no pong frame is received; the connection is closed.
         await asyncio.sleep(2 * MS)
         # 7 ms: check that the connection is closed.
@@ -1026,8 +1023,7 @@ async def test_keepalive_ignores_timeout(self, getrandbits):
             self.connection.start_keepalive()
             # 4 ms: keepalive() sends a ping frame.
             # 4.x ms: a pong frame is dropped.
-            await asyncio.sleep(4 * MS)
-            # Exiting the context manager sleeps for 1 ms.
+            await asyncio.sleep(5 * MS)
         # 6 ms: no pong frame is received; the connection remains open.
         await asyncio.sleep(2 * MS)
         # 7 ms: check that the connection is still open.
@@ -1038,19 +1034,19 @@ async def test_keepalive_terminates_while_sleeping(self):
         self.connection.ping_interval = 3 * MS
         self.connection.start_keepalive()
         await asyncio.sleep(MS)
+        self.assertFalse(self.connection.keepalive_task.done())
         await self.connection.close()
         self.assertTrue(self.connection.keepalive_task.done())
 
     async def test_keepalive_terminates_while_waiting_for_pong(self):
         """keepalive task terminates while waiting to receive a pong."""
         self.connection.ping_interval = MS
-        self.connection.ping_timeout = 3 * MS
+        self.connection.ping_timeout = 4 * MS
         async with self.drop_frames_rcvd():
             self.connection.start_keepalive()
             # 1 ms: keepalive() sends a ping frame.
             # 1.x ms: a pong frame is dropped.
-            await asyncio.sleep(MS)
-            # Exiting the context manager sleeps for 1 ms.
+            await asyncio.sleep(2 * MS)
         # 2 ms: close the connection before ping_timeout elapses.
         await self.connection.close()
         self.assertTrue(self.connection.keepalive_task.done())
@@ -1062,8 +1058,7 @@ async def test_keepalive_reports_errors(self):
             self.connection.start_keepalive()
             # 2 ms: keepalive() sends a ping frame.
             # 2.x ms: a pong frame is dropped.
-            await asyncio.sleep(2 * MS)
-            # Exiting the context manager sleeps for 1 ms.
+            await asyncio.sleep(3 * MS)
         # 3 ms: inject a fault: raise an exception in the pending pong waiter.
         pong_received = next(iter(self.connection.pending_pings.values()))[0]
         with self.assertLogs("websockets", logging.ERROR) as logs:

tests/sync/test_connection.py

@@ -44,43 +44,49 @@ def tearDown(self):
 
     # Test helpers built upon RecordingProtocol and InterceptingConnection.
 
+    def wait_for_remote_side(self):
+        """Wait for the remote side to process messages."""
+        # We don't have a way to tell if the remote side is blocked on I/O.
+        # The sync tests still run faster than the asyncio and trio tests :-)
+        time.sleep(MS)
+
     def assertFrameSent(self, frame):
         """Check that a single frame was sent."""
-        time.sleep(MS)  # let the remote side process messages
+        self.wait_for_remote_side()
         self.assertEqual(self.remote_connection.protocol.get_frames_rcvd(), [frame])
 
     def assertNoFrameSent(self):
         """Check that no frame was sent."""
-        time.sleep(MS)  # let the remote side process messages
+        self.wait_for_remote_side()
         self.assertEqual(self.remote_connection.protocol.get_frames_rcvd(), [])
 
     @contextlib.contextmanager
     def delay_frames_rcvd(self, delay):
         """Delay frames before they're received by the connection."""
         with self.remote_connection.delay_frames_sent(delay):
             yield
-            time.sleep(MS)  # let the remote side process messages
+            self.wait_for_remote_side()
 
     @contextlib.contextmanager
     def delay_eof_rcvd(self, delay):
         """Delay EOF before it's received by the connection."""
         with self.remote_connection.delay_eof_sent(delay):
             yield
-            time.sleep(MS)  # let the remote side process messages
+            self.wait_for_remote_side()
 
     @contextlib.contextmanager
     def drop_frames_rcvd(self):
         """Drop frames before they're received by the connection."""
         with self.remote_connection.drop_frames_sent():
             yield
-            time.sleep(MS)  # let the remote side process messages
+            self.wait_for_remote_side()
 
     @contextlib.contextmanager
     def drop_eof_rcvd(self):
         """Drop EOF before it's received by the connection."""
         with self.remote_connection.drop_eof_sent():
             yield
-            time.sleep(MS)  # let the remote side process messages
+            self.wait_for_remote_side()
 
     # Test __enter__ and __exit__.
 
@@ -736,9 +742,9 @@ def test_keepalive_times_out(self, getrandbits):
         with self.drop_frames_rcvd():
             self.connection.start_keepalive()
             # 4 ms: keepalive() sends a ping frame.
+            # 4.x ms: a pong frame is dropped.
             time.sleep(4 * MS)
             # Exiting the context manager sleeps for 1 ms.
-            # 4.x ms: a pong frame is dropped.
         # 6 ms: no pong frame is received; the connection is closed.
         time.sleep(2 * MS)
         # 7 ms: check that the connection is closed.
@@ -752,9 +758,9 @@ def test_keepalive_ignores_timeout(self, getrandbits):
         with self.drop_frames_rcvd():
             self.connection.start_keepalive()
             # 4 ms: keepalive() sends a ping frame.
+            # 4.x ms: a pong frame is dropped.
             time.sleep(4 * MS)
             # Exiting the context manager sleeps for 1 ms.
-            # 4.x ms: a pong frame is dropped.
         # 6 ms: no pong frame is received; the connection remains open.
         time.sleep(2 * MS)
         # 7 ms: check that the connection is still open.
@@ -765,16 +771,18 @@ def test_keepalive_terminates_while_sleeping(self):
         self.connection.ping_interval = 3 * MS
         self.connection.start_keepalive()
         time.sleep(MS)
+        self.assertTrue(self.connection.keepalive_thread.is_alive())
         self.connection.close()
         self.connection.keepalive_thread.join(MS)
         self.assertFalse(self.connection.keepalive_thread.is_alive())
 
     def test_keepalive_terminates_when_sending_ping_fails(self):
         """keepalive task terminates when sending a ping fails."""
-        self.connection.ping_interval = 1 * MS
+        self.connection.ping_interval = MS
         self.connection.start_keepalive()
         with self.drop_eof_rcvd(), self.drop_frames_rcvd():
             self.connection.close()
+            # Exiting the context managers sleeps for 2 ms.
         self.assertFalse(self.connection.keepalive_thread.is_alive())
 
     def test_keepalive_terminates_while_waiting_for_pong(self):