Address review

Author: NoahStapp

test/asynchronous/test_discovery_and_monitoring.py

@@ -27,7 +27,7 @@
 
 from pymongo.asynchronous.pool import AsyncConnection
 from pymongo.operations import _Op
-from pymongo.server_selectors import readable_server_selector
+from pymongo.server_selectors import writable_server_selector
 
 sys.path[0:0] = [""]
 
@@ -387,24 +387,25 @@ async def test_connection_close_does_not_block_other_operations(self):
             minPoolSize=10,
         )
         server = await (await client._get_topology()).select_server(
-            readable_server_selector, _Op.TEST
+            writable_server_selector, _Op.TEST
         )
         await async_wait_until(
             lambda: len(server._pool.conns) == 10,
             "pool initialized with 10 connections",
         )
 
         await client.db.test.insert_one({"x": 1})
-        close_delay = 0.05
+        close_delay = 0.1
         latencies = []
+        should_exit = []
 
         async def run_task():
             while True:
                 start_time = time.monotonic()
                 await client.db.test.find_one({})
                 elapsed = time.monotonic() - start_time
                 latencies.append(elapsed)
-                if elapsed >= close_delay:
+                if should_exit:
                     break
                 await asyncio.sleep(0.001)
 
@@ -432,8 +433,9 @@ async def mock_close(self, reason):
                 await listener.async_wait_for_event(monitoring.ServerHeartbeatFailedEvent, 1)
             # Wait until all idle connections are closed to simulate real-world conditions
             await listener.async_wait_for_event(monitoring.ConnectionClosedEvent, 10)
+            should_exit.append(True)
             # No operation latency should not significantly exceed close_delay
-            self.assertLessEqual(max(latencies), close_delay * 2.0)
+            self.assertLessEqual(max(latencies), close_delay * 5.0)
         finally:
             AsyncConnection.close_conn = original_close
             await task.join()

test/test_discovery_and_monitoring.py

@@ -26,7 +26,7 @@
 from test.helpers import ConcurrentRunner
 
 from pymongo.operations import _Op
-from pymongo.server_selectors import readable_server_selector
+from pymongo.server_selectors import writable_server_selector
 from pymongo.synchronous.pool import Connection
 
 sys.path[0:0] = [""]
@@ -386,23 +386,24 @@ def test_connection_close_does_not_block_other_operations(self):
             heartbeatFrequencyMS=500,
             minPoolSize=10,
         )
-        server = (client._get_topology()).select_server(readable_server_selector, _Op.TEST)
+        server = (client._get_topology()).select_server(writable_server_selector, _Op.TEST)
         wait_until(
             lambda: len(server._pool.conns) == 10,
             "pool initialized with 10 connections",
         )
 
         client.db.test.insert_one({"x": 1})
-        close_delay = 0.05
+        close_delay = 0.1
         latencies = []
+        should_exit = []
 
         def run_task():
             while True:
                 start_time = time.monotonic()
                 client.db.test.find_one({})
                 elapsed = time.monotonic() - start_time
                 latencies.append(elapsed)
-                if elapsed >= close_delay:
+                if should_exit:
                     break
                 time.sleep(0.001)
 
@@ -430,8 +431,9 @@ def mock_close(self, reason):
                 listener.wait_for_event(monitoring.ServerHeartbeatFailedEvent, 1)
             # Wait until all idle connections are closed to simulate real-world conditions
             listener.wait_for_event(monitoring.ConnectionClosedEvent, 10)
+            should_exit.append(True)
             # No operation latency should not significantly exceed close_delay
-            self.assertLessEqual(max(latencies), close_delay * 2.0)
+            self.assertLessEqual(max(latencies), close_delay * 5.0)
         finally:
             Connection.close_conn = original_close
             task.join()