From 938d9da08ce98a8b3633a1cf9cf308e41c2c12d7 Mon Sep 17 00:00:00 2001
From: Jeffrey 'Alex' Clark <aclark@aclark.net>
Date: Thu, 23 Apr 2026 17:58:04 -0400
Subject: [PATCH 1/7] PYTHON-5781 Increase coverage for network_layer.py

Add test/test_network_layer.py with 56 unit tests covering:
- PyMongoProtocol: process_header (including ProtocolError paths),
  process_compression_header, get_buffer (all state branches),
  buffer_updated (state machine), close/connection_lost lifecycle
- NetworkingInterfaceBase: abstract method NotImplementedError raises
- NetworkingInterface: socket delegation methods
- AsyncNetworkingInterface: transport/protocol delegation
- sendall: trivial delegation
- _async_socket_receive: success and connection-closed paths
---
 test/test_network_layer.py | 650 +++++++++++++++++++++++++++++++++++++
 1 file changed, 650 insertions(+)
 create mode 100644 test/test_network_layer.py

diff --git a/test/test_network_layer.py b/test/test_network_layer.py
new file mode 100644
index 0000000000..99148c82e7
--- /dev/null
+++ b/test/test_network_layer.py
@@ -0,0 +1,650 @@
+# Copyright 2026-present MongoDB, Inc.
+#
+# Licensed 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
+#
+# https://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.
+
+"""Unit tests for network_layer.py.
+
+Tests cover pure-function and state-machine logic that does not require
+a live socket or MongoDB server.  Live-endpoint paths are exercised by
+integration tests in test_client.py / test_ssl.py.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import struct
+import sys
+import unittest
+from unittest.mock import AsyncMock, MagicMock, patch
+
+sys.path[0:0] = [""]
+
+from pymongo.common import MAX_MESSAGE_SIZE
+from pymongo.errors import ProtocolError
+from pymongo.network_layer import (
+    AsyncNetworkingInterface,
+    NetworkingInterface,
+    NetworkingInterfaceBase,
+    PyMongoProtocol,
+    _async_socket_receive,
+    sendall,
+)
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _run(coro):
+    """Run a coroutine synchronously for testing."""
+    return asyncio.run(coro)
+
+
+async def _make_protocol(timeout=None):
+    """Create a PyMongoProtocol with a stubbed transport."""
+    proto = PyMongoProtocol(timeout=timeout)
+    mock_transport = MagicMock()
+    mock_transport.is_closing.return_value = False
+    proto.transport = mock_transport
+    return proto
+
+
+def _make_header(length, request_id, response_to, op_code):
+    """Pack a 16-byte MongoDB wire-protocol header."""
+    return struct.pack("<iiii", length, request_id, response_to, op_code)
+
+
+# ---------------------------------------------------------------------------
+# sendall
+# ---------------------------------------------------------------------------
+
+
+class TestSendall(unittest.TestCase):
+    def test_delegates_to_sock_sendall(self):
+        mock_sock = MagicMock()
+        sendall(mock_sock, b"hello")
+        mock_sock.sendall.assert_called_once_with(b"hello")
+
+
+# ---------------------------------------------------------------------------
+# NetworkingInterfaceBase
+# ---------------------------------------------------------------------------
+
+
+class TestNetworkingInterfaceBase(unittest.TestCase):
+    def setUp(self):
+        self.base = NetworkingInterfaceBase(MagicMock())
+
+    def test_gettimeout_raises(self):
+        with self.assertRaises(NotImplementedError):
+            _ = self.base.gettimeout
+
+    def test_settimeout_raises(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.settimeout(1.0)
+
+    def test_close_raises(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.close()
+
+    def test_is_closing_raises(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.is_closing()
+
+    def test_get_conn_raises(self):
+        with self.assertRaises(NotImplementedError):
+            _ = self.base.get_conn
+
+    def test_sock_raises(self):
+        with self.assertRaises(NotImplementedError):
+            _ = self.base.sock
+
+
+# ---------------------------------------------------------------------------
+# NetworkingInterface
+# ---------------------------------------------------------------------------
+
+
+class TestNetworkingInterface(unittest.TestCase):
+    def setUp(self):
+        self.mock_sock = MagicMock()
+        self.iface = NetworkingInterface(self.mock_sock)
+
+    def test_gettimeout_delegates(self):
+        self.mock_sock.gettimeout.return_value = 5.0
+        self.assertEqual(self.iface.gettimeout(), 5.0)
+
+    def test_settimeout_delegates(self):
+        self.iface.settimeout(3.0)
+        self.mock_sock.settimeout.assert_called_once_with(3.0)
+
+    def test_close_delegates(self):
+        self.iface.close()
+        self.mock_sock.close.assert_called_once()
+
+    def test_is_closing_delegates(self):
+        self.mock_sock.is_closing.return_value = True
+        self.assertTrue(self.iface.is_closing())
+
+    def test_fileno_delegates(self):
+        self.mock_sock.fileno.return_value = 42
+        self.assertEqual(self.iface.fileno(), 42)
+
+    def test_recv_into_delegates(self):
+        buf = bytearray(10)
+        self.mock_sock.recv_into.return_value = 7
+        result = self.iface.recv_into(buf)
+        self.assertEqual(result, 7)
+        self.mock_sock.recv_into.assert_called_once_with(buf)
+
+    def test_get_conn_returns_socket(self):
+        self.assertIs(self.iface.get_conn, self.mock_sock)
+
+    def test_sock_returns_socket(self):
+        self.assertIs(self.iface.sock, self.mock_sock)
+
+
+# ---------------------------------------------------------------------------
+# AsyncNetworkingInterface
+# ---------------------------------------------------------------------------
+
+
+class TestAsyncNetworkingInterface(unittest.TestCase):
+    def _make_iface(self):
+        mock_transport = MagicMock()
+        mock_protocol = MagicMock()
+        mock_protocol.gettimeout = 10.0
+        return AsyncNetworkingInterface((mock_transport, mock_protocol))
+
+    def test_gettimeout_returns_protocol_timeout(self):
+        iface = self._make_iface()
+        self.assertEqual(iface.gettimeout, 10.0)
+
+    def test_settimeout_delegates_to_protocol(self):
+        iface = self._make_iface()
+        iface.settimeout(7.0)
+        iface.conn[1].settimeout.assert_called_once_with(7.0)
+
+    def test_is_closing_delegates_to_transport(self):
+        iface = self._make_iface()
+        iface.conn[0].is_closing.return_value = False
+        self.assertFalse(iface.is_closing())
+
+    def test_get_conn_returns_protocol(self):
+        iface = self._make_iface()
+        self.assertIs(iface.get_conn, iface.conn[1])
+
+    def test_sock_returns_transport_socket(self):
+        iface = self._make_iface()
+        sentinel = object()
+        iface.conn[0].get_extra_info.return_value = sentinel
+        self.assertIs(iface.sock, sentinel)
+        iface.conn[0].get_extra_info.assert_called_once_with("socket")
+
+
+# ---------------------------------------------------------------------------
+# PyMongoProtocol — settimeout / gettimeout
+# ---------------------------------------------------------------------------
+
+
+class TestPyMongoProtocolTimeout(unittest.TestCase):
+    def test_initial_timeout_from_constructor(self):
+        result = _run(_make_protocol(timeout=3.0))
+        self.assertEqual(result.gettimeout, 3.0)
+
+    def test_settimeout_updates_value(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto.settimeout(7.5)
+            return proto.gettimeout
+
+        self.assertEqual(_run(_test()), 7.5)
+
+    def test_default_timeout_is_none(self):
+        result = _run(_make_protocol())
+        self.assertIsNone(result.gettimeout)
+
+
+# ---------------------------------------------------------------------------
+# PyMongoProtocol — process_header
+# ---------------------------------------------------------------------------
+
+
+class TestPyMongoProtocolProcessHeader(unittest.TestCase):
+    def _run_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
+        async def _test():
+            proto = await _make_protocol()
+            proto._max_message_size = max_size
+            proto._header = memoryview(bytearray(header_bytes))
+            return proto.process_header()
+
+        return _run(_test())
+
+    def test_normal_op_msg(self):
+        # length=32, op_code=2013 (OP_MSG) → body = 32-16 = 16
+        hdr = _make_header(32, 1, 99, 2013)
+        body_len, op_code, response_to, expecting_compression = self._run_with_header(hdr)
+        self.assertEqual(body_len, 16)
+        self.assertEqual(op_code, 2013)
+        self.assertEqual(response_to, 99)
+        self.assertFalse(expecting_compression)
+
+    def test_op_compressed(self):
+        # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
+        hdr = _make_header(35, 1, 0, 2012)
+        body_len, op_code, response_to, expecting_compression = self._run_with_header(hdr)
+        self.assertEqual(body_len, 10)
+        self.assertEqual(op_code, 2012)
+        self.assertTrue(expecting_compression)
+
+    def test_op_compressed_length_too_small_raises(self):
+        # OP_COMPRESSED with length <= 25
+        hdr = _make_header(25, 1, 0, 2012)
+        with self.assertRaises(ProtocolError):
+            self._run_with_header(hdr)
+
+    def test_non_compressed_length_too_small_raises(self):
+        # Non-compressed with length <= 16
+        hdr = _make_header(16, 1, 0, 2013)
+        with self.assertRaises(ProtocolError):
+            self._run_with_header(hdr)
+
+    def test_length_exceeds_max_raises(self):
+        hdr = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
+        with self.assertRaises(ProtocolError):
+            self._run_with_header(hdr)
+
+    def test_op_reply_op_code(self):
+        # OP_REPLY=1 is a valid non-compressed opcode
+        hdr = _make_header(20, 0, 0, 1)
+        body_len, op_code, response_to, expecting_compression = self._run_with_header(hdr)
+        self.assertEqual(body_len, 4)
+        self.assertEqual(op_code, 1)
+        self.assertFalse(expecting_compression)
+
+
+# ---------------------------------------------------------------------------
+# PyMongoProtocol — process_compression_header
+# ---------------------------------------------------------------------------
+
+
+class TestPyMongoProtocolProcessCompressionHeader(unittest.TestCase):
+    def test_returns_op_code_and_compressor_id(self):
+        async def _test():
+            proto = await _make_protocol()
+            # op_code=2013, unknown int=0, compressor_id=1 (snappy)
+            data = struct.pack("<iiB", 2013, 0, 1)
+            proto._compression_header = memoryview(bytearray(data))
+            return proto.process_compression_header()
+
+        op_code, compressor_id = _run(_test())
+        self.assertEqual(op_code, 2013)
+        self.assertEqual(compressor_id, 1)
+
+    def test_zlib_compressor_id(self):
+        async def _test():
+            proto = await _make_protocol()
+            data = struct.pack("<iiB", 2013, 0, 2)
+            proto._compression_header = memoryview(bytearray(data))
+            return proto.process_compression_header()
+
+        _, compressor_id = _run(_test())
+        self.assertEqual(compressor_id, 2)
+
+
+# ---------------------------------------------------------------------------
+# PyMongoProtocol — get_buffer
+# ---------------------------------------------------------------------------
+
+
+class TestPyMongoProtocolGetBuffer(unittest.TestCase):
+    def test_expecting_header_returns_full_header_slice(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            proto._header_index = 0
+            return len(proto.get_buffer(0))
+
+        self.assertEqual(_run(_test()), 16)
+
+    def test_expecting_header_partial_returns_remaining(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            proto._header_index = 8
+            return len(proto.get_buffer(0))
+
+        self.assertEqual(_run(_test()), 8)
+
+    def test_expecting_compression_returns_compression_slice(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            proto._compression_index = 0
+            return len(proto.get_buffer(0))
+
+        self.assertEqual(_run(_test()), 9)
+
+    def test_expecting_compression_partial(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            proto._compression_index = 5
+            return len(proto.get_buffer(0))
+
+        self.assertEqual(_run(_test()), 4)
+
+    def test_message_body_returns_remaining_slice(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message = memoryview(bytearray(100))
+            proto._message_index = 0
+            return len(proto.get_buffer(0))
+
+        self.assertEqual(_run(_test()), 100)
+
+    def test_connection_lost_allocates_drain_buffer(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._connection_lost = True
+            proto._message = None
+            return len(proto.get_buffer(0))
+
+        self.assertEqual(_run(_test()), 2**14)
+
+    def test_connection_lost_reuses_existing_buffer(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._connection_lost = True
+            proto._message = memoryview(bytearray(50))
+            return len(proto.get_buffer(0))
+
+        self.assertEqual(_run(_test()), 50)
+
+
+# ---------------------------------------------------------------------------
+# PyMongoProtocol — buffer_updated
+# ---------------------------------------------------------------------------
+
+
+class TestPyMongoProtocolBufferUpdated(unittest.TestCase):
+    def test_zero_bytes_closes_connection(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto.buffer_updated(0)
+            return proto._connection_lost
+
+        self.assertTrue(_run(_test()))
+
+    def test_connection_lost_returns_early(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._connection_lost = True
+            proto._header_index = 3
+            proto.buffer_updated(5)
+            return proto._header_index  # must remain 3
+
+        self.assertEqual(_run(_test()), 3)
+
+    def test_partial_header_increments_index(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            proto._header_index = 0
+            proto.buffer_updated(8)
+            return proto._header_index
+
+        self.assertEqual(_run(_test()), 8)
+
+    def test_full_header_transitions_to_message(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            hdr = _make_header(32, 1, 0, 2013)
+            proto._header = memoryview(bytearray(hdr))
+            proto._header_index = 0
+            proto.buffer_updated(16)
+            return proto._expecting_header, proto._message_size
+
+        expecting_header, message_size = _run(_test())
+        self.assertFalse(expecting_header)
+        self.assertEqual(message_size, 16)  # 32 - 16
+
+    def test_invalid_header_closes_connection(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            # length=16 (not > 16) triggers ProtocolError
+            hdr = _make_header(16, 1, 0, 2013)
+            proto._header = memoryview(bytearray(hdr))
+            proto._header_index = 0
+            proto.buffer_updated(16)
+            return proto._connection_lost
+
+        self.assertTrue(_run(_test()))
+
+    def test_compression_header_processing(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            comp_hdr = struct.pack("<iiB", 2013, 0, 2)
+            proto._compression_header = memoryview(bytearray(comp_hdr))
+            proto._compression_index = 0
+            proto.buffer_updated(9)
+            return proto._expecting_compression, proto._op_code, proto._compressor_id
+
+        expecting_compression, op_code, compressor_id = _run(_test())
+        self.assertFalse(expecting_compression)
+        self.assertEqual(op_code, 2013)
+        self.assertEqual(compressor_id, 2)
+
+    def test_partial_compression_header_increments_index(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            proto._compression_index = 0
+            proto.buffer_updated(4)
+            return proto._compression_index, proto._expecting_compression
+
+        idx, still_expecting = _run(_test())
+        self.assertEqual(idx, 4)
+        self.assertTrue(still_expecting)
+
+    def test_message_complete_resolves_pending_future(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message_size = 10
+            proto._message = memoryview(bytearray(10))
+            proto._message_index = 0
+            proto._op_code = 2013
+            proto._compressor_id = None
+            proto._response_to = 42
+
+            fut = asyncio.get_running_loop().create_future()
+            proto._pending_messages.append(fut)
+
+            proto.buffer_updated(10)
+            return fut.done(), fut.result()
+
+        done, result = _run(_test())
+        self.assertTrue(done)
+        op_code, compressor_id, response_to, _ = result
+        self.assertEqual(op_code, 2013)
+        self.assertIsNone(compressor_id)
+        self.assertEqual(response_to, 42)
+
+    def test_message_complete_no_pending_creates_new_future(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message_size = 5
+            proto._message = memoryview(bytearray(5))
+            proto._message_index = 0
+            proto._op_code = 2013
+            proto._compressor_id = None
+            proto._response_to = 0
+
+            # No pending futures; buffer_updated creates one internally
+            self.assertFalse(proto._pending_messages)
+            proto.buffer_updated(5)
+            # The auto-created future should be in _done_messages
+            return len(proto._done_messages)
+
+        self.assertEqual(_run(_test()), 1)
+
+    def test_partial_message_increments_index(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message_size = 20
+            proto._message = memoryview(bytearray(20))
+            proto._message_index = 0
+            proto.buffer_updated(7)
+            return proto._message_index
+
+        self.assertEqual(_run(_test()), 7)
+
+
+# ---------------------------------------------------------------------------
+# PyMongoProtocol — close / connection_lost
+# ---------------------------------------------------------------------------
+
+
+class TestPyMongoProtocolClose(unittest.TestCase):
+    def test_close_sets_connection_lost_flag(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto.close()
+            return proto._connection_lost
+
+        self.assertTrue(_run(_test()))
+
+    def test_close_aborts_transport(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto.close()
+            return proto.transport.abort.called
+
+        self.assertTrue(_run(_test()))
+
+    def test_connection_lost_resolves_closed_future(self):
+        async def _test():
+            proto = await _make_protocol()
+            self.assertFalse(proto._closed.done())
+            proto.connection_lost(None)
+            return proto._closed.done()
+
+        self.assertTrue(_run(_test()))
+
+    def test_connection_lost_twice_does_not_raise(self):
+        async def _test():
+            proto = await _make_protocol()
+            proto.connection_lost(None)
+            proto.connection_lost(None)  # second call must not raise InvalidStateError
+
+        _run(_test())  # should not raise
+
+    def test_close_with_exception_propagates_to_pending(self):
+        async def _test():
+            proto = await _make_protocol()
+            fut = asyncio.get_running_loop().create_future()
+            proto._pending_messages.append(fut)
+            exc = OSError("connection reset")
+            proto.close(exc)
+            try:
+                await fut
+                return None
+            except OSError as e:
+                return str(e)
+
+        result = _run(_test())
+        self.assertIn("connection reset", result)
+
+
+# ---------------------------------------------------------------------------
+# _async_socket_receive
+# ---------------------------------------------------------------------------
+
+
+class TestAsyncSocketReceive(unittest.TestCase):
+    def test_reads_full_data_in_one_call(self):
+        data = b"hello world!"
+        length = len(data)
+
+        async def _test():
+            mock_sock = MagicMock()
+            loop = asyncio.get_running_loop()
+
+            async def fake_recv_into(sock, buf):
+                buf[:length] = data
+                return length
+
+            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+                result = await _async_socket_receive(mock_sock, length, loop)
+            return bytes(result)
+
+        self.assertEqual(_run(_test()), data)
+
+    def test_reads_data_in_multiple_chunks(self):
+        data = b"abcdefgh"
+        length = len(data)
+        chunk1, chunk2 = data[:4], data[4:]
+
+        async def _test():
+            mock_sock = MagicMock()
+            loop = asyncio.get_running_loop()
+            calls = [0]
+
+            async def fake_recv_into(sock, buf):
+                if calls[0] == 0:
+                    buf[: len(chunk1)] = chunk1
+                    calls[0] += 1
+                    return len(chunk1)
+                buf[: len(chunk2)] = chunk2
+                calls[0] += 1
+                return len(chunk2)
+
+            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+                result = await _async_socket_receive(mock_sock, length, loop)
+            return bytes(result)
+
+        self.assertEqual(_run(_test()), data)
+
+    def test_raises_on_connection_closed(self):
+        async def _test():
+            mock_sock = MagicMock()
+            loop = asyncio.get_running_loop()
+
+            async def fake_recv_into(sock, buf):
+                return 0  # connection closed
+
+            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+                await _async_socket_receive(mock_sock, 10, loop)
+
+        with self.assertRaises(OSError) as ctx:
+            _run(_test())
+        self.assertIn("connection closed", str(ctx.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()

From 4aec47f942dfaf2e54a2c49de37189dbd21f51f3 Mon Sep 17 00:00:00 2001
From: Jeffrey 'Alex' Clark <aclark@aclark.net>
Date: Thu, 23 Apr 2026 18:09:38 -0400
Subject: [PATCH 2/7] PYTHON-5781 Nit fixes

- Fix mypy type error in test_network_layer.py
- Use 'from test import unittest', remove self-evident docstrings from helpers
- Fix inaccurate comment: second field in compression header is uncompressed_size
---
 test/test_network_layer.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/test/test_network_layer.py b/test/test_network_layer.py
index 99148c82e7..daf0dff185 100644
--- a/test/test_network_layer.py
+++ b/test/test_network_layer.py
@@ -24,11 +24,12 @@
 import asyncio
 import struct
 import sys
-import unittest
 from unittest.mock import AsyncMock, MagicMock, patch
 
 sys.path[0:0] = [""]
 
+from test import unittest
+
 from pymongo.common import MAX_MESSAGE_SIZE
 from pymongo.errors import ProtocolError
 from pymongo.network_layer import (
@@ -45,13 +46,11 @@
 # ---------------------------------------------------------------------------
 
 
-def _run(coro):
-    """Run a coroutine synchronously for testing."""
-    return asyncio.run(coro)
+def _run(coroutine):
+    return asyncio.run(coroutine)
 
 
 async def _make_protocol(timeout=None):
-    """Create a PyMongoProtocol with a stubbed transport."""
     proto = PyMongoProtocol(timeout=timeout)
     mock_transport = MagicMock()
     mock_transport.is_closing.return_value = False
@@ -60,7 +59,6 @@ async def _make_protocol(timeout=None):
 
 
 def _make_header(length, request_id, response_to, op_code):
-    """Pack a 16-byte MongoDB wire-protocol header."""
     return struct.pack("<iiii", length, request_id, response_to, op_code)
 
 
@@ -141,7 +139,7 @@ def test_fileno_delegates(self):
         self.assertEqual(self.iface.fileno(), 42)
 
     def test_recv_into_delegates(self):
-        buf = bytearray(10)
+        buf = memoryview(bytearray(10))
         self.mock_sock.recv_into.return_value = 7
         result = self.iface.recv_into(buf)
         self.assertEqual(result, 7)
@@ -282,7 +280,7 @@ class TestPyMongoProtocolProcessCompressionHeader(unittest.TestCase):
     def test_returns_op_code_and_compressor_id(self):
         async def _test():
             proto = await _make_protocol()
-            # op_code=2013, unknown int=0, compressor_id=1 (snappy)
+            # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
             proto._compression_header = memoryview(bytearray(data))
             return proto.process_compression_header()

From 0335f822e967147aba226e726b38bd84efe1e6a1 Mon Sep 17 00:00:00 2001
From: Jeffrey 'Alex' Clark <aclark@aclark.net>
Date: Fri, 1 May 2026 17:53:05 -0400
Subject: [PATCH 3/7] PYTHON-5781 Async split for test_network_layer.py

- Add test/asynchronous/test_network_layer.py as the async source of truth
  with AsyncUnitTest and _IS_SYNC = False
- Regenerate test/test_network_layer.py via synchro from the async source
- Register test_network_layer.py in synchro converted_tests (alpha order)
- Add "AsyncMock": "MagicMock" replacement after AsyncMockPool to avoid
  substring collision in translate_docstrings
---
 test/asynchronous/test_network_layer.py | 500 ++++++++++++++++++++
 test/test_network_layer.py              | 579 +++++++++---------------
 tools/synchro.py                        |   2 +
 3 files changed, 717 insertions(+), 364 deletions(-)
 create mode 100644 test/asynchronous/test_network_layer.py

diff --git a/test/asynchronous/test_network_layer.py b/test/asynchronous/test_network_layer.py
new file mode 100644
index 0000000000..fa207be49f
--- /dev/null
+++ b/test/asynchronous/test_network_layer.py
@@ -0,0 +1,500 @@
+# Copyright 2026-present MongoDB, Inc.
+#
+# Licensed 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
+#
+# https://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.
+
+"""Unit tests for network_layer.py."""
+
+from __future__ import annotations
+
+import asyncio
+import struct
+import sys
+from unittest.mock import AsyncMock, MagicMock, patch
+
+sys.path[0:0] = [""]
+
+from test.asynchronous import AsyncUnitTest, unittest
+
+from pymongo.common import MAX_MESSAGE_SIZE
+from pymongo.errors import ProtocolError
+from pymongo.network_layer import (
+    AsyncNetworkingInterface,
+    NetworkingInterface,
+    NetworkingInterfaceBase,
+    PyMongoProtocol,
+    _async_socket_receive,
+    sendall,
+)
+
+_IS_SYNC = False
+
+
+async def _make_protocol(timeout=None):
+    proto = PyMongoProtocol(timeout=timeout)
+    mock_transport = MagicMock()
+    mock_transport.is_closing.return_value = False
+    proto.transport = mock_transport
+    return proto
+
+
+def _make_header(length, request_id, response_to, op_code):
+    return struct.pack("<iiii", length, request_id, response_to, op_code)
+
+
+class TestSendall(AsyncUnitTest):
+    def test_delegates_to_sock_sendall(self):
+        mock_sock = MagicMock()
+        sendall(mock_sock, b"hello")
+        mock_sock.sendall.assert_called_once_with(b"hello")
+
+
+class TestNetworkingInterfaceBase(AsyncUnitTest):
+    def setUp(self):
+        self.base = NetworkingInterfaceBase(MagicMock())
+
+    def test_gettimeout_raises(self):
+        with self.assertRaises(NotImplementedError):
+            _ = self.base.gettimeout
+
+    def test_settimeout_raises(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.settimeout(1.0)
+
+    def test_close_raises(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.close()
+
+    def test_is_closing_raises(self):
+        with self.assertRaises(NotImplementedError):
+            self.base.is_closing()
+
+    def test_get_conn_raises(self):
+        with self.assertRaises(NotImplementedError):
+            _ = self.base.get_conn
+
+    def test_sock_raises(self):
+        with self.assertRaises(NotImplementedError):
+            _ = self.base.sock
+
+
+class TestNetworkingInterface(AsyncUnitTest):
+    def setUp(self):
+        self.mock_sock = MagicMock()
+        self.iface = NetworkingInterface(self.mock_sock)
+
+    def test_gettimeout_delegates(self):
+        self.mock_sock.gettimeout.return_value = 5.0
+        self.assertEqual(self.iface.gettimeout(), 5.0)
+
+    def test_settimeout_delegates(self):
+        self.iface.settimeout(3.0)
+        self.mock_sock.settimeout.assert_called_once_with(3.0)
+
+    def test_close_delegates(self):
+        self.iface.close()
+        self.mock_sock.close.assert_called_once()
+
+    def test_is_closing_delegates(self):
+        self.mock_sock.is_closing.return_value = True
+        self.assertTrue(self.iface.is_closing())
+
+    def test_fileno_delegates(self):
+        self.mock_sock.fileno.return_value = 42
+        self.assertEqual(self.iface.fileno(), 42)
+
+    def test_recv_into_delegates(self):
+        buf = memoryview(bytearray(10))
+        self.mock_sock.recv_into.return_value = 7
+        result = self.iface.recv_into(buf)
+        self.assertEqual(result, 7)
+        self.mock_sock.recv_into.assert_called_once_with(buf)
+
+    def test_get_conn_returns_socket(self):
+        self.assertIs(self.iface.get_conn, self.mock_sock)
+
+    def test_sock_returns_socket(self):
+        self.assertIs(self.iface.sock, self.mock_sock)
+
+    if not _IS_SYNC:
+
+        def _make_async_iface(self):
+            mock_transport = MagicMock()
+            mock_protocol = MagicMock()
+            mock_protocol.gettimeout = 10.0
+            return AsyncNetworkingInterface((mock_transport, mock_protocol))
+
+        def test_async_gettimeout_returns_protocol_timeout(self):
+            iface = self._make_async_iface()
+            self.assertEqual(iface.gettimeout, 10.0)
+
+        def test_async_settimeout_delegates_to_protocol(self):
+            iface = self._make_async_iface()
+            iface.settimeout(7.0)
+            iface.conn[1].settimeout.assert_called_once_with(7.0)
+
+        def test_async_is_closing_delegates_to_transport(self):
+            iface = self._make_async_iface()
+            iface.conn[0].is_closing.return_value = False
+            self.assertFalse(iface.is_closing())
+
+        def test_async_get_conn_returns_protocol(self):
+            iface = self._make_async_iface()
+            self.assertIs(iface.get_conn, iface.conn[1])
+
+        def test_async_sock_returns_transport_socket(self):
+            iface = self._make_async_iface()
+            sentinel = object()
+            iface.conn[0].get_extra_info.return_value = sentinel
+            self.assertIs(iface.sock, sentinel)
+            iface.conn[0].get_extra_info.assert_called_once_with("socket")
+
+
+class TestPyMongoProtocolTimeout(AsyncUnitTest):
+    if not _IS_SYNC:
+
+        async def test_initial_timeout_from_constructor(self):
+            proto = await _make_protocol(timeout=3.0)
+            self.assertEqual(proto.gettimeout, 3.0)
+
+        async def test_settimeout_updates_value(self):
+            proto = await _make_protocol()
+            proto.settimeout(7.5)
+            self.assertEqual(proto.gettimeout, 7.5)
+
+        async def test_default_timeout_is_none(self):
+            proto = await _make_protocol()
+            self.assertIsNone(proto.gettimeout)
+
+
+class TestPyMongoProtocolProcessHeader(AsyncUnitTest):
+    if not _IS_SYNC:
+
+        async def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
+            proto = await _make_protocol()
+            proto._max_message_size = max_size
+            proto._header = memoryview(bytearray(header_bytes))
+            return proto
+
+        async def test_normal_op_msg(self):
+            hdr = _make_header(32, 1, 99, 2013)
+            proto = await self._make_proto_with_header(hdr)
+            body_len, op_code, response_to, expecting_compression = proto.process_header()
+            self.assertEqual(body_len, 16)
+            self.assertEqual(op_code, 2013)
+            self.assertEqual(response_to, 99)
+            self.assertFalse(expecting_compression)
+
+        async def test_op_compressed(self):
+            # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
+            hdr = _make_header(35, 1, 0, 2012)
+            proto = await self._make_proto_with_header(hdr)
+            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            self.assertEqual(body_len, 10)
+            self.assertEqual(op_code, 2012)
+            self.assertTrue(expecting_compression)
+
+        async def test_op_compressed_length_too_small_raises(self):
+            hdr = _make_header(25, 1, 0, 2012)
+            proto = await self._make_proto_with_header(hdr)
+            with self.assertRaises(ProtocolError):
+                proto.process_header()
+
+        async def test_non_compressed_length_too_small_raises(self):
+            hdr = _make_header(16, 1, 0, 2013)
+            proto = await self._make_proto_with_header(hdr)
+            with self.assertRaises(ProtocolError):
+                proto.process_header()
+
+        async def test_length_exceeds_max_raises(self):
+            hdr = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
+            proto = await self._make_proto_with_header(hdr)
+            with self.assertRaises(ProtocolError):
+                proto.process_header()
+
+        async def test_op_reply_op_code(self):
+            hdr = _make_header(20, 0, 0, 1)
+            proto = await self._make_proto_with_header(hdr)
+            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            self.assertEqual(body_len, 4)
+            self.assertEqual(op_code, 1)
+            self.assertFalse(expecting_compression)
+
+
+class TestPyMongoProtocolProcessCompressionHeader(AsyncUnitTest):
+    if not _IS_SYNC:
+
+        async def test_returns_op_code_and_compressor_id(self):
+            proto = await _make_protocol()
+            # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
+            data = struct.pack("<iiB", 2013, 0, 1)
+            proto._compression_header = memoryview(bytearray(data))
+            op_code, compressor_id = proto.process_compression_header()
+            self.assertEqual(op_code, 2013)
+            self.assertEqual(compressor_id, 1)
+
+        async def test_zlib_compressor_id(self):
+            proto = await _make_protocol()
+            data = struct.pack("<iiB", 2013, 0, 2)
+            proto._compression_header = memoryview(bytearray(data))
+            _, compressor_id = proto.process_compression_header()
+            self.assertEqual(compressor_id, 2)
+
+
+class TestPyMongoProtocolGetBuffer(AsyncUnitTest):
+    if not _IS_SYNC:
+
+        async def test_expecting_header_returns_full_header_slice(self):
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            proto._header_index = 0
+            self.assertEqual(len(proto.get_buffer(0)), 16)
+
+        async def test_expecting_header_partial_returns_remaining(self):
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            proto._header_index = 8
+            self.assertEqual(len(proto.get_buffer(0)), 8)
+
+        async def test_expecting_compression_returns_compression_slice(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            proto._compression_index = 0
+            self.assertEqual(len(proto.get_buffer(0)), 9)
+
+        async def test_expecting_compression_partial(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            proto._compression_index = 5
+            self.assertEqual(len(proto.get_buffer(0)), 4)
+
+        async def test_message_body_returns_remaining_slice(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message = memoryview(bytearray(100))
+            proto._message_index = 0
+            self.assertEqual(len(proto.get_buffer(0)), 100)
+
+        async def test_connection_lost_allocates_drain_buffer(self):
+            proto = await _make_protocol()
+            proto._connection_lost = True
+            proto._message = None
+            self.assertEqual(len(proto.get_buffer(0)), 2**14)
+
+        async def test_connection_lost_reuses_existing_buffer(self):
+            proto = await _make_protocol()
+            proto._connection_lost = True
+            proto._message = memoryview(bytearray(50))
+            self.assertEqual(len(proto.get_buffer(0)), 50)
+
+
+class TestPyMongoProtocolBufferUpdated(AsyncUnitTest):
+    if not _IS_SYNC:
+
+        async def test_zero_bytes_closes_connection(self):
+            proto = await _make_protocol()
+            proto.buffer_updated(0)
+            self.assertTrue(proto._connection_lost)
+
+        async def test_connection_lost_returns_early(self):
+            proto = await _make_protocol()
+            proto._connection_lost = True
+            proto._header_index = 3
+            proto.buffer_updated(5)
+            self.assertEqual(proto._header_index, 3)
+
+        async def test_partial_header_increments_index(self):
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            proto._header_index = 0
+            proto.buffer_updated(8)
+            self.assertEqual(proto._header_index, 8)
+
+        async def test_full_header_transitions_to_message(self):
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            hdr = _make_header(32, 1, 0, 2013)
+            proto._header = memoryview(bytearray(hdr))
+            proto._header_index = 0
+            proto.buffer_updated(16)
+            self.assertFalse(proto._expecting_header)
+            self.assertEqual(proto._message_size, 16)
+
+        async def test_invalid_header_closes_connection(self):
+            proto = await _make_protocol()
+            proto._expecting_header = True
+            # length=16 (not > 16) triggers ProtocolError
+            hdr = _make_header(16, 1, 0, 2013)
+            proto._header = memoryview(bytearray(hdr))
+            proto._header_index = 0
+            proto.buffer_updated(16)
+            self.assertTrue(proto._connection_lost)
+
+        async def test_compression_header_processing(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            comp_hdr = struct.pack("<iiB", 2013, 0, 2)
+            proto._compression_header = memoryview(bytearray(comp_hdr))
+            proto._compression_index = 0
+            proto.buffer_updated(9)
+            self.assertFalse(proto._expecting_compression)
+            self.assertEqual(proto._op_code, 2013)
+            self.assertEqual(proto._compressor_id, 2)
+
+        async def test_partial_compression_header_increments_index(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = True
+            proto._compression_index = 0
+            proto.buffer_updated(4)
+            self.assertEqual(proto._compression_index, 4)
+            self.assertTrue(proto._expecting_compression)
+
+        async def test_message_complete_resolves_pending_future(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message_size = 10
+            proto._message = memoryview(bytearray(10))
+            proto._message_index = 0
+            proto._op_code = 2013
+            proto._compressor_id = None
+            proto._response_to = 42
+
+            fut = asyncio.get_running_loop().create_future()
+            proto._pending_messages.append(fut)
+
+            proto.buffer_updated(10)
+            self.assertTrue(fut.done())
+            op_code, compressor_id, response_to, _ = fut.result()
+            self.assertEqual(op_code, 2013)
+            self.assertIsNone(compressor_id)
+            self.assertEqual(response_to, 42)
+
+        async def test_message_complete_no_pending_creates_new_future(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message_size = 5
+            proto._message = memoryview(bytearray(5))
+            proto._message_index = 0
+            proto._op_code = 2013
+            proto._compressor_id = None
+            proto._response_to = 0
+
+            self.assertFalse(proto._pending_messages)
+            proto.buffer_updated(5)
+            self.assertEqual(len(proto._done_messages), 1)
+
+        async def test_partial_message_increments_index(self):
+            proto = await _make_protocol()
+            proto._expecting_header = False
+            proto._expecting_compression = False
+            proto._message_size = 20
+            proto._message = memoryview(bytearray(20))
+            proto._message_index = 0
+            proto.buffer_updated(7)
+            self.assertEqual(proto._message_index, 7)
+
+
+class TestPyMongoProtocolClose(AsyncUnitTest):
+    if not _IS_SYNC:
+
+        async def test_close_sets_connection_lost_flag(self):
+            proto = await _make_protocol()
+            proto.close()
+            self.assertTrue(proto._connection_lost)
+
+        async def test_close_aborts_transport(self):
+            proto = await _make_protocol()
+            proto.close()
+            self.assertTrue(proto.transport.abort.called)
+
+        async def test_connection_lost_resolves_closed_future(self):
+            proto = await _make_protocol()
+            self.assertFalse(proto._closed.done())
+            proto.connection_lost(None)
+            self.assertTrue(proto._closed.done())
+
+        async def test_connection_lost_twice_does_not_raise(self):
+            proto = await _make_protocol()
+            proto.connection_lost(None)
+            proto.connection_lost(None)
+
+        async def test_close_with_exception_propagates_to_pending(self):
+            proto = await _make_protocol()
+            fut = asyncio.get_running_loop().create_future()
+            proto._pending_messages.append(fut)
+            exc = OSError("connection reset")
+            proto.close(exc)
+            with self.assertRaises(OSError) as ctx:
+                await fut
+            self.assertIn("connection reset", str(ctx.exception))
+
+
+class TestAsyncSocketReceive(AsyncUnitTest):
+    if not _IS_SYNC:
+
+        async def test_reads_full_data_in_one_call(self):
+            data = b"hello world!"
+            length = len(data)
+            mock_sock = MagicMock()
+            loop = asyncio.get_running_loop()
+
+            async def fake_recv_into(sock, buf):
+                buf[:length] = data
+                return length
+
+            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+                result = await _async_socket_receive(mock_sock, length, loop)
+            self.assertEqual(bytes(result), data)
+
+        async def test_reads_data_in_multiple_chunks(self):
+            data = b"abcdefgh"
+            length = len(data)
+            chunk1, chunk2 = data[:4], data[4:]
+            mock_sock = MagicMock()
+            loop = asyncio.get_running_loop()
+            calls = [0]
+
+            async def fake_recv_into(sock, buf):
+                if calls[0] == 0:
+                    buf[: len(chunk1)] = chunk1
+                    calls[0] += 1
+                    return len(chunk1)
+                buf[: len(chunk2)] = chunk2
+                calls[0] += 1
+                return len(chunk2)
+
+            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+                result = await _async_socket_receive(mock_sock, length, loop)
+            self.assertEqual(bytes(result), data)
+
+        async def test_raises_on_connection_closed(self):
+            mock_sock = MagicMock()
+            loop = asyncio.get_running_loop()
+
+            async def fake_recv_into(sock, buf):
+                return 0
+
+            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+                with self.assertRaises(OSError) as ctx:
+                    await _async_socket_receive(mock_sock, 10, loop)
+            self.assertIn("connection closed", str(ctx.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/test_network_layer.py b/test/test_network_layer.py
index daf0dff185..0e0dd4d719 100644
--- a/test/test_network_layer.py
+++ b/test/test_network_layer.py
@@ -12,28 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Unit tests for network_layer.py.
-
-Tests cover pure-function and state-machine logic that does not require
-a live socket or MongoDB server.  Live-endpoint paths are exercised by
-integration tests in test_client.py / test_ssl.py.
-"""
+"""Unit tests for network_layer.py."""
 
 from __future__ import annotations
 
 import asyncio
 import struct
 import sys
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import MagicMock, patch
 
 sys.path[0:0] = [""]
 
-from test import unittest
+from test import UnitTest, unittest
 
 from pymongo.common import MAX_MESSAGE_SIZE
 from pymongo.errors import ProtocolError
 from pymongo.network_layer import (
-    AsyncNetworkingInterface,
     NetworkingInterface,
     NetworkingInterfaceBase,
     PyMongoProtocol,
@@ -41,16 +35,10 @@
     sendall,
 )
 
-# ---------------------------------------------------------------------------
-# Helpers
-# ---------------------------------------------------------------------------
-
-
-def _run(coroutine):
-    return asyncio.run(coroutine)
+_IS_SYNC = True
 
 
-async def _make_protocol(timeout=None):
+def _make_protocol(timeout=None):
     proto = PyMongoProtocol(timeout=timeout)
     mock_transport = MagicMock()
     mock_transport.is_closing.return_value = False
@@ -62,24 +50,14 @@ def _make_header(length, request_id, response_to, op_code):
     return struct.pack("<iiii", length, request_id, response_to, op_code)
 
 
-# ---------------------------------------------------------------------------
-# sendall
-# ---------------------------------------------------------------------------
-
-
-class TestSendall(unittest.TestCase):
+class TestSendall(UnitTest):
     def test_delegates_to_sock_sendall(self):
         mock_sock = MagicMock()
         sendall(mock_sock, b"hello")
         mock_sock.sendall.assert_called_once_with(b"hello")
 
 
-# ---------------------------------------------------------------------------
-# NetworkingInterfaceBase
-# ---------------------------------------------------------------------------
-
-
-class TestNetworkingInterfaceBase(unittest.TestCase):
+class TestNetworkingInterfaceBase(UnitTest):
     def setUp(self):
         self.base = NetworkingInterfaceBase(MagicMock())
 
@@ -108,12 +86,7 @@ def test_sock_raises(self):
             _ = self.base.sock
 
 
-# ---------------------------------------------------------------------------
-# NetworkingInterface
-# ---------------------------------------------------------------------------
-
-
-class TestNetworkingInterface(unittest.TestCase):
+class TestNetworkingInterface(UnitTest):
     def setUp(self):
         self.mock_sock = MagicMock()
         self.iface = NetworkingInterface(self.mock_sock)
@@ -151,322 +124,246 @@ def test_get_conn_returns_socket(self):
     def test_sock_returns_socket(self):
         self.assertIs(self.iface.sock, self.mock_sock)
 
+    if not _IS_SYNC:
 
-# ---------------------------------------------------------------------------
-# AsyncNetworkingInterface
-# ---------------------------------------------------------------------------
-
-
-class TestAsyncNetworkingInterface(unittest.TestCase):
-    def _make_iface(self):
-        mock_transport = MagicMock()
-        mock_protocol = MagicMock()
-        mock_protocol.gettimeout = 10.0
-        return AsyncNetworkingInterface((mock_transport, mock_protocol))
-
-    def test_gettimeout_returns_protocol_timeout(self):
-        iface = self._make_iface()
-        self.assertEqual(iface.gettimeout, 10.0)
+        def _make_async_iface(self):
+            mock_transport = MagicMock()
+            mock_protocol = MagicMock()
+            mock_protocol.gettimeout = 10.0
+            return NetworkingInterface((mock_transport, mock_protocol))
 
-    def test_settimeout_delegates_to_protocol(self):
-        iface = self._make_iface()
-        iface.settimeout(7.0)
-        iface.conn[1].settimeout.assert_called_once_with(7.0)
+        def test_async_gettimeout_returns_protocol_timeout(self):
+            iface = self._make_async_iface()
+            self.assertEqual(iface.gettimeout, 10.0)
 
-    def test_is_closing_delegates_to_transport(self):
-        iface = self._make_iface()
-        iface.conn[0].is_closing.return_value = False
-        self.assertFalse(iface.is_closing())
+        def test_async_settimeout_delegates_to_protocol(self):
+            iface = self._make_async_iface()
+            iface.settimeout(7.0)
+            iface.conn[1].settimeout.assert_called_once_with(7.0)
 
-    def test_get_conn_returns_protocol(self):
-        iface = self._make_iface()
-        self.assertIs(iface.get_conn, iface.conn[1])
+        def test_async_is_closing_delegates_to_transport(self):
+            iface = self._make_async_iface()
+            iface.conn[0].is_closing.return_value = False
+            self.assertFalse(iface.is_closing())
 
-    def test_sock_returns_transport_socket(self):
-        iface = self._make_iface()
-        sentinel = object()
-        iface.conn[0].get_extra_info.return_value = sentinel
-        self.assertIs(iface.sock, sentinel)
-        iface.conn[0].get_extra_info.assert_called_once_with("socket")
+        def test_async_get_conn_returns_protocol(self):
+            iface = self._make_async_iface()
+            self.assertIs(iface.get_conn, iface.conn[1])
 
+        def test_async_sock_returns_transport_socket(self):
+            iface = self._make_async_iface()
+            sentinel = object()
+            iface.conn[0].get_extra_info.return_value = sentinel
+            self.assertIs(iface.sock, sentinel)
+            iface.conn[0].get_extra_info.assert_called_once_with("socket")
 
-# ---------------------------------------------------------------------------
-# PyMongoProtocol — settimeout / gettimeout
-# ---------------------------------------------------------------------------
 
+class TestPyMongoProtocolTimeout(UnitTest):
+    if not _IS_SYNC:
 
-class TestPyMongoProtocolTimeout(unittest.TestCase):
-    def test_initial_timeout_from_constructor(self):
-        result = _run(_make_protocol(timeout=3.0))
-        self.assertEqual(result.gettimeout, 3.0)
+        def test_initial_timeout_from_constructor(self):
+            proto = _make_protocol(timeout=3.0)
+            self.assertEqual(proto.gettimeout, 3.0)
 
-    def test_settimeout_updates_value(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_settimeout_updates_value(self):
+            proto = _make_protocol()
             proto.settimeout(7.5)
-            return proto.gettimeout
+            self.assertEqual(proto.gettimeout, 7.5)
 
-        self.assertEqual(_run(_test()), 7.5)
+        def test_default_timeout_is_none(self):
+            proto = _make_protocol()
+            self.assertIsNone(proto.gettimeout)
 
-    def test_default_timeout_is_none(self):
-        result = _run(_make_protocol())
-        self.assertIsNone(result.gettimeout)
 
+class TestPyMongoProtocolProcessHeader(UnitTest):
+    if not _IS_SYNC:
 
-# ---------------------------------------------------------------------------
-# PyMongoProtocol — process_header
-# ---------------------------------------------------------------------------
-
-
-class TestPyMongoProtocolProcessHeader(unittest.TestCase):
-    def _run_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
-        async def _test():
-            proto = await _make_protocol()
+        def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
+            proto = _make_protocol()
             proto._max_message_size = max_size
             proto._header = memoryview(bytearray(header_bytes))
-            return proto.process_header()
-
-        return _run(_test())
-
-    def test_normal_op_msg(self):
-        # length=32, op_code=2013 (OP_MSG) → body = 32-16 = 16
-        hdr = _make_header(32, 1, 99, 2013)
-        body_len, op_code, response_to, expecting_compression = self._run_with_header(hdr)
-        self.assertEqual(body_len, 16)
-        self.assertEqual(op_code, 2013)
-        self.assertEqual(response_to, 99)
-        self.assertFalse(expecting_compression)
-
-    def test_op_compressed(self):
-        # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
-        hdr = _make_header(35, 1, 0, 2012)
-        body_len, op_code, response_to, expecting_compression = self._run_with_header(hdr)
-        self.assertEqual(body_len, 10)
-        self.assertEqual(op_code, 2012)
-        self.assertTrue(expecting_compression)
-
-    def test_op_compressed_length_too_small_raises(self):
-        # OP_COMPRESSED with length <= 25
-        hdr = _make_header(25, 1, 0, 2012)
-        with self.assertRaises(ProtocolError):
-            self._run_with_header(hdr)
-
-    def test_non_compressed_length_too_small_raises(self):
-        # Non-compressed with length <= 16
-        hdr = _make_header(16, 1, 0, 2013)
-        with self.assertRaises(ProtocolError):
-            self._run_with_header(hdr)
-
-    def test_length_exceeds_max_raises(self):
-        hdr = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
-        with self.assertRaises(ProtocolError):
-            self._run_with_header(hdr)
-
-    def test_op_reply_op_code(self):
-        # OP_REPLY=1 is a valid non-compressed opcode
-        hdr = _make_header(20, 0, 0, 1)
-        body_len, op_code, response_to, expecting_compression = self._run_with_header(hdr)
-        self.assertEqual(body_len, 4)
-        self.assertEqual(op_code, 1)
-        self.assertFalse(expecting_compression)
-
-
-# ---------------------------------------------------------------------------
-# PyMongoProtocol — process_compression_header
-# ---------------------------------------------------------------------------
-
-
-class TestPyMongoProtocolProcessCompressionHeader(unittest.TestCase):
-    def test_returns_op_code_and_compressor_id(self):
-        async def _test():
-            proto = await _make_protocol()
+            return proto
+
+        def test_normal_op_msg(self):
+            hdr = _make_header(32, 1, 99, 2013)
+            proto = self._make_proto_with_header(hdr)
+            body_len, op_code, response_to, expecting_compression = proto.process_header()
+            self.assertEqual(body_len, 16)
+            self.assertEqual(op_code, 2013)
+            self.assertEqual(response_to, 99)
+            self.assertFalse(expecting_compression)
+
+        def test_op_compressed(self):
+            # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
+            hdr = _make_header(35, 1, 0, 2012)
+            proto = self._make_proto_with_header(hdr)
+            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            self.assertEqual(body_len, 10)
+            self.assertEqual(op_code, 2012)
+            self.assertTrue(expecting_compression)
+
+        def test_op_compressed_length_too_small_raises(self):
+            hdr = _make_header(25, 1, 0, 2012)
+            proto = self._make_proto_with_header(hdr)
+            with self.assertRaises(ProtocolError):
+                proto.process_header()
+
+        def test_non_compressed_length_too_small_raises(self):
+            hdr = _make_header(16, 1, 0, 2013)
+            proto = self._make_proto_with_header(hdr)
+            with self.assertRaises(ProtocolError):
+                proto.process_header()
+
+        def test_length_exceeds_max_raises(self):
+            hdr = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
+            proto = self._make_proto_with_header(hdr)
+            with self.assertRaises(ProtocolError):
+                proto.process_header()
+
+        def test_op_reply_op_code(self):
+            hdr = _make_header(20, 0, 0, 1)
+            proto = self._make_proto_with_header(hdr)
+            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            self.assertEqual(body_len, 4)
+            self.assertEqual(op_code, 1)
+            self.assertFalse(expecting_compression)
+
+
+class TestPyMongoProtocolProcessCompressionHeader(UnitTest):
+    if not _IS_SYNC:
+
+        def test_returns_op_code_and_compressor_id(self):
+            proto = _make_protocol()
             # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
             proto._compression_header = memoryview(bytearray(data))
-            return proto.process_compression_header()
+            op_code, compressor_id = proto.process_compression_header()
+            self.assertEqual(op_code, 2013)
+            self.assertEqual(compressor_id, 1)
 
-        op_code, compressor_id = _run(_test())
-        self.assertEqual(op_code, 2013)
-        self.assertEqual(compressor_id, 1)
-
-    def test_zlib_compressor_id(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_zlib_compressor_id(self):
+            proto = _make_protocol()
             data = struct.pack("<iiB", 2013, 0, 2)
             proto._compression_header = memoryview(bytearray(data))
-            return proto.process_compression_header()
-
-        _, compressor_id = _run(_test())
-        self.assertEqual(compressor_id, 2)
-
+            _, compressor_id = proto.process_compression_header()
+            self.assertEqual(compressor_id, 2)
 
-# ---------------------------------------------------------------------------
-# PyMongoProtocol — get_buffer
-# ---------------------------------------------------------------------------
 
+class TestPyMongoProtocolGetBuffer(UnitTest):
+    if not _IS_SYNC:
 
-class TestPyMongoProtocolGetBuffer(unittest.TestCase):
-    def test_expecting_header_returns_full_header_slice(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_expecting_header_returns_full_header_slice(self):
+            proto = _make_protocol()
             proto._expecting_header = True
             proto._header_index = 0
-            return len(proto.get_buffer(0))
+            self.assertEqual(len(proto.get_buffer(0)), 16)
 
-        self.assertEqual(_run(_test()), 16)
-
-    def test_expecting_header_partial_returns_remaining(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_expecting_header_partial_returns_remaining(self):
+            proto = _make_protocol()
             proto._expecting_header = True
             proto._header_index = 8
-            return len(proto.get_buffer(0))
-
-        self.assertEqual(_run(_test()), 8)
+            self.assertEqual(len(proto.get_buffer(0)), 8)
 
-    def test_expecting_compression_returns_compression_slice(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_expecting_compression_returns_compression_slice(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = True
             proto._compression_index = 0
-            return len(proto.get_buffer(0))
-
-        self.assertEqual(_run(_test()), 9)
+            self.assertEqual(len(proto.get_buffer(0)), 9)
 
-    def test_expecting_compression_partial(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_expecting_compression_partial(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = True
             proto._compression_index = 5
-            return len(proto.get_buffer(0))
+            self.assertEqual(len(proto.get_buffer(0)), 4)
 
-        self.assertEqual(_run(_test()), 4)
-
-    def test_message_body_returns_remaining_slice(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_message_body_returns_remaining_slice(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = False
             proto._message = memoryview(bytearray(100))
             proto._message_index = 0
-            return len(proto.get_buffer(0))
-
-        self.assertEqual(_run(_test()), 100)
+            self.assertEqual(len(proto.get_buffer(0)), 100)
 
-    def test_connection_lost_allocates_drain_buffer(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_connection_lost_allocates_drain_buffer(self):
+            proto = _make_protocol()
             proto._connection_lost = True
             proto._message = None
-            return len(proto.get_buffer(0))
-
-        self.assertEqual(_run(_test()), 2**14)
+            self.assertEqual(len(proto.get_buffer(0)), 2**14)
 
-    def test_connection_lost_reuses_existing_buffer(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_connection_lost_reuses_existing_buffer(self):
+            proto = _make_protocol()
             proto._connection_lost = True
             proto._message = memoryview(bytearray(50))
-            return len(proto.get_buffer(0))
+            self.assertEqual(len(proto.get_buffer(0)), 50)
 
-        self.assertEqual(_run(_test()), 50)
 
+class TestPyMongoProtocolBufferUpdated(UnitTest):
+    if not _IS_SYNC:
 
-# ---------------------------------------------------------------------------
-# PyMongoProtocol — buffer_updated
-# ---------------------------------------------------------------------------
-
-
-class TestPyMongoProtocolBufferUpdated(unittest.TestCase):
-    def test_zero_bytes_closes_connection(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_zero_bytes_closes_connection(self):
+            proto = _make_protocol()
             proto.buffer_updated(0)
-            return proto._connection_lost
-
-        self.assertTrue(_run(_test()))
+            self.assertTrue(proto._connection_lost)
 
-    def test_connection_lost_returns_early(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_connection_lost_returns_early(self):
+            proto = _make_protocol()
             proto._connection_lost = True
             proto._header_index = 3
             proto.buffer_updated(5)
-            return proto._header_index  # must remain 3
+            self.assertEqual(proto._header_index, 3)
 
-        self.assertEqual(_run(_test()), 3)
-
-    def test_partial_header_increments_index(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_partial_header_increments_index(self):
+            proto = _make_protocol()
             proto._expecting_header = True
             proto._header_index = 0
             proto.buffer_updated(8)
-            return proto._header_index
-
-        self.assertEqual(_run(_test()), 8)
+            self.assertEqual(proto._header_index, 8)
 
-    def test_full_header_transitions_to_message(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_full_header_transitions_to_message(self):
+            proto = _make_protocol()
             proto._expecting_header = True
             hdr = _make_header(32, 1, 0, 2013)
             proto._header = memoryview(bytearray(hdr))
             proto._header_index = 0
             proto.buffer_updated(16)
-            return proto._expecting_header, proto._message_size
-
-        expecting_header, message_size = _run(_test())
-        self.assertFalse(expecting_header)
-        self.assertEqual(message_size, 16)  # 32 - 16
+            self.assertFalse(proto._expecting_header)
+            self.assertEqual(proto._message_size, 16)
 
-    def test_invalid_header_closes_connection(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_invalid_header_closes_connection(self):
+            proto = _make_protocol()
             proto._expecting_header = True
             # length=16 (not > 16) triggers ProtocolError
             hdr = _make_header(16, 1, 0, 2013)
             proto._header = memoryview(bytearray(hdr))
             proto._header_index = 0
             proto.buffer_updated(16)
-            return proto._connection_lost
+            self.assertTrue(proto._connection_lost)
 
-        self.assertTrue(_run(_test()))
-
-    def test_compression_header_processing(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_compression_header_processing(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = True
             comp_hdr = struct.pack("<iiB", 2013, 0, 2)
             proto._compression_header = memoryview(bytearray(comp_hdr))
             proto._compression_index = 0
             proto.buffer_updated(9)
-            return proto._expecting_compression, proto._op_code, proto._compressor_id
-
-        expecting_compression, op_code, compressor_id = _run(_test())
-        self.assertFalse(expecting_compression)
-        self.assertEqual(op_code, 2013)
-        self.assertEqual(compressor_id, 2)
+            self.assertFalse(proto._expecting_compression)
+            self.assertEqual(proto._op_code, 2013)
+            self.assertEqual(proto._compressor_id, 2)
 
-    def test_partial_compression_header_increments_index(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_partial_compression_header_increments_index(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = True
             proto._compression_index = 0
             proto.buffer_updated(4)
-            return proto._compression_index, proto._expecting_compression
-
-        idx, still_expecting = _run(_test())
-        self.assertEqual(idx, 4)
-        self.assertTrue(still_expecting)
+            self.assertEqual(proto._compression_index, 4)
+            self.assertTrue(proto._expecting_compression)
 
-    def test_message_complete_resolves_pending_future(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_message_complete_resolves_pending_future(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = False
             proto._message_size = 10
@@ -480,18 +377,14 @@ async def _test():
             proto._pending_messages.append(fut)
 
             proto.buffer_updated(10)
-            return fut.done(), fut.result()
-
-        done, result = _run(_test())
-        self.assertTrue(done)
-        op_code, compressor_id, response_to, _ = result
-        self.assertEqual(op_code, 2013)
-        self.assertIsNone(compressor_id)
-        self.assertEqual(response_to, 42)
-
-    def test_message_complete_no_pending_creates_new_future(self):
-        async def _test():
-            proto = await _make_protocol()
+            self.assertTrue(fut.done())
+            op_code, compressor_id, response_to, _ = fut.result()
+            self.assertEqual(op_code, 2013)
+            self.assertIsNone(compressor_id)
+            self.assertEqual(response_to, 42)
+
+        def test_message_complete_no_pending_creates_new_future(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = False
             proto._message_size = 5
@@ -501,119 +394,82 @@ async def _test():
             proto._compressor_id = None
             proto._response_to = 0
 
-            # No pending futures; buffer_updated creates one internally
             self.assertFalse(proto._pending_messages)
             proto.buffer_updated(5)
-            # The auto-created future should be in _done_messages
-            return len(proto._done_messages)
+            self.assertEqual(len(proto._done_messages), 1)
 
-        self.assertEqual(_run(_test()), 1)
-
-    def test_partial_message_increments_index(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_partial_message_increments_index(self):
+            proto = _make_protocol()
             proto._expecting_header = False
             proto._expecting_compression = False
             proto._message_size = 20
             proto._message = memoryview(bytearray(20))
             proto._message_index = 0
             proto.buffer_updated(7)
-            return proto._message_index
-
-        self.assertEqual(_run(_test()), 7)
-
+            self.assertEqual(proto._message_index, 7)
 
-# ---------------------------------------------------------------------------
-# PyMongoProtocol — close / connection_lost
-# ---------------------------------------------------------------------------
 
+class TestPyMongoProtocolClose(UnitTest):
+    if not _IS_SYNC:
 
-class TestPyMongoProtocolClose(unittest.TestCase):
-    def test_close_sets_connection_lost_flag(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_close_sets_connection_lost_flag(self):
+            proto = _make_protocol()
             proto.close()
-            return proto._connection_lost
+            self.assertTrue(proto._connection_lost)
 
-        self.assertTrue(_run(_test()))
-
-    def test_close_aborts_transport(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_close_aborts_transport(self):
+            proto = _make_protocol()
             proto.close()
-            return proto.transport.abort.called
-
-        self.assertTrue(_run(_test()))
+            self.assertTrue(proto.transport.abort.called)
 
-    def test_connection_lost_resolves_closed_future(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_connection_lost_resolves_closed_future(self):
+            proto = _make_protocol()
             self.assertFalse(proto._closed.done())
             proto.connection_lost(None)
-            return proto._closed.done()
-
-        self.assertTrue(_run(_test()))
+            self.assertTrue(proto._closed.done())
 
-    def test_connection_lost_twice_does_not_raise(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_connection_lost_twice_does_not_raise(self):
+            proto = _make_protocol()
+            proto.connection_lost(None)
             proto.connection_lost(None)
-            proto.connection_lost(None)  # second call must not raise InvalidStateError
-
-        _run(_test())  # should not raise
 
-    def test_close_with_exception_propagates_to_pending(self):
-        async def _test():
-            proto = await _make_protocol()
+        def test_close_with_exception_propagates_to_pending(self):
+            proto = _make_protocol()
             fut = asyncio.get_running_loop().create_future()
             proto._pending_messages.append(fut)
             exc = OSError("connection reset")
             proto.close(exc)
-            try:
-                await fut
-                return None
-            except OSError as e:
-                return str(e)
-
-        result = _run(_test())
-        self.assertIn("connection reset", result)
+            with self.assertRaises(OSError) as ctx:
+                fut
+            self.assertIn("connection reset", str(ctx.exception))
 
 
-# ---------------------------------------------------------------------------
-# _async_socket_receive
-# ---------------------------------------------------------------------------
+class TestAsyncSocketReceive(UnitTest):
+    if not _IS_SYNC:
 
-
-class TestAsyncSocketReceive(unittest.TestCase):
-    def test_reads_full_data_in_one_call(self):
-        data = b"hello world!"
-        length = len(data)
-
-        async def _test():
+        def test_reads_full_data_in_one_call(self):
+            data = b"hello world!"
+            length = len(data)
             mock_sock = MagicMock()
             loop = asyncio.get_running_loop()
 
-            async def fake_recv_into(sock, buf):
+            def fake_recv_into(sock, buf):
                 buf[:length] = data
                 return length
 
-            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                result = await _async_socket_receive(mock_sock, length, loop)
-            return bytes(result)
-
-        self.assertEqual(_run(_test()), data)
+            with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
+                result = _async_socket_receive(mock_sock, length, loop)
+            self.assertEqual(bytes(result), data)
 
-    def test_reads_data_in_multiple_chunks(self):
-        data = b"abcdefgh"
-        length = len(data)
-        chunk1, chunk2 = data[:4], data[4:]
-
-        async def _test():
+        def test_reads_data_in_multiple_chunks(self):
+            data = b"abcdefgh"
+            length = len(data)
+            chunk1, chunk2 = data[:4], data[4:]
             mock_sock = MagicMock()
             loop = asyncio.get_running_loop()
             calls = [0]
 
-            async def fake_recv_into(sock, buf):
+            def fake_recv_into(sock, buf):
                 if calls[0] == 0:
                     buf[: len(chunk1)] = chunk1
                     calls[0] += 1
@@ -622,26 +478,21 @@ async def fake_recv_into(sock, buf):
                 calls[0] += 1
                 return len(chunk2)
 
-            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                result = await _async_socket_receive(mock_sock, length, loop)
-            return bytes(result)
-
-        self.assertEqual(_run(_test()), data)
+            with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
+                result = _async_socket_receive(mock_sock, length, loop)
+            self.assertEqual(bytes(result), data)
 
-    def test_raises_on_connection_closed(self):
-        async def _test():
+        def test_raises_on_connection_closed(self):
             mock_sock = MagicMock()
             loop = asyncio.get_running_loop()
 
-            async def fake_recv_into(sock, buf):
-                return 0  # connection closed
-
-            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                await _async_socket_receive(mock_sock, 10, loop)
+            def fake_recv_into(sock, buf):
+                return 0
 
-        with self.assertRaises(OSError) as ctx:
-            _run(_test())
-        self.assertIn("connection closed", str(ctx.exception))
+            with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
+                with self.assertRaises(OSError) as ctx:
+                    _async_socket_receive(mock_sock, 10, loop)
+            self.assertIn("connection closed", str(ctx.exception))
 
 
 if __name__ == "__main__":
diff --git a/tools/synchro.py b/tools/synchro.py
index ed794c5963..398e353f89 100644
--- a/tools/synchro.py
+++ b/tools/synchro.py
@@ -128,6 +128,7 @@
     "SpecRunnerTask": "SpecRunnerThread",
     "AsyncMockConnection": "MockConnection",
     "AsyncMockPool": "MockPool",
+    "AsyncMock": "MagicMock",
     "StopAsyncIteration": "StopIteration",
     "create_async_event": "create_event",
     "async_create_barrier": "create_barrier",
@@ -251,6 +252,7 @@ def async_only_test(f: str) -> bool:
     "test_monitor.py",
     "test_monitoring.py",
     "test_mongos_load_balancing.py",
+    "test_network_layer.py",
     "test_on_demand_csfle.py",
     "test_pooling.py",
     "test_raw_bson.py",

From 9d4bf46ea846e5f1262708f01fb06ce3e2397cc0 Mon Sep 17 00:00:00 2001
From: Jeffrey 'Alex' Clark <aclark@aclark.net>
Date: Tue, 5 May 2026 18:24:21 -0400
Subject: [PATCH 4/7] Address Noah review by proxy

Applying feedback from PYTHON-5784 to all open codecov PRs
---
 test/asynchronous/test_network_layer.py | 221 +++---------------------
 test/test_network_layer.py              | 221 +++---------------------
 2 files changed, 56 insertions(+), 386 deletions(-)

diff --git a/test/asynchronous/test_network_layer.py b/test/asynchronous/test_network_layer.py
index fa207be49f..8bfea71cff 100644
--- a/test/asynchronous/test_network_layer.py
+++ b/test/asynchronous/test_network_layer.py
@@ -125,42 +125,47 @@ def test_get_conn_returns_socket(self):
     def test_sock_returns_socket(self):
         self.assertIs(self.iface.sock, self.mock_sock)
 
-    if not _IS_SYNC:
 
-        def _make_async_iface(self):
+if not _IS_SYNC:
+
+    class TestAsyncNetworkingInterface(AsyncUnitTest):
+        def _make_iface(self):
             mock_transport = MagicMock()
             mock_protocol = MagicMock()
             mock_protocol.gettimeout = 10.0
             return AsyncNetworkingInterface((mock_transport, mock_protocol))
 
-        def test_async_gettimeout_returns_protocol_timeout(self):
-            iface = self._make_async_iface()
+        def test_gettimeout_returns_protocol_timeout(self):
+            iface = self._make_iface()
             self.assertEqual(iface.gettimeout, 10.0)
 
-        def test_async_settimeout_delegates_to_protocol(self):
-            iface = self._make_async_iface()
+        def test_settimeout_delegates_to_protocol(self):
+            iface = self._make_iface()
             iface.settimeout(7.0)
             iface.conn[1].settimeout.assert_called_once_with(7.0)
 
-        def test_async_is_closing_delegates_to_transport(self):
-            iface = self._make_async_iface()
+        def test_is_closing_delegates_to_transport(self):
+            iface = self._make_iface()
             iface.conn[0].is_closing.return_value = False
             self.assertFalse(iface.is_closing())
 
-        def test_async_get_conn_returns_protocol(self):
-            iface = self._make_async_iface()
+        def test_get_conn_returns_protocol(self):
+            iface = self._make_iface()
             self.assertIs(iface.get_conn, iface.conn[1])
 
-        def test_async_sock_returns_transport_socket(self):
-            iface = self._make_async_iface()
+        def test_sock_returns_transport_socket(self):
+            iface = self._make_iface()
             sentinel = object()
             iface.conn[0].get_extra_info.return_value = sentinel
             self.assertIs(iface.sock, sentinel)
             iface.conn[0].get_extra_info.assert_called_once_with("socket")
 
-
-class TestPyMongoProtocolTimeout(AsyncUnitTest):
-    if not _IS_SYNC:
+    class TestPyMongoProtocol(AsyncUnitTest):
+        async def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
+            proto = await _make_protocol()
+            proto._max_message_size = max_size
+            proto._header = memoryview(bytearray(header_bytes))
+            return proto
 
         async def test_initial_timeout_from_constructor(self):
             proto = await _make_protocol(timeout=3.0)
@@ -175,16 +180,6 @@ async def test_default_timeout_is_none(self):
             proto = await _make_protocol()
             self.assertIsNone(proto.gettimeout)
 
-
-class TestPyMongoProtocolProcessHeader(AsyncUnitTest):
-    if not _IS_SYNC:
-
-        async def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
-            proto = await _make_protocol()
-            proto._max_message_size = max_size
-            proto._header = memoryview(bytearray(header_bytes))
-            return proto
-
         async def test_normal_op_msg(self):
             hdr = _make_header(32, 1, 99, 2013)
             proto = await self._make_proto_with_header(hdr)
@@ -229,11 +224,7 @@ async def test_op_reply_op_code(self):
             self.assertEqual(op_code, 1)
             self.assertFalse(expecting_compression)
 
-
-class TestPyMongoProtocolProcessCompressionHeader(AsyncUnitTest):
-    if not _IS_SYNC:
-
-        async def test_returns_op_code_and_compressor_id(self):
+        async def test_compression_header_returns_op_code_and_compressor_id(self):
             proto = await _make_protocol()
             # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
@@ -242,127 +233,13 @@ async def test_returns_op_code_and_compressor_id(self):
             self.assertEqual(op_code, 2013)
             self.assertEqual(compressor_id, 1)
 
-        async def test_zlib_compressor_id(self):
+        async def test_compression_header_zlib_compressor_id(self):
             proto = await _make_protocol()
             data = struct.pack("<iiB", 2013, 0, 2)
             proto._compression_header = memoryview(bytearray(data))
             _, compressor_id = proto.process_compression_header()
             self.assertEqual(compressor_id, 2)
 
-
-class TestPyMongoProtocolGetBuffer(AsyncUnitTest):
-    if not _IS_SYNC:
-
-        async def test_expecting_header_returns_full_header_slice(self):
-            proto = await _make_protocol()
-            proto._expecting_header = True
-            proto._header_index = 0
-            self.assertEqual(len(proto.get_buffer(0)), 16)
-
-        async def test_expecting_header_partial_returns_remaining(self):
-            proto = await _make_protocol()
-            proto._expecting_header = True
-            proto._header_index = 8
-            self.assertEqual(len(proto.get_buffer(0)), 8)
-
-        async def test_expecting_compression_returns_compression_slice(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            proto._compression_index = 0
-            self.assertEqual(len(proto.get_buffer(0)), 9)
-
-        async def test_expecting_compression_partial(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            proto._compression_index = 5
-            self.assertEqual(len(proto.get_buffer(0)), 4)
-
-        async def test_message_body_returns_remaining_slice(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message = memoryview(bytearray(100))
-            proto._message_index = 0
-            self.assertEqual(len(proto.get_buffer(0)), 100)
-
-        async def test_connection_lost_allocates_drain_buffer(self):
-            proto = await _make_protocol()
-            proto._connection_lost = True
-            proto._message = None
-            self.assertEqual(len(proto.get_buffer(0)), 2**14)
-
-        async def test_connection_lost_reuses_existing_buffer(self):
-            proto = await _make_protocol()
-            proto._connection_lost = True
-            proto._message = memoryview(bytearray(50))
-            self.assertEqual(len(proto.get_buffer(0)), 50)
-
-
-class TestPyMongoProtocolBufferUpdated(AsyncUnitTest):
-    if not _IS_SYNC:
-
-        async def test_zero_bytes_closes_connection(self):
-            proto = await _make_protocol()
-            proto.buffer_updated(0)
-            self.assertTrue(proto._connection_lost)
-
-        async def test_connection_lost_returns_early(self):
-            proto = await _make_protocol()
-            proto._connection_lost = True
-            proto._header_index = 3
-            proto.buffer_updated(5)
-            self.assertEqual(proto._header_index, 3)
-
-        async def test_partial_header_increments_index(self):
-            proto = await _make_protocol()
-            proto._expecting_header = True
-            proto._header_index = 0
-            proto.buffer_updated(8)
-            self.assertEqual(proto._header_index, 8)
-
-        async def test_full_header_transitions_to_message(self):
-            proto = await _make_protocol()
-            proto._expecting_header = True
-            hdr = _make_header(32, 1, 0, 2013)
-            proto._header = memoryview(bytearray(hdr))
-            proto._header_index = 0
-            proto.buffer_updated(16)
-            self.assertFalse(proto._expecting_header)
-            self.assertEqual(proto._message_size, 16)
-
-        async def test_invalid_header_closes_connection(self):
-            proto = await _make_protocol()
-            proto._expecting_header = True
-            # length=16 (not > 16) triggers ProtocolError
-            hdr = _make_header(16, 1, 0, 2013)
-            proto._header = memoryview(bytearray(hdr))
-            proto._header_index = 0
-            proto.buffer_updated(16)
-            self.assertTrue(proto._connection_lost)
-
-        async def test_compression_header_processing(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            comp_hdr = struct.pack("<iiB", 2013, 0, 2)
-            proto._compression_header = memoryview(bytearray(comp_hdr))
-            proto._compression_index = 0
-            proto.buffer_updated(9)
-            self.assertFalse(proto._expecting_compression)
-            self.assertEqual(proto._op_code, 2013)
-            self.assertEqual(proto._compressor_id, 2)
-
-        async def test_partial_compression_header_increments_index(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            proto._compression_index = 0
-            proto.buffer_updated(4)
-            self.assertEqual(proto._compression_index, 4)
-            self.assertTrue(proto._expecting_compression)
-
         async def test_message_complete_resolves_pending_future(self):
             proto = await _make_protocol()
             proto._expecting_header = False
@@ -384,51 +261,11 @@ async def test_message_complete_resolves_pending_future(self):
             self.assertIsNone(compressor_id)
             self.assertEqual(response_to, 42)
 
-        async def test_message_complete_no_pending_creates_new_future(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message_size = 5
-            proto._message = memoryview(bytearray(5))
-            proto._message_index = 0
-            proto._op_code = 2013
-            proto._compressor_id = None
-            proto._response_to = 0
-
-            self.assertFalse(proto._pending_messages)
-            proto.buffer_updated(5)
-            self.assertEqual(len(proto._done_messages), 1)
-
-        async def test_partial_message_increments_index(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message_size = 20
-            proto._message = memoryview(bytearray(20))
-            proto._message_index = 0
-            proto.buffer_updated(7)
-            self.assertEqual(proto._message_index, 7)
-
-
-class TestPyMongoProtocolClose(AsyncUnitTest):
-    if not _IS_SYNC:
-
-        async def test_close_sets_connection_lost_flag(self):
-            proto = await _make_protocol()
-            proto.close()
-            self.assertTrue(proto._connection_lost)
-
         async def test_close_aborts_transport(self):
             proto = await _make_protocol()
             proto.close()
             self.assertTrue(proto.transport.abort.called)
 
-        async def test_connection_lost_resolves_closed_future(self):
-            proto = await _make_protocol()
-            self.assertFalse(proto._closed.done())
-            proto.connection_lost(None)
-            self.assertTrue(proto._closed.done())
-
         async def test_connection_lost_twice_does_not_raise(self):
             proto = await _make_protocol()
             proto.connection_lost(None)
@@ -444,10 +281,7 @@ async def test_close_with_exception_propagates_to_pending(self):
                 await fut
             self.assertIn("connection reset", str(ctx.exception))
 
-
-class TestAsyncSocketReceive(AsyncUnitTest):
-    if not _IS_SYNC:
-
+    class TestAsyncSocketReceive(AsyncUnitTest):
         async def test_reads_full_data_in_one_call(self):
             data = b"hello world!"
             length = len(data)
@@ -468,15 +302,16 @@ async def test_reads_data_in_multiple_chunks(self):
             chunk1, chunk2 = data[:4], data[4:]
             mock_sock = MagicMock()
             loop = asyncio.get_running_loop()
-            calls = [0]
+            calls = 0
 
             async def fake_recv_into(sock, buf):
-                if calls[0] == 0:
+                nonlocal calls
+                if calls == 0:
                     buf[: len(chunk1)] = chunk1
-                    calls[0] += 1
+                    calls += 1
                     return len(chunk1)
                 buf[: len(chunk2)] = chunk2
-                calls[0] += 1
+                calls += 1
                 return len(chunk2)
 
             with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
diff --git a/test/test_network_layer.py b/test/test_network_layer.py
index 0e0dd4d719..881c259892 100644
--- a/test/test_network_layer.py
+++ b/test/test_network_layer.py
@@ -124,42 +124,47 @@ def test_get_conn_returns_socket(self):
     def test_sock_returns_socket(self):
         self.assertIs(self.iface.sock, self.mock_sock)
 
-    if not _IS_SYNC:
 
-        def _make_async_iface(self):
+if not _IS_SYNC:
+
+    class TestNetworkingInterface(UnitTest):
+        def _make_iface(self):
             mock_transport = MagicMock()
             mock_protocol = MagicMock()
             mock_protocol.gettimeout = 10.0
             return NetworkingInterface((mock_transport, mock_protocol))
 
-        def test_async_gettimeout_returns_protocol_timeout(self):
-            iface = self._make_async_iface()
+        def test_gettimeout_returns_protocol_timeout(self):
+            iface = self._make_iface()
             self.assertEqual(iface.gettimeout, 10.0)
 
-        def test_async_settimeout_delegates_to_protocol(self):
-            iface = self._make_async_iface()
+        def test_settimeout_delegates_to_protocol(self):
+            iface = self._make_iface()
             iface.settimeout(7.0)
             iface.conn[1].settimeout.assert_called_once_with(7.0)
 
-        def test_async_is_closing_delegates_to_transport(self):
-            iface = self._make_async_iface()
+        def test_is_closing_delegates_to_transport(self):
+            iface = self._make_iface()
             iface.conn[0].is_closing.return_value = False
             self.assertFalse(iface.is_closing())
 
-        def test_async_get_conn_returns_protocol(self):
-            iface = self._make_async_iface()
+        def test_get_conn_returns_protocol(self):
+            iface = self._make_iface()
             self.assertIs(iface.get_conn, iface.conn[1])
 
-        def test_async_sock_returns_transport_socket(self):
-            iface = self._make_async_iface()
+        def test_sock_returns_transport_socket(self):
+            iface = self._make_iface()
             sentinel = object()
             iface.conn[0].get_extra_info.return_value = sentinel
             self.assertIs(iface.sock, sentinel)
             iface.conn[0].get_extra_info.assert_called_once_with("socket")
 
-
-class TestPyMongoProtocolTimeout(UnitTest):
-    if not _IS_SYNC:
+    class TestPyMongoProtocol(UnitTest):
+        def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
+            proto = _make_protocol()
+            proto._max_message_size = max_size
+            proto._header = memoryview(bytearray(header_bytes))
+            return proto
 
         def test_initial_timeout_from_constructor(self):
             proto = _make_protocol(timeout=3.0)
@@ -174,16 +179,6 @@ def test_default_timeout_is_none(self):
             proto = _make_protocol()
             self.assertIsNone(proto.gettimeout)
 
-
-class TestPyMongoProtocolProcessHeader(UnitTest):
-    if not _IS_SYNC:
-
-        def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
-            proto = _make_protocol()
-            proto._max_message_size = max_size
-            proto._header = memoryview(bytearray(header_bytes))
-            return proto
-
         def test_normal_op_msg(self):
             hdr = _make_header(32, 1, 99, 2013)
             proto = self._make_proto_with_header(hdr)
@@ -228,11 +223,7 @@ def test_op_reply_op_code(self):
             self.assertEqual(op_code, 1)
             self.assertFalse(expecting_compression)
 
-
-class TestPyMongoProtocolProcessCompressionHeader(UnitTest):
-    if not _IS_SYNC:
-
-        def test_returns_op_code_and_compressor_id(self):
+        def test_compression_header_returns_op_code_and_compressor_id(self):
             proto = _make_protocol()
             # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
@@ -241,127 +232,13 @@ def test_returns_op_code_and_compressor_id(self):
             self.assertEqual(op_code, 2013)
             self.assertEqual(compressor_id, 1)
 
-        def test_zlib_compressor_id(self):
+        def test_compression_header_zlib_compressor_id(self):
             proto = _make_protocol()
             data = struct.pack("<iiB", 2013, 0, 2)
             proto._compression_header = memoryview(bytearray(data))
             _, compressor_id = proto.process_compression_header()
             self.assertEqual(compressor_id, 2)
 
-
-class TestPyMongoProtocolGetBuffer(UnitTest):
-    if not _IS_SYNC:
-
-        def test_expecting_header_returns_full_header_slice(self):
-            proto = _make_protocol()
-            proto._expecting_header = True
-            proto._header_index = 0
-            self.assertEqual(len(proto.get_buffer(0)), 16)
-
-        def test_expecting_header_partial_returns_remaining(self):
-            proto = _make_protocol()
-            proto._expecting_header = True
-            proto._header_index = 8
-            self.assertEqual(len(proto.get_buffer(0)), 8)
-
-        def test_expecting_compression_returns_compression_slice(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            proto._compression_index = 0
-            self.assertEqual(len(proto.get_buffer(0)), 9)
-
-        def test_expecting_compression_partial(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            proto._compression_index = 5
-            self.assertEqual(len(proto.get_buffer(0)), 4)
-
-        def test_message_body_returns_remaining_slice(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message = memoryview(bytearray(100))
-            proto._message_index = 0
-            self.assertEqual(len(proto.get_buffer(0)), 100)
-
-        def test_connection_lost_allocates_drain_buffer(self):
-            proto = _make_protocol()
-            proto._connection_lost = True
-            proto._message = None
-            self.assertEqual(len(proto.get_buffer(0)), 2**14)
-
-        def test_connection_lost_reuses_existing_buffer(self):
-            proto = _make_protocol()
-            proto._connection_lost = True
-            proto._message = memoryview(bytearray(50))
-            self.assertEqual(len(proto.get_buffer(0)), 50)
-
-
-class TestPyMongoProtocolBufferUpdated(UnitTest):
-    if not _IS_SYNC:
-
-        def test_zero_bytes_closes_connection(self):
-            proto = _make_protocol()
-            proto.buffer_updated(0)
-            self.assertTrue(proto._connection_lost)
-
-        def test_connection_lost_returns_early(self):
-            proto = _make_protocol()
-            proto._connection_lost = True
-            proto._header_index = 3
-            proto.buffer_updated(5)
-            self.assertEqual(proto._header_index, 3)
-
-        def test_partial_header_increments_index(self):
-            proto = _make_protocol()
-            proto._expecting_header = True
-            proto._header_index = 0
-            proto.buffer_updated(8)
-            self.assertEqual(proto._header_index, 8)
-
-        def test_full_header_transitions_to_message(self):
-            proto = _make_protocol()
-            proto._expecting_header = True
-            hdr = _make_header(32, 1, 0, 2013)
-            proto._header = memoryview(bytearray(hdr))
-            proto._header_index = 0
-            proto.buffer_updated(16)
-            self.assertFalse(proto._expecting_header)
-            self.assertEqual(proto._message_size, 16)
-
-        def test_invalid_header_closes_connection(self):
-            proto = _make_protocol()
-            proto._expecting_header = True
-            # length=16 (not > 16) triggers ProtocolError
-            hdr = _make_header(16, 1, 0, 2013)
-            proto._header = memoryview(bytearray(hdr))
-            proto._header_index = 0
-            proto.buffer_updated(16)
-            self.assertTrue(proto._connection_lost)
-
-        def test_compression_header_processing(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            comp_hdr = struct.pack("<iiB", 2013, 0, 2)
-            proto._compression_header = memoryview(bytearray(comp_hdr))
-            proto._compression_index = 0
-            proto.buffer_updated(9)
-            self.assertFalse(proto._expecting_compression)
-            self.assertEqual(proto._op_code, 2013)
-            self.assertEqual(proto._compressor_id, 2)
-
-        def test_partial_compression_header_increments_index(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = True
-            proto._compression_index = 0
-            proto.buffer_updated(4)
-            self.assertEqual(proto._compression_index, 4)
-            self.assertTrue(proto._expecting_compression)
-
         def test_message_complete_resolves_pending_future(self):
             proto = _make_protocol()
             proto._expecting_header = False
@@ -383,51 +260,11 @@ def test_message_complete_resolves_pending_future(self):
             self.assertIsNone(compressor_id)
             self.assertEqual(response_to, 42)
 
-        def test_message_complete_no_pending_creates_new_future(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message_size = 5
-            proto._message = memoryview(bytearray(5))
-            proto._message_index = 0
-            proto._op_code = 2013
-            proto._compressor_id = None
-            proto._response_to = 0
-
-            self.assertFalse(proto._pending_messages)
-            proto.buffer_updated(5)
-            self.assertEqual(len(proto._done_messages), 1)
-
-        def test_partial_message_increments_index(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message_size = 20
-            proto._message = memoryview(bytearray(20))
-            proto._message_index = 0
-            proto.buffer_updated(7)
-            self.assertEqual(proto._message_index, 7)
-
-
-class TestPyMongoProtocolClose(UnitTest):
-    if not _IS_SYNC:
-
-        def test_close_sets_connection_lost_flag(self):
-            proto = _make_protocol()
-            proto.close()
-            self.assertTrue(proto._connection_lost)
-
         def test_close_aborts_transport(self):
             proto = _make_protocol()
             proto.close()
             self.assertTrue(proto.transport.abort.called)
 
-        def test_connection_lost_resolves_closed_future(self):
-            proto = _make_protocol()
-            self.assertFalse(proto._closed.done())
-            proto.connection_lost(None)
-            self.assertTrue(proto._closed.done())
-
         def test_connection_lost_twice_does_not_raise(self):
             proto = _make_protocol()
             proto.connection_lost(None)
@@ -443,10 +280,7 @@ def test_close_with_exception_propagates_to_pending(self):
                 fut
             self.assertIn("connection reset", str(ctx.exception))
 
-
-class TestAsyncSocketReceive(UnitTest):
-    if not _IS_SYNC:
-
+    class TestAsyncSocketReceive(UnitTest):
         def test_reads_full_data_in_one_call(self):
             data = b"hello world!"
             length = len(data)
@@ -467,15 +301,16 @@ def test_reads_data_in_multiple_chunks(self):
             chunk1, chunk2 = data[:4], data[4:]
             mock_sock = MagicMock()
             loop = asyncio.get_running_loop()
-            calls = [0]
+            calls = 0
 
             def fake_recv_into(sock, buf):
-                if calls[0] == 0:
+                nonlocal calls
+                if calls == 0:
                     buf[: len(chunk1)] = chunk1
-                    calls[0] += 1
+                    calls += 1
                     return len(chunk1)
                 buf[: len(chunk2)] = chunk2
-                calls[0] += 1
+                calls += 1
                 return len(chunk2)
 
             with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):

From dd4aacab1b0ce494a2c72ef38220a7e1f8e53ba2 Mon Sep 17 00:00:00 2001
From: Jeffrey 'Alex' Clark <aclark@aclark.net>
Date: Tue, 5 May 2026 20:31:57 -0400
Subject: [PATCH 5/7] Rename vars

---
 test/asynchronous/test_network_layer.py | 212 ++++++++++++------------
 test/test_network_layer.py              | 212 ++++++++++++------------
 2 files changed, 212 insertions(+), 212 deletions(-)

diff --git a/test/asynchronous/test_network_layer.py b/test/asynchronous/test_network_layer.py
index 8bfea71cff..88e1d56a6e 100644
--- a/test/asynchronous/test_network_layer.py
+++ b/test/asynchronous/test_network_layer.py
@@ -40,11 +40,11 @@
 
 
 async def _make_protocol(timeout=None):
-    proto = PyMongoProtocol(timeout=timeout)
+    protocol = PyMongoProtocol(timeout=timeout)
     mock_transport = MagicMock()
     mock_transport.is_closing.return_value = False
-    proto.transport = mock_transport
-    return proto
+    protocol.transport = mock_transport
+    return protocol
 
 
 def _make_header(length, request_id, response_to, op_code):
@@ -53,9 +53,9 @@ def _make_header(length, request_id, response_to, op_code):
 
 class TestSendall(AsyncUnitTest):
     def test_delegates_to_sock_sendall(self):
-        mock_sock = MagicMock()
-        sendall(mock_sock, b"hello")
-        mock_sock.sendall.assert_called_once_with(b"hello")
+        mock_socket = MagicMock()
+        sendall(mock_socket, b"hello")
+        mock_socket.sendall.assert_called_once_with(b"hello")
 
 
 class TestNetworkingInterfaceBase(AsyncUnitTest):
@@ -89,101 +89,101 @@ def test_sock_raises(self):
 
 class TestNetworkingInterface(AsyncUnitTest):
     def setUp(self):
-        self.mock_sock = MagicMock()
-        self.iface = NetworkingInterface(self.mock_sock)
+        self.mock_socket = MagicMock()
+        self.network_interface = NetworkingInterface(self.mock_socket)
 
     def test_gettimeout_delegates(self):
-        self.mock_sock.gettimeout.return_value = 5.0
-        self.assertEqual(self.iface.gettimeout(), 5.0)
+        self.mock_socket.gettimeout.return_value = 5.0
+        self.assertEqual(self.network_interface.gettimeout(), 5.0)
 
     def test_settimeout_delegates(self):
-        self.iface.settimeout(3.0)
-        self.mock_sock.settimeout.assert_called_once_with(3.0)
+        self.network_interface.settimeout(3.0)
+        self.mock_socket.settimeout.assert_called_once_with(3.0)
 
     def test_close_delegates(self):
-        self.iface.close()
-        self.mock_sock.close.assert_called_once()
+        self.network_interface.close()
+        self.mock_socket.close.assert_called_once()
 
     def test_is_closing_delegates(self):
-        self.mock_sock.is_closing.return_value = True
-        self.assertTrue(self.iface.is_closing())
+        self.mock_socket.is_closing.return_value = True
+        self.assertTrue(self.network_interface.is_closing())
 
     def test_fileno_delegates(self):
-        self.mock_sock.fileno.return_value = 42
-        self.assertEqual(self.iface.fileno(), 42)
+        self.mock_socket.fileno.return_value = 42
+        self.assertEqual(self.network_interface.fileno(), 42)
 
     def test_recv_into_delegates(self):
         buf = memoryview(bytearray(10))
-        self.mock_sock.recv_into.return_value = 7
-        result = self.iface.recv_into(buf)
+        self.mock_socket.recv_into.return_value = 7
+        result = self.network_interface.recv_into(buf)
         self.assertEqual(result, 7)
-        self.mock_sock.recv_into.assert_called_once_with(buf)
+        self.mock_socket.recv_into.assert_called_once_with(buf)
 
     def test_get_conn_returns_socket(self):
-        self.assertIs(self.iface.get_conn, self.mock_sock)
+        self.assertIs(self.network_interface.get_conn, self.mock_socket)
 
     def test_sock_returns_socket(self):
-        self.assertIs(self.iface.sock, self.mock_sock)
+        self.assertIs(self.network_interface.sock, self.mock_socket)
 
 
 if not _IS_SYNC:
 
     class TestAsyncNetworkingInterface(AsyncUnitTest):
-        def _make_iface(self):
+        def _make_network_interface(self):
             mock_transport = MagicMock()
             mock_protocol = MagicMock()
             mock_protocol.gettimeout = 10.0
             return AsyncNetworkingInterface((mock_transport, mock_protocol))
 
         def test_gettimeout_returns_protocol_timeout(self):
-            iface = self._make_iface()
-            self.assertEqual(iface.gettimeout, 10.0)
+            network_interface = self._make_network_interface()
+            self.assertEqual(network_interface.gettimeout, 10.0)
 
         def test_settimeout_delegates_to_protocol(self):
-            iface = self._make_iface()
-            iface.settimeout(7.0)
-            iface.conn[1].settimeout.assert_called_once_with(7.0)
+            network_interface = self._make_network_interface()
+            network_interface.settimeout(7.0)
+            network_interface.conn[1].settimeout.assert_called_once_with(7.0)
 
         def test_is_closing_delegates_to_transport(self):
-            iface = self._make_iface()
-            iface.conn[0].is_closing.return_value = False
-            self.assertFalse(iface.is_closing())
+            network_interface = self._make_network_interface()
+            network_interface.conn[0].is_closing.return_value = False
+            self.assertFalse(network_interface.is_closing())
 
         def test_get_conn_returns_protocol(self):
-            iface = self._make_iface()
-            self.assertIs(iface.get_conn, iface.conn[1])
+            network_interface = self._make_network_interface()
+            self.assertIs(network_interface.get_conn, network_interface.conn[1])
 
         def test_sock_returns_transport_socket(self):
-            iface = self._make_iface()
+            network_interface = self._make_network_interface()
             sentinel = object()
-            iface.conn[0].get_extra_info.return_value = sentinel
-            self.assertIs(iface.sock, sentinel)
-            iface.conn[0].get_extra_info.assert_called_once_with("socket")
+            network_interface.conn[0].get_extra_info.return_value = sentinel
+            self.assertIs(network_interface.sock, sentinel)
+            network_interface.conn[0].get_extra_info.assert_called_once_with("socket")
 
     class TestPyMongoProtocol(AsyncUnitTest):
         async def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
-            proto = await _make_protocol()
-            proto._max_message_size = max_size
-            proto._header = memoryview(bytearray(header_bytes))
-            return proto
+            protocol = await _make_protocol()
+            protocol._max_message_size = max_size
+            protocol._header = memoryview(bytearray(header_bytes))
+            return protocol
 
         async def test_initial_timeout_from_constructor(self):
-            proto = await _make_protocol(timeout=3.0)
-            self.assertEqual(proto.gettimeout, 3.0)
+            protocol = await _make_protocol(timeout=3.0)
+            self.assertEqual(protocol.gettimeout, 3.0)
 
         async def test_settimeout_updates_value(self):
-            proto = await _make_protocol()
-            proto.settimeout(7.5)
-            self.assertEqual(proto.gettimeout, 7.5)
+            protocol = await _make_protocol()
+            protocol.settimeout(7.5)
+            self.assertEqual(protocol.gettimeout, 7.5)
 
         async def test_default_timeout_is_none(self):
-            proto = await _make_protocol()
-            self.assertIsNone(proto.gettimeout)
+            protocol = await _make_protocol()
+            self.assertIsNone(protocol.gettimeout)
 
         async def test_normal_op_msg(self):
-            hdr = _make_header(32, 1, 99, 2013)
-            proto = await self._make_proto_with_header(hdr)
-            body_len, op_code, response_to, expecting_compression = proto.process_header()
+            header = _make_header(32, 1, 99, 2013)
+            protocol = await self._make_proto_with_header(header)
+            body_len, op_code, response_to, expecting_compression = protocol.process_header()
             self.assertEqual(body_len, 16)
             self.assertEqual(op_code, 2013)
             self.assertEqual(response_to, 99)
@@ -191,101 +191,101 @@ async def test_normal_op_msg(self):
 
         async def test_op_compressed(self):
             # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
-            hdr = _make_header(35, 1, 0, 2012)
-            proto = await self._make_proto_with_header(hdr)
-            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            header = _make_header(35, 1, 0, 2012)
+            protocol = await self._make_proto_with_header(header)
+            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
             self.assertEqual(body_len, 10)
             self.assertEqual(op_code, 2012)
             self.assertTrue(expecting_compression)
 
         async def test_op_compressed_length_too_small_raises(self):
-            hdr = _make_header(25, 1, 0, 2012)
-            proto = await self._make_proto_with_header(hdr)
+            header = _make_header(25, 1, 0, 2012)
+            protocol = await self._make_proto_with_header(header)
             with self.assertRaises(ProtocolError):
-                proto.process_header()
+                protocol.process_header()
 
         async def test_non_compressed_length_too_small_raises(self):
-            hdr = _make_header(16, 1, 0, 2013)
-            proto = await self._make_proto_with_header(hdr)
+            header = _make_header(16, 1, 0, 2013)
+            protocol = await self._make_proto_with_header(header)
             with self.assertRaises(ProtocolError):
-                proto.process_header()
+                protocol.process_header()
 
         async def test_length_exceeds_max_raises(self):
-            hdr = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
-            proto = await self._make_proto_with_header(hdr)
+            header = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
+            protocol = await self._make_proto_with_header(header)
             with self.assertRaises(ProtocolError):
-                proto.process_header()
+                protocol.process_header()
 
         async def test_op_reply_op_code(self):
-            hdr = _make_header(20, 0, 0, 1)
-            proto = await self._make_proto_with_header(hdr)
-            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            header = _make_header(20, 0, 0, 1)
+            protocol = await self._make_proto_with_header(header)
+            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
             self.assertEqual(body_len, 4)
             self.assertEqual(op_code, 1)
             self.assertFalse(expecting_compression)
 
         async def test_compression_header_returns_op_code_and_compressor_id(self):
-            proto = await _make_protocol()
+            protocol = await _make_protocol()
             # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
-            proto._compression_header = memoryview(bytearray(data))
-            op_code, compressor_id = proto.process_compression_header()
+            protocol._compression_header = memoryview(bytearray(data))
+            op_code, compressor_id = protocol.process_compression_header()
             self.assertEqual(op_code, 2013)
             self.assertEqual(compressor_id, 1)
 
         async def test_compression_header_zlib_compressor_id(self):
-            proto = await _make_protocol()
+            protocol = await _make_protocol()
             data = struct.pack("<iiB", 2013, 0, 2)
-            proto._compression_header = memoryview(bytearray(data))
-            _, compressor_id = proto.process_compression_header()
+            protocol._compression_header = memoryview(bytearray(data))
+            _, compressor_id = protocol.process_compression_header()
             self.assertEqual(compressor_id, 2)
 
         async def test_message_complete_resolves_pending_future(self):
-            proto = await _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message_size = 10
-            proto._message = memoryview(bytearray(10))
-            proto._message_index = 0
-            proto._op_code = 2013
-            proto._compressor_id = None
-            proto._response_to = 42
-
-            fut = asyncio.get_running_loop().create_future()
-            proto._pending_messages.append(fut)
-
-            proto.buffer_updated(10)
-            self.assertTrue(fut.done())
-            op_code, compressor_id, response_to, _ = fut.result()
+            protocol = await _make_protocol()
+            protocol._expecting_header = False
+            protocol._expecting_compression = False
+            protocol._message_size = 10
+            protocol._message = memoryview(bytearray(10))
+            protocol._message_index = 0
+            protocol._op_code = 2013
+            protocol._compressor_id = None
+            protocol._response_to = 42
+
+            future = asyncio.get_running_loop().create_future()
+            protocol._pending_messages.append(future)
+
+            protocol.buffer_updated(10)
+            self.assertTrue(future.done())
+            op_code, compressor_id, response_to, _ = future.result()
             self.assertEqual(op_code, 2013)
             self.assertIsNone(compressor_id)
             self.assertEqual(response_to, 42)
 
         async def test_close_aborts_transport(self):
-            proto = await _make_protocol()
-            proto.close()
-            self.assertTrue(proto.transport.abort.called)
+            protocol = await _make_protocol()
+            protocol.close()
+            self.assertTrue(protocol.transport.abort.called)
 
         async def test_connection_lost_twice_does_not_raise(self):
-            proto = await _make_protocol()
-            proto.connection_lost(None)
-            proto.connection_lost(None)
+            protocol = await _make_protocol()
+            protocol.connection_lost(None)
+            protocol.connection_lost(None)
 
         async def test_close_with_exception_propagates_to_pending(self):
-            proto = await _make_protocol()
-            fut = asyncio.get_running_loop().create_future()
-            proto._pending_messages.append(fut)
+            protocol = await _make_protocol()
+            future = asyncio.get_running_loop().create_future()
+            protocol._pending_messages.append(future)
             exc = OSError("connection reset")
-            proto.close(exc)
+            protocol.close(exc)
             with self.assertRaises(OSError) as ctx:
-                await fut
+                await future
             self.assertIn("connection reset", str(ctx.exception))
 
     class TestAsyncSocketReceive(AsyncUnitTest):
         async def test_reads_full_data_in_one_call(self):
             data = b"hello world!"
             length = len(data)
-            mock_sock = MagicMock()
+            mock_socket = MagicMock()
             loop = asyncio.get_running_loop()
 
             async def fake_recv_into(sock, buf):
@@ -293,14 +293,14 @@ async def fake_recv_into(sock, buf):
                 return length
 
             with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                result = await _async_socket_receive(mock_sock, length, loop)
+                result = await _async_socket_receive(mock_socket, length, loop)
             self.assertEqual(bytes(result), data)
 
         async def test_reads_data_in_multiple_chunks(self):
             data = b"abcdefgh"
             length = len(data)
             chunk1, chunk2 = data[:4], data[4:]
-            mock_sock = MagicMock()
+            mock_socket = MagicMock()
             loop = asyncio.get_running_loop()
             calls = 0
 
@@ -315,11 +315,11 @@ async def fake_recv_into(sock, buf):
                 return len(chunk2)
 
             with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                result = await _async_socket_receive(mock_sock, length, loop)
+                result = await _async_socket_receive(mock_socket, length, loop)
             self.assertEqual(bytes(result), data)
 
         async def test_raises_on_connection_closed(self):
-            mock_sock = MagicMock()
+            mock_socket = MagicMock()
             loop = asyncio.get_running_loop()
 
             async def fake_recv_into(sock, buf):
@@ -327,7 +327,7 @@ async def fake_recv_into(sock, buf):
 
             with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
                 with self.assertRaises(OSError) as ctx:
-                    await _async_socket_receive(mock_sock, 10, loop)
+                    await _async_socket_receive(mock_socket, 10, loop)
             self.assertIn("connection closed", str(ctx.exception))
 
 
diff --git a/test/test_network_layer.py b/test/test_network_layer.py
index 881c259892..b0f64adf28 100644
--- a/test/test_network_layer.py
+++ b/test/test_network_layer.py
@@ -39,11 +39,11 @@
 
 
 def _make_protocol(timeout=None):
-    proto = PyMongoProtocol(timeout=timeout)
+    protocol = PyMongoProtocol(timeout=timeout)
     mock_transport = MagicMock()
     mock_transport.is_closing.return_value = False
-    proto.transport = mock_transport
-    return proto
+    protocol.transport = mock_transport
+    return protocol
 
 
 def _make_header(length, request_id, response_to, op_code):
@@ -52,9 +52,9 @@ def _make_header(length, request_id, response_to, op_code):
 
 class TestSendall(UnitTest):
     def test_delegates_to_sock_sendall(self):
-        mock_sock = MagicMock()
-        sendall(mock_sock, b"hello")
-        mock_sock.sendall.assert_called_once_with(b"hello")
+        mock_socket = MagicMock()
+        sendall(mock_socket, b"hello")
+        mock_socket.sendall.assert_called_once_with(b"hello")
 
 
 class TestNetworkingInterfaceBase(UnitTest):
@@ -88,101 +88,101 @@ def test_sock_raises(self):
 
 class TestNetworkingInterface(UnitTest):
     def setUp(self):
-        self.mock_sock = MagicMock()
-        self.iface = NetworkingInterface(self.mock_sock)
+        self.mock_socket = MagicMock()
+        self.network_interface = NetworkingInterface(self.mock_socket)
 
     def test_gettimeout_delegates(self):
-        self.mock_sock.gettimeout.return_value = 5.0
-        self.assertEqual(self.iface.gettimeout(), 5.0)
+        self.mock_socket.gettimeout.return_value = 5.0
+        self.assertEqual(self.network_interface.gettimeout(), 5.0)
 
     def test_settimeout_delegates(self):
-        self.iface.settimeout(3.0)
-        self.mock_sock.settimeout.assert_called_once_with(3.0)
+        self.network_interface.settimeout(3.0)
+        self.mock_socket.settimeout.assert_called_once_with(3.0)
 
     def test_close_delegates(self):
-        self.iface.close()
-        self.mock_sock.close.assert_called_once()
+        self.network_interface.close()
+        self.mock_socket.close.assert_called_once()
 
     def test_is_closing_delegates(self):
-        self.mock_sock.is_closing.return_value = True
-        self.assertTrue(self.iface.is_closing())
+        self.mock_socket.is_closing.return_value = True
+        self.assertTrue(self.network_interface.is_closing())
 
     def test_fileno_delegates(self):
-        self.mock_sock.fileno.return_value = 42
-        self.assertEqual(self.iface.fileno(), 42)
+        self.mock_socket.fileno.return_value = 42
+        self.assertEqual(self.network_interface.fileno(), 42)
 
     def test_recv_into_delegates(self):
         buf = memoryview(bytearray(10))
-        self.mock_sock.recv_into.return_value = 7
-        result = self.iface.recv_into(buf)
+        self.mock_socket.recv_into.return_value = 7
+        result = self.network_interface.recv_into(buf)
         self.assertEqual(result, 7)
-        self.mock_sock.recv_into.assert_called_once_with(buf)
+        self.mock_socket.recv_into.assert_called_once_with(buf)
 
     def test_get_conn_returns_socket(self):
-        self.assertIs(self.iface.get_conn, self.mock_sock)
+        self.assertIs(self.network_interface.get_conn, self.mock_socket)
 
     def test_sock_returns_socket(self):
-        self.assertIs(self.iface.sock, self.mock_sock)
+        self.assertIs(self.network_interface.sock, self.mock_socket)
 
 
 if not _IS_SYNC:
 
     class TestNetworkingInterface(UnitTest):
-        def _make_iface(self):
+        def _make_network_interface(self):
             mock_transport = MagicMock()
             mock_protocol = MagicMock()
             mock_protocol.gettimeout = 10.0
             return NetworkingInterface((mock_transport, mock_protocol))
 
         def test_gettimeout_returns_protocol_timeout(self):
-            iface = self._make_iface()
-            self.assertEqual(iface.gettimeout, 10.0)
+            network_interface = self._make_network_interface()
+            self.assertEqual(network_interface.gettimeout, 10.0)
 
         def test_settimeout_delegates_to_protocol(self):
-            iface = self._make_iface()
-            iface.settimeout(7.0)
-            iface.conn[1].settimeout.assert_called_once_with(7.0)
+            network_interface = self._make_network_interface()
+            network_interface.settimeout(7.0)
+            network_interface.conn[1].settimeout.assert_called_once_with(7.0)
 
         def test_is_closing_delegates_to_transport(self):
-            iface = self._make_iface()
-            iface.conn[0].is_closing.return_value = False
-            self.assertFalse(iface.is_closing())
+            network_interface = self._make_network_interface()
+            network_interface.conn[0].is_closing.return_value = False
+            self.assertFalse(network_interface.is_closing())
 
         def test_get_conn_returns_protocol(self):
-            iface = self._make_iface()
-            self.assertIs(iface.get_conn, iface.conn[1])
+            network_interface = self._make_network_interface()
+            self.assertIs(network_interface.get_conn, network_interface.conn[1])
 
         def test_sock_returns_transport_socket(self):
-            iface = self._make_iface()
+            network_interface = self._make_network_interface()
             sentinel = object()
-            iface.conn[0].get_extra_info.return_value = sentinel
-            self.assertIs(iface.sock, sentinel)
-            iface.conn[0].get_extra_info.assert_called_once_with("socket")
+            network_interface.conn[0].get_extra_info.return_value = sentinel
+            self.assertIs(network_interface.sock, sentinel)
+            network_interface.conn[0].get_extra_info.assert_called_once_with("socket")
 
     class TestPyMongoProtocol(UnitTest):
         def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
-            proto = _make_protocol()
-            proto._max_message_size = max_size
-            proto._header = memoryview(bytearray(header_bytes))
-            return proto
+            protocol = _make_protocol()
+            protocol._max_message_size = max_size
+            protocol._header = memoryview(bytearray(header_bytes))
+            return protocol
 
         def test_initial_timeout_from_constructor(self):
-            proto = _make_protocol(timeout=3.0)
-            self.assertEqual(proto.gettimeout, 3.0)
+            protocol = _make_protocol(timeout=3.0)
+            self.assertEqual(protocol.gettimeout, 3.0)
 
         def test_settimeout_updates_value(self):
-            proto = _make_protocol()
-            proto.settimeout(7.5)
-            self.assertEqual(proto.gettimeout, 7.5)
+            protocol = _make_protocol()
+            protocol.settimeout(7.5)
+            self.assertEqual(protocol.gettimeout, 7.5)
 
         def test_default_timeout_is_none(self):
-            proto = _make_protocol()
-            self.assertIsNone(proto.gettimeout)
+            protocol = _make_protocol()
+            self.assertIsNone(protocol.gettimeout)
 
         def test_normal_op_msg(self):
-            hdr = _make_header(32, 1, 99, 2013)
-            proto = self._make_proto_with_header(hdr)
-            body_len, op_code, response_to, expecting_compression = proto.process_header()
+            header = _make_header(32, 1, 99, 2013)
+            protocol = self._make_proto_with_header(header)
+            body_len, op_code, response_to, expecting_compression = protocol.process_header()
             self.assertEqual(body_len, 16)
             self.assertEqual(op_code, 2013)
             self.assertEqual(response_to, 99)
@@ -190,101 +190,101 @@ def test_normal_op_msg(self):
 
         def test_op_compressed(self):
             # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
-            hdr = _make_header(35, 1, 0, 2012)
-            proto = self._make_proto_with_header(hdr)
-            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            header = _make_header(35, 1, 0, 2012)
+            protocol = self._make_proto_with_header(header)
+            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
             self.assertEqual(body_len, 10)
             self.assertEqual(op_code, 2012)
             self.assertTrue(expecting_compression)
 
         def test_op_compressed_length_too_small_raises(self):
-            hdr = _make_header(25, 1, 0, 2012)
-            proto = self._make_proto_with_header(hdr)
+            header = _make_header(25, 1, 0, 2012)
+            protocol = self._make_proto_with_header(header)
             with self.assertRaises(ProtocolError):
-                proto.process_header()
+                protocol.process_header()
 
         def test_non_compressed_length_too_small_raises(self):
-            hdr = _make_header(16, 1, 0, 2013)
-            proto = self._make_proto_with_header(hdr)
+            header = _make_header(16, 1, 0, 2013)
+            protocol = self._make_proto_with_header(header)
             with self.assertRaises(ProtocolError):
-                proto.process_header()
+                protocol.process_header()
 
         def test_length_exceeds_max_raises(self):
-            hdr = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
-            proto = self._make_proto_with_header(hdr)
+            header = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
+            protocol = self._make_proto_with_header(header)
             with self.assertRaises(ProtocolError):
-                proto.process_header()
+                protocol.process_header()
 
         def test_op_reply_op_code(self):
-            hdr = _make_header(20, 0, 0, 1)
-            proto = self._make_proto_with_header(hdr)
-            body_len, op_code, _response_to, expecting_compression = proto.process_header()
+            header = _make_header(20, 0, 0, 1)
+            protocol = self._make_proto_with_header(header)
+            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
             self.assertEqual(body_len, 4)
             self.assertEqual(op_code, 1)
             self.assertFalse(expecting_compression)
 
         def test_compression_header_returns_op_code_and_compressor_id(self):
-            proto = _make_protocol()
+            protocol = _make_protocol()
             # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
-            proto._compression_header = memoryview(bytearray(data))
-            op_code, compressor_id = proto.process_compression_header()
+            protocol._compression_header = memoryview(bytearray(data))
+            op_code, compressor_id = protocol.process_compression_header()
             self.assertEqual(op_code, 2013)
             self.assertEqual(compressor_id, 1)
 
         def test_compression_header_zlib_compressor_id(self):
-            proto = _make_protocol()
+            protocol = _make_protocol()
             data = struct.pack("<iiB", 2013, 0, 2)
-            proto._compression_header = memoryview(bytearray(data))
-            _, compressor_id = proto.process_compression_header()
+            protocol._compression_header = memoryview(bytearray(data))
+            _, compressor_id = protocol.process_compression_header()
             self.assertEqual(compressor_id, 2)
 
         def test_message_complete_resolves_pending_future(self):
-            proto = _make_protocol()
-            proto._expecting_header = False
-            proto._expecting_compression = False
-            proto._message_size = 10
-            proto._message = memoryview(bytearray(10))
-            proto._message_index = 0
-            proto._op_code = 2013
-            proto._compressor_id = None
-            proto._response_to = 42
-
-            fut = asyncio.get_running_loop().create_future()
-            proto._pending_messages.append(fut)
-
-            proto.buffer_updated(10)
-            self.assertTrue(fut.done())
-            op_code, compressor_id, response_to, _ = fut.result()
+            protocol = _make_protocol()
+            protocol._expecting_header = False
+            protocol._expecting_compression = False
+            protocol._message_size = 10
+            protocol._message = memoryview(bytearray(10))
+            protocol._message_index = 0
+            protocol._op_code = 2013
+            protocol._compressor_id = None
+            protocol._response_to = 42
+
+            future = asyncio.get_running_loop().create_future()
+            protocol._pending_messages.append(future)
+
+            protocol.buffer_updated(10)
+            self.assertTrue(future.done())
+            op_code, compressor_id, response_to, _ = future.result()
             self.assertEqual(op_code, 2013)
             self.assertIsNone(compressor_id)
             self.assertEqual(response_to, 42)
 
         def test_close_aborts_transport(self):
-            proto = _make_protocol()
-            proto.close()
-            self.assertTrue(proto.transport.abort.called)
+            protocol = _make_protocol()
+            protocol.close()
+            self.assertTrue(protocol.transport.abort.called)
 
         def test_connection_lost_twice_does_not_raise(self):
-            proto = _make_protocol()
-            proto.connection_lost(None)
-            proto.connection_lost(None)
+            protocol = _make_protocol()
+            protocol.connection_lost(None)
+            protocol.connection_lost(None)
 
         def test_close_with_exception_propagates_to_pending(self):
-            proto = _make_protocol()
-            fut = asyncio.get_running_loop().create_future()
-            proto._pending_messages.append(fut)
+            protocol = _make_protocol()
+            future = asyncio.get_running_loop().create_future()
+            protocol._pending_messages.append(future)
             exc = OSError("connection reset")
-            proto.close(exc)
+            protocol.close(exc)
             with self.assertRaises(OSError) as ctx:
-                fut
+                future
             self.assertIn("connection reset", str(ctx.exception))
 
     class TestAsyncSocketReceive(UnitTest):
         def test_reads_full_data_in_one_call(self):
             data = b"hello world!"
             length = len(data)
-            mock_sock = MagicMock()
+            mock_socket = MagicMock()
             loop = asyncio.get_running_loop()
 
             def fake_recv_into(sock, buf):
@@ -292,14 +292,14 @@ def fake_recv_into(sock, buf):
                 return length
 
             with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
-                result = _async_socket_receive(mock_sock, length, loop)
+                result = _async_socket_receive(mock_socket, length, loop)
             self.assertEqual(bytes(result), data)
 
         def test_reads_data_in_multiple_chunks(self):
             data = b"abcdefgh"
             length = len(data)
             chunk1, chunk2 = data[:4], data[4:]
-            mock_sock = MagicMock()
+            mock_socket = MagicMock()
             loop = asyncio.get_running_loop()
             calls = 0
 
@@ -314,11 +314,11 @@ def fake_recv_into(sock, buf):
                 return len(chunk2)
 
             with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
-                result = _async_socket_receive(mock_sock, length, loop)
+                result = _async_socket_receive(mock_socket, length, loop)
             self.assertEqual(bytes(result), data)
 
         def test_raises_on_connection_closed(self):
-            mock_sock = MagicMock()
+            mock_socket = MagicMock()
             loop = asyncio.get_running_loop()
 
             def fake_recv_into(sock, buf):
@@ -326,7 +326,7 @@ def fake_recv_into(sock, buf):
 
             with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
                 with self.assertRaises(OSError) as ctx:
-                    _async_socket_receive(mock_sock, 10, loop)
+                    _async_socket_receive(mock_socket, 10, loop)
             self.assertIn("connection closed", str(ctx.exception))
 
 

From cdc07e3ed99f474daf78696c9a054b552d6e288f Mon Sep 17 00:00:00 2001
From: Jeffrey 'Alex' Clark <aclark@aclark.net>
Date: Tue, 5 May 2026 20:50:49 -0400
Subject: [PATCH 6/7] Update OP_COMPRESSED comment

---
 test/asynchronous/test_network_layer.py | 2 +-
 test/test_network_layer.py              | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/asynchronous/test_network_layer.py b/test/asynchronous/test_network_layer.py
index 88e1d56a6e..8e806ba763 100644
--- a/test/asynchronous/test_network_layer.py
+++ b/test/asynchronous/test_network_layer.py
@@ -226,7 +226,7 @@ async def test_op_reply_op_code(self):
 
         async def test_compression_header_returns_op_code_and_compressor_id(self):
             protocol = await _make_protocol()
-            # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
+            # <iiB: little-endian, i32 op code=2013, i32 uncompressed size=0, u8 compressor id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
             protocol._compression_header = memoryview(bytearray(data))
             op_code, compressor_id = protocol.process_compression_header()
diff --git a/test/test_network_layer.py b/test/test_network_layer.py
index b0f64adf28..6ca37d2cce 100644
--- a/test/test_network_layer.py
+++ b/test/test_network_layer.py
@@ -225,7 +225,7 @@ def test_op_reply_op_code(self):
 
         def test_compression_header_returns_op_code_and_compressor_id(self):
             protocol = _make_protocol()
-            # op_code=2013, uncompressed_size=0, compressor_id=1 (snappy)
+            # <iiB: little-endian, i32 op code=2013, i32 uncompressed size=0, u8 compressor id=1 (snappy)
             data = struct.pack("<iiB", 2013, 0, 1)
             protocol._compression_header = memoryview(bytearray(data))
             op_code, compressor_id = protocol.process_compression_header()

From 33c8039298a669472bd2051329673cf98db180aa Mon Sep 17 00:00:00 2001
From: Jeffrey 'Alex' Clark <aclark@aclark.net>
Date: Wed, 6 May 2026 17:22:56 -0400
Subject: [PATCH 7/7] Noah + Copilot review

---
 test/asynchronous/test_async_network_layer.py | 211 +++++++++++++
 test/asynchronous/test_network_layer.py       | 285 +-----------------
 test/test_network_layer.py                    | 282 +----------------
 tools/synchro.py                              |   1 +
 4 files changed, 225 insertions(+), 554 deletions(-)
 create mode 100644 test/asynchronous/test_async_network_layer.py

diff --git a/test/asynchronous/test_async_network_layer.py b/test/asynchronous/test_async_network_layer.py
new file mode 100644
index 0000000000..2480bbf61c
--- /dev/null
+++ b/test/asynchronous/test_async_network_layer.py
@@ -0,0 +1,211 @@
+# Copyright 2026-present MongoDB, Inc.
+#
+# Licensed 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
+#
+# https://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.
+
+"""Async-only unit tests for network_layer.py."""
+
+from __future__ import annotations
+
+import asyncio
+import struct
+import sys
+from unittest.mock import AsyncMock, MagicMock, patch
+
+sys.path[0:0] = [""]
+
+from test.asynchronous import AsyncUnitTest, unittest
+
+from pymongo.common import MAX_MESSAGE_SIZE
+from pymongo.errors import ProtocolError
+from pymongo.network_layer import PyMongoProtocol, _async_socket_receive
+
+
+async def _make_protocol(timeout=None):
+    protocol = PyMongoProtocol(timeout=timeout)
+    mock_transport = MagicMock()
+    mock_transport.is_closing.return_value = False
+    protocol.transport = mock_transport
+    return protocol
+
+
+def _make_header(length, request_id, response_to, op_code):
+    return struct.pack("<iiii", length, request_id, response_to, op_code)
+
+
+class TestPyMongoProtocol(AsyncUnitTest):
+    async def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
+        protocol = await _make_protocol()
+        protocol._max_message_size = max_size
+        protocol._header = memoryview(bytearray(header_bytes))
+        return protocol
+
+    async def test_initial_timeout_from_constructor(self):
+        protocol = await _make_protocol(timeout=3.0)
+        self.assertEqual(protocol.gettimeout, 3.0)
+
+    async def test_settimeout_updates_value(self):
+        protocol = await _make_protocol()
+        protocol.settimeout(7.5)
+        self.assertEqual(protocol.gettimeout, 7.5)
+
+    async def test_default_timeout_is_none(self):
+        protocol = await _make_protocol()
+        self.assertIsNone(protocol.gettimeout)
+
+    async def test_normal_op_msg(self):
+        header = _make_header(length=32, request_id=1, response_to=99, op_code=2013)
+        protocol = await self._make_proto_with_header(header)
+        body_len, op_code, response_to, expecting_compression = protocol.process_header()
+        self.assertEqual(body_len, 16)
+        self.assertEqual(op_code, 2013)
+        self.assertEqual(response_to, 99)
+        self.assertFalse(expecting_compression)
+
+    async def test_op_compressed(self):
+        # OP_COMPRESSED=2012; process_header strips the 9-byte compression sub-header
+        # (op code + uncompressed size + compressor id), then the 16-byte standard header.
+        # length=35 → after compression sub-header: 26 → body: 10
+        header = _make_header(length=35, request_id=1, response_to=0, op_code=2012)
+        protocol = await self._make_proto_with_header(header)
+        body_len, op_code, _response_to, expecting_compression = protocol.process_header()
+        self.assertEqual(body_len, 10)
+        self.assertEqual(op_code, 2012)
+        self.assertTrue(expecting_compression)
+
+    async def test_op_compressed_length_too_small_raises(self):
+        header = _make_header(length=25, request_id=1, response_to=0, op_code=2012)
+        protocol = await self._make_proto_with_header(header)
+        with self.assertRaises(ProtocolError):
+            protocol.process_header()
+
+    async def test_non_compressed_length_too_small_raises(self):
+        header = _make_header(length=16, request_id=1, response_to=0, op_code=2013)
+        protocol = await self._make_proto_with_header(header)
+        with self.assertRaises(ProtocolError):
+            protocol.process_header()
+
+    async def test_length_exceeds_max_raises(self):
+        header = _make_header(
+            length=MAX_MESSAGE_SIZE + 1, request_id=1, response_to=0, op_code=2013
+        )
+        protocol = await self._make_proto_with_header(header)
+        with self.assertRaises(ProtocolError):
+            protocol.process_header()
+
+    async def test_op_reply_op_code(self):
+        header = _make_header(length=20, request_id=0, response_to=0, op_code=1)
+        protocol = await self._make_proto_with_header(header)
+        body_len, op_code, _response_to, expecting_compression = protocol.process_header()
+        self.assertEqual(body_len, 4)
+        self.assertEqual(op_code, 1)
+        self.assertFalse(expecting_compression)
+
+    async def test_compression_header_snappy_compressor_id(self):
+        protocol = await _make_protocol()
+        # <iiB: little-endian, i32 op code=2013, i32 uncompressed size=0, u8 compressor id=1 (snappy)
+        data = struct.pack("<iiB", 2013, 0, 1)
+        protocol._compression_header = memoryview(bytearray(data))
+        op_code, compressor_id = protocol.process_compression_header()
+        self.assertEqual(op_code, 2013)
+        self.assertEqual(compressor_id, 1)
+
+    async def test_compression_header_zlib_compressor_id(self):
+        protocol = await _make_protocol()
+        data = struct.pack("<iiB", 2013, 0, 2)
+        protocol._compression_header = memoryview(bytearray(data))
+        _, compressor_id = protocol.process_compression_header()
+        self.assertEqual(compressor_id, 2)
+
+    async def test_message_complete_resolves_pending_future(self):
+        protocol = await _make_protocol()
+        protocol._expecting_header = False
+        protocol._expecting_compression = False
+        protocol._message_size = 10
+        protocol._message = memoryview(bytearray(10))
+        protocol._message_index = 0
+        protocol._op_code = 2013
+        protocol._compressor_id = None
+        protocol._response_to = 42
+
+        future = asyncio.get_running_loop().create_future()
+        protocol._pending_messages.append(future)
+
+        protocol.buffer_updated(10)
+        self.assertTrue(future.done())
+        op_code, compressor_id, response_to, _ = future.result()
+        self.assertEqual(op_code, 2013)
+        self.assertIsNone(compressor_id)
+        self.assertEqual(response_to, 42)
+
+    async def test_close_aborts_transport(self):
+        protocol = await _make_protocol()
+        protocol.close()
+        self.assertTrue(protocol.transport.abort.called)
+
+    async def test_connection_lost_twice_does_not_raise(self):
+        protocol = await _make_protocol()
+        protocol.connection_lost(None)
+        protocol.connection_lost(None)
+
+    async def test_close_with_exception_propagates_to_pending(self):
+        protocol = await _make_protocol()
+        future = asyncio.get_running_loop().create_future()
+        protocol._pending_messages.append(future)
+        exc = OSError("connection reset")
+        protocol.close(exc)
+        with self.assertRaisesRegex(OSError, "connection reset"):
+            await future
+
+
+class TestAsyncSocketReceive(AsyncUnitTest):
+    async def test_reads_data_in_multiple_chunks(self):
+        # Covers the loop in _async_socket_receive that accumulates short reads
+        # until the requested length has been received.
+        data = b"abcdefgh"
+        length = len(data)
+        chunk1, chunk2 = data[:4], data[4:]
+        mock_socket = MagicMock()
+        loop = asyncio.get_running_loop()
+        calls = 0
+
+        async def fake_recv_into(sock, buf):
+            nonlocal calls
+            if calls == 0:
+                buf[: len(chunk1)] = chunk1
+                calls += 1
+                return len(chunk1)
+            buf[: len(chunk2)] = chunk2
+            calls += 1
+            return len(chunk2)
+
+        with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+            result = await _async_socket_receive(mock_socket, length, loop)
+        self.assertEqual(bytes(result), data)
+        self.assertEqual(calls, 2)
+
+    async def test_raises_on_connection_closed(self):
+        # Covers the explicit `raise OSError("connection closed")` branch when
+        # sock_recv_into returns 0.
+        mock_socket = MagicMock()
+        loop = asyncio.get_running_loop()
+
+        async def fake_recv_into(sock, buf):
+            return 0
+
+        with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
+            with self.assertRaisesRegex(OSError, "connection closed"):
+                await _async_socket_receive(mock_socket, 10, loop)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/test/asynchronous/test_network_layer.py b/test/asynchronous/test_network_layer.py
index 8e806ba763..4b6511490b 100644
--- a/test/asynchronous/test_network_layer.py
+++ b/test/asynchronous/test_network_layer.py
@@ -12,54 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Unit tests for network_layer.py."""
+"""Unit tests for code in network_layer.py shared between sync and async APIs.
+
+Async-only tests live in ``test_async_network_layer.py``.
+"""
 
 from __future__ import annotations
 
-import asyncio
-import struct
 import sys
-from unittest.mock import AsyncMock, MagicMock, patch
+from unittest.mock import MagicMock
 
 sys.path[0:0] = [""]
 
 from test.asynchronous import AsyncUnitTest, unittest
 
-from pymongo.common import MAX_MESSAGE_SIZE
-from pymongo.errors import ProtocolError
-from pymongo.network_layer import (
-    AsyncNetworkingInterface,
-    NetworkingInterface,
-    NetworkingInterfaceBase,
-    PyMongoProtocol,
-    _async_socket_receive,
-    sendall,
-)
+from pymongo.network_layer import NetworkingInterfaceBase
 
 _IS_SYNC = False
 
 
-async def _make_protocol(timeout=None):
-    protocol = PyMongoProtocol(timeout=timeout)
-    mock_transport = MagicMock()
-    mock_transport.is_closing.return_value = False
-    protocol.transport = mock_transport
-    return protocol
-
-
-def _make_header(length, request_id, response_to, op_code):
-    return struct.pack("<iiii", length, request_id, response_to, op_code)
-
-
-class TestSendall(AsyncUnitTest):
-    def test_delegates_to_sock_sendall(self):
-        mock_socket = MagicMock()
-        sendall(mock_socket, b"hello")
-        mock_socket.sendall.assert_called_once_with(b"hello")
-
-
 class TestNetworkingInterfaceBase(AsyncUnitTest):
-    def setUp(self):
+    async def asyncSetUp(self):
         self.base = NetworkingInterfaceBase(MagicMock())
 
     def test_gettimeout_raises(self):
@@ -87,249 +60,5 @@ def test_sock_raises(self):
             _ = self.base.sock
 
 
-class TestNetworkingInterface(AsyncUnitTest):
-    def setUp(self):
-        self.mock_socket = MagicMock()
-        self.network_interface = NetworkingInterface(self.mock_socket)
-
-    def test_gettimeout_delegates(self):
-        self.mock_socket.gettimeout.return_value = 5.0
-        self.assertEqual(self.network_interface.gettimeout(), 5.0)
-
-    def test_settimeout_delegates(self):
-        self.network_interface.settimeout(3.0)
-        self.mock_socket.settimeout.assert_called_once_with(3.0)
-
-    def test_close_delegates(self):
-        self.network_interface.close()
-        self.mock_socket.close.assert_called_once()
-
-    def test_is_closing_delegates(self):
-        self.mock_socket.is_closing.return_value = True
-        self.assertTrue(self.network_interface.is_closing())
-
-    def test_fileno_delegates(self):
-        self.mock_socket.fileno.return_value = 42
-        self.assertEqual(self.network_interface.fileno(), 42)
-
-    def test_recv_into_delegates(self):
-        buf = memoryview(bytearray(10))
-        self.mock_socket.recv_into.return_value = 7
-        result = self.network_interface.recv_into(buf)
-        self.assertEqual(result, 7)
-        self.mock_socket.recv_into.assert_called_once_with(buf)
-
-    def test_get_conn_returns_socket(self):
-        self.assertIs(self.network_interface.get_conn, self.mock_socket)
-
-    def test_sock_returns_socket(self):
-        self.assertIs(self.network_interface.sock, self.mock_socket)
-
-
-if not _IS_SYNC:
-
-    class TestAsyncNetworkingInterface(AsyncUnitTest):
-        def _make_network_interface(self):
-            mock_transport = MagicMock()
-            mock_protocol = MagicMock()
-            mock_protocol.gettimeout = 10.0
-            return AsyncNetworkingInterface((mock_transport, mock_protocol))
-
-        def test_gettimeout_returns_protocol_timeout(self):
-            network_interface = self._make_network_interface()
-            self.assertEqual(network_interface.gettimeout, 10.0)
-
-        def test_settimeout_delegates_to_protocol(self):
-            network_interface = self._make_network_interface()
-            network_interface.settimeout(7.0)
-            network_interface.conn[1].settimeout.assert_called_once_with(7.0)
-
-        def test_is_closing_delegates_to_transport(self):
-            network_interface = self._make_network_interface()
-            network_interface.conn[0].is_closing.return_value = False
-            self.assertFalse(network_interface.is_closing())
-
-        def test_get_conn_returns_protocol(self):
-            network_interface = self._make_network_interface()
-            self.assertIs(network_interface.get_conn, network_interface.conn[1])
-
-        def test_sock_returns_transport_socket(self):
-            network_interface = self._make_network_interface()
-            sentinel = object()
-            network_interface.conn[0].get_extra_info.return_value = sentinel
-            self.assertIs(network_interface.sock, sentinel)
-            network_interface.conn[0].get_extra_info.assert_called_once_with("socket")
-
-    class TestPyMongoProtocol(AsyncUnitTest):
-        async def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
-            protocol = await _make_protocol()
-            protocol._max_message_size = max_size
-            protocol._header = memoryview(bytearray(header_bytes))
-            return protocol
-
-        async def test_initial_timeout_from_constructor(self):
-            protocol = await _make_protocol(timeout=3.0)
-            self.assertEqual(protocol.gettimeout, 3.0)
-
-        async def test_settimeout_updates_value(self):
-            protocol = await _make_protocol()
-            protocol.settimeout(7.5)
-            self.assertEqual(protocol.gettimeout, 7.5)
-
-        async def test_default_timeout_is_none(self):
-            protocol = await _make_protocol()
-            self.assertIsNone(protocol.gettimeout)
-
-        async def test_normal_op_msg(self):
-            header = _make_header(32, 1, 99, 2013)
-            protocol = await self._make_proto_with_header(header)
-            body_len, op_code, response_to, expecting_compression = protocol.process_header()
-            self.assertEqual(body_len, 16)
-            self.assertEqual(op_code, 2013)
-            self.assertEqual(response_to, 99)
-            self.assertFalse(expecting_compression)
-
-        async def test_op_compressed(self):
-            # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
-            header = _make_header(35, 1, 0, 2012)
-            protocol = await self._make_proto_with_header(header)
-            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
-            self.assertEqual(body_len, 10)
-            self.assertEqual(op_code, 2012)
-            self.assertTrue(expecting_compression)
-
-        async def test_op_compressed_length_too_small_raises(self):
-            header = _make_header(25, 1, 0, 2012)
-            protocol = await self._make_proto_with_header(header)
-            with self.assertRaises(ProtocolError):
-                protocol.process_header()
-
-        async def test_non_compressed_length_too_small_raises(self):
-            header = _make_header(16, 1, 0, 2013)
-            protocol = await self._make_proto_with_header(header)
-            with self.assertRaises(ProtocolError):
-                protocol.process_header()
-
-        async def test_length_exceeds_max_raises(self):
-            header = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
-            protocol = await self._make_proto_with_header(header)
-            with self.assertRaises(ProtocolError):
-                protocol.process_header()
-
-        async def test_op_reply_op_code(self):
-            header = _make_header(20, 0, 0, 1)
-            protocol = await self._make_proto_with_header(header)
-            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
-            self.assertEqual(body_len, 4)
-            self.assertEqual(op_code, 1)
-            self.assertFalse(expecting_compression)
-
-        async def test_compression_header_returns_op_code_and_compressor_id(self):
-            protocol = await _make_protocol()
-            # <iiB: little-endian, i32 op code=2013, i32 uncompressed size=0, u8 compressor id=1 (snappy)
-            data = struct.pack("<iiB", 2013, 0, 1)
-            protocol._compression_header = memoryview(bytearray(data))
-            op_code, compressor_id = protocol.process_compression_header()
-            self.assertEqual(op_code, 2013)
-            self.assertEqual(compressor_id, 1)
-
-        async def test_compression_header_zlib_compressor_id(self):
-            protocol = await _make_protocol()
-            data = struct.pack("<iiB", 2013, 0, 2)
-            protocol._compression_header = memoryview(bytearray(data))
-            _, compressor_id = protocol.process_compression_header()
-            self.assertEqual(compressor_id, 2)
-
-        async def test_message_complete_resolves_pending_future(self):
-            protocol = await _make_protocol()
-            protocol._expecting_header = False
-            protocol._expecting_compression = False
-            protocol._message_size = 10
-            protocol._message = memoryview(bytearray(10))
-            protocol._message_index = 0
-            protocol._op_code = 2013
-            protocol._compressor_id = None
-            protocol._response_to = 42
-
-            future = asyncio.get_running_loop().create_future()
-            protocol._pending_messages.append(future)
-
-            protocol.buffer_updated(10)
-            self.assertTrue(future.done())
-            op_code, compressor_id, response_to, _ = future.result()
-            self.assertEqual(op_code, 2013)
-            self.assertIsNone(compressor_id)
-            self.assertEqual(response_to, 42)
-
-        async def test_close_aborts_transport(self):
-            protocol = await _make_protocol()
-            protocol.close()
-            self.assertTrue(protocol.transport.abort.called)
-
-        async def test_connection_lost_twice_does_not_raise(self):
-            protocol = await _make_protocol()
-            protocol.connection_lost(None)
-            protocol.connection_lost(None)
-
-        async def test_close_with_exception_propagates_to_pending(self):
-            protocol = await _make_protocol()
-            future = asyncio.get_running_loop().create_future()
-            protocol._pending_messages.append(future)
-            exc = OSError("connection reset")
-            protocol.close(exc)
-            with self.assertRaises(OSError) as ctx:
-                await future
-            self.assertIn("connection reset", str(ctx.exception))
-
-    class TestAsyncSocketReceive(AsyncUnitTest):
-        async def test_reads_full_data_in_one_call(self):
-            data = b"hello world!"
-            length = len(data)
-            mock_socket = MagicMock()
-            loop = asyncio.get_running_loop()
-
-            async def fake_recv_into(sock, buf):
-                buf[:length] = data
-                return length
-
-            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                result = await _async_socket_receive(mock_socket, length, loop)
-            self.assertEqual(bytes(result), data)
-
-        async def test_reads_data_in_multiple_chunks(self):
-            data = b"abcdefgh"
-            length = len(data)
-            chunk1, chunk2 = data[:4], data[4:]
-            mock_socket = MagicMock()
-            loop = asyncio.get_running_loop()
-            calls = 0
-
-            async def fake_recv_into(sock, buf):
-                nonlocal calls
-                if calls == 0:
-                    buf[: len(chunk1)] = chunk1
-                    calls += 1
-                    return len(chunk1)
-                buf[: len(chunk2)] = chunk2
-                calls += 1
-                return len(chunk2)
-
-            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                result = await _async_socket_receive(mock_socket, length, loop)
-            self.assertEqual(bytes(result), data)
-
-        async def test_raises_on_connection_closed(self):
-            mock_socket = MagicMock()
-            loop = asyncio.get_running_loop()
-
-            async def fake_recv_into(sock, buf):
-                return 0
-
-            with patch.object(loop, "sock_recv_into", new=AsyncMock(side_effect=fake_recv_into)):
-                with self.assertRaises(OSError) as ctx:
-                    await _async_socket_receive(mock_socket, 10, loop)
-            self.assertIn("connection closed", str(ctx.exception))
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/test_network_layer.py b/test/test_network_layer.py
index 6ca37d2cce..8f3281de1c 100644
--- a/test/test_network_layer.py
+++ b/test/test_network_layer.py
@@ -12,51 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Unit tests for network_layer.py."""
+"""Unit tests for code in network_layer.py shared between sync and async APIs.
+
+Async-only tests live in ``test_async_network_layer.py``.
+"""
 
 from __future__ import annotations
 
-import asyncio
-import struct
 import sys
-from unittest.mock import MagicMock, patch
+from unittest.mock import MagicMock
 
 sys.path[0:0] = [""]
 
 from test import UnitTest, unittest
 
-from pymongo.common import MAX_MESSAGE_SIZE
-from pymongo.errors import ProtocolError
-from pymongo.network_layer import (
-    NetworkingInterface,
-    NetworkingInterfaceBase,
-    PyMongoProtocol,
-    _async_socket_receive,
-    sendall,
-)
+from pymongo.network_layer import NetworkingInterfaceBase
 
 _IS_SYNC = True
 
 
-def _make_protocol(timeout=None):
-    protocol = PyMongoProtocol(timeout=timeout)
-    mock_transport = MagicMock()
-    mock_transport.is_closing.return_value = False
-    protocol.transport = mock_transport
-    return protocol
-
-
-def _make_header(length, request_id, response_to, op_code):
-    return struct.pack("<iiii", length, request_id, response_to, op_code)
-
-
-class TestSendall(UnitTest):
-    def test_delegates_to_sock_sendall(self):
-        mock_socket = MagicMock()
-        sendall(mock_socket, b"hello")
-        mock_socket.sendall.assert_called_once_with(b"hello")
-
-
 class TestNetworkingInterfaceBase(UnitTest):
     def setUp(self):
         self.base = NetworkingInterfaceBase(MagicMock())
@@ -86,249 +60,5 @@ def test_sock_raises(self):
             _ = self.base.sock
 
 
-class TestNetworkingInterface(UnitTest):
-    def setUp(self):
-        self.mock_socket = MagicMock()
-        self.network_interface = NetworkingInterface(self.mock_socket)
-
-    def test_gettimeout_delegates(self):
-        self.mock_socket.gettimeout.return_value = 5.0
-        self.assertEqual(self.network_interface.gettimeout(), 5.0)
-
-    def test_settimeout_delegates(self):
-        self.network_interface.settimeout(3.0)
-        self.mock_socket.settimeout.assert_called_once_with(3.0)
-
-    def test_close_delegates(self):
-        self.network_interface.close()
-        self.mock_socket.close.assert_called_once()
-
-    def test_is_closing_delegates(self):
-        self.mock_socket.is_closing.return_value = True
-        self.assertTrue(self.network_interface.is_closing())
-
-    def test_fileno_delegates(self):
-        self.mock_socket.fileno.return_value = 42
-        self.assertEqual(self.network_interface.fileno(), 42)
-
-    def test_recv_into_delegates(self):
-        buf = memoryview(bytearray(10))
-        self.mock_socket.recv_into.return_value = 7
-        result = self.network_interface.recv_into(buf)
-        self.assertEqual(result, 7)
-        self.mock_socket.recv_into.assert_called_once_with(buf)
-
-    def test_get_conn_returns_socket(self):
-        self.assertIs(self.network_interface.get_conn, self.mock_socket)
-
-    def test_sock_returns_socket(self):
-        self.assertIs(self.network_interface.sock, self.mock_socket)
-
-
-if not _IS_SYNC:
-
-    class TestNetworkingInterface(UnitTest):
-        def _make_network_interface(self):
-            mock_transport = MagicMock()
-            mock_protocol = MagicMock()
-            mock_protocol.gettimeout = 10.0
-            return NetworkingInterface((mock_transport, mock_protocol))
-
-        def test_gettimeout_returns_protocol_timeout(self):
-            network_interface = self._make_network_interface()
-            self.assertEqual(network_interface.gettimeout, 10.0)
-
-        def test_settimeout_delegates_to_protocol(self):
-            network_interface = self._make_network_interface()
-            network_interface.settimeout(7.0)
-            network_interface.conn[1].settimeout.assert_called_once_with(7.0)
-
-        def test_is_closing_delegates_to_transport(self):
-            network_interface = self._make_network_interface()
-            network_interface.conn[0].is_closing.return_value = False
-            self.assertFalse(network_interface.is_closing())
-
-        def test_get_conn_returns_protocol(self):
-            network_interface = self._make_network_interface()
-            self.assertIs(network_interface.get_conn, network_interface.conn[1])
-
-        def test_sock_returns_transport_socket(self):
-            network_interface = self._make_network_interface()
-            sentinel = object()
-            network_interface.conn[0].get_extra_info.return_value = sentinel
-            self.assertIs(network_interface.sock, sentinel)
-            network_interface.conn[0].get_extra_info.assert_called_once_with("socket")
-
-    class TestPyMongoProtocol(UnitTest):
-        def _make_proto_with_header(self, header_bytes, max_size=MAX_MESSAGE_SIZE):
-            protocol = _make_protocol()
-            protocol._max_message_size = max_size
-            protocol._header = memoryview(bytearray(header_bytes))
-            return protocol
-
-        def test_initial_timeout_from_constructor(self):
-            protocol = _make_protocol(timeout=3.0)
-            self.assertEqual(protocol.gettimeout, 3.0)
-
-        def test_settimeout_updates_value(self):
-            protocol = _make_protocol()
-            protocol.settimeout(7.5)
-            self.assertEqual(protocol.gettimeout, 7.5)
-
-        def test_default_timeout_is_none(self):
-            protocol = _make_protocol()
-            self.assertIsNone(protocol.gettimeout)
-
-        def test_normal_op_msg(self):
-            header = _make_header(32, 1, 99, 2013)
-            protocol = self._make_proto_with_header(header)
-            body_len, op_code, response_to, expecting_compression = protocol.process_header()
-            self.assertEqual(body_len, 16)
-            self.assertEqual(op_code, 2013)
-            self.assertEqual(response_to, 99)
-            self.assertFalse(expecting_compression)
-
-        def test_op_compressed(self):
-            # OP_COMPRESSED=2012, length=35 → adjusted=35-9=26 → body=26-16=10
-            header = _make_header(35, 1, 0, 2012)
-            protocol = self._make_proto_with_header(header)
-            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
-            self.assertEqual(body_len, 10)
-            self.assertEqual(op_code, 2012)
-            self.assertTrue(expecting_compression)
-
-        def test_op_compressed_length_too_small_raises(self):
-            header = _make_header(25, 1, 0, 2012)
-            protocol = self._make_proto_with_header(header)
-            with self.assertRaises(ProtocolError):
-                protocol.process_header()
-
-        def test_non_compressed_length_too_small_raises(self):
-            header = _make_header(16, 1, 0, 2013)
-            protocol = self._make_proto_with_header(header)
-            with self.assertRaises(ProtocolError):
-                protocol.process_header()
-
-        def test_length_exceeds_max_raises(self):
-            header = _make_header(MAX_MESSAGE_SIZE + 1, 1, 0, 2013)
-            protocol = self._make_proto_with_header(header)
-            with self.assertRaises(ProtocolError):
-                protocol.process_header()
-
-        def test_op_reply_op_code(self):
-            header = _make_header(20, 0, 0, 1)
-            protocol = self._make_proto_with_header(header)
-            body_len, op_code, _response_to, expecting_compression = protocol.process_header()
-            self.assertEqual(body_len, 4)
-            self.assertEqual(op_code, 1)
-            self.assertFalse(expecting_compression)
-
-        def test_compression_header_returns_op_code_and_compressor_id(self):
-            protocol = _make_protocol()
-            # <iiB: little-endian, i32 op code=2013, i32 uncompressed size=0, u8 compressor id=1 (snappy)
-            data = struct.pack("<iiB", 2013, 0, 1)
-            protocol._compression_header = memoryview(bytearray(data))
-            op_code, compressor_id = protocol.process_compression_header()
-            self.assertEqual(op_code, 2013)
-            self.assertEqual(compressor_id, 1)
-
-        def test_compression_header_zlib_compressor_id(self):
-            protocol = _make_protocol()
-            data = struct.pack("<iiB", 2013, 0, 2)
-            protocol._compression_header = memoryview(bytearray(data))
-            _, compressor_id = protocol.process_compression_header()
-            self.assertEqual(compressor_id, 2)
-
-        def test_message_complete_resolves_pending_future(self):
-            protocol = _make_protocol()
-            protocol._expecting_header = False
-            protocol._expecting_compression = False
-            protocol._message_size = 10
-            protocol._message = memoryview(bytearray(10))
-            protocol._message_index = 0
-            protocol._op_code = 2013
-            protocol._compressor_id = None
-            protocol._response_to = 42
-
-            future = asyncio.get_running_loop().create_future()
-            protocol._pending_messages.append(future)
-
-            protocol.buffer_updated(10)
-            self.assertTrue(future.done())
-            op_code, compressor_id, response_to, _ = future.result()
-            self.assertEqual(op_code, 2013)
-            self.assertIsNone(compressor_id)
-            self.assertEqual(response_to, 42)
-
-        def test_close_aborts_transport(self):
-            protocol = _make_protocol()
-            protocol.close()
-            self.assertTrue(protocol.transport.abort.called)
-
-        def test_connection_lost_twice_does_not_raise(self):
-            protocol = _make_protocol()
-            protocol.connection_lost(None)
-            protocol.connection_lost(None)
-
-        def test_close_with_exception_propagates_to_pending(self):
-            protocol = _make_protocol()
-            future = asyncio.get_running_loop().create_future()
-            protocol._pending_messages.append(future)
-            exc = OSError("connection reset")
-            protocol.close(exc)
-            with self.assertRaises(OSError) as ctx:
-                future
-            self.assertIn("connection reset", str(ctx.exception))
-
-    class TestAsyncSocketReceive(UnitTest):
-        def test_reads_full_data_in_one_call(self):
-            data = b"hello world!"
-            length = len(data)
-            mock_socket = MagicMock()
-            loop = asyncio.get_running_loop()
-
-            def fake_recv_into(sock, buf):
-                buf[:length] = data
-                return length
-
-            with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
-                result = _async_socket_receive(mock_socket, length, loop)
-            self.assertEqual(bytes(result), data)
-
-        def test_reads_data_in_multiple_chunks(self):
-            data = b"abcdefgh"
-            length = len(data)
-            chunk1, chunk2 = data[:4], data[4:]
-            mock_socket = MagicMock()
-            loop = asyncio.get_running_loop()
-            calls = 0
-
-            def fake_recv_into(sock, buf):
-                nonlocal calls
-                if calls == 0:
-                    buf[: len(chunk1)] = chunk1
-                    calls += 1
-                    return len(chunk1)
-                buf[: len(chunk2)] = chunk2
-                calls += 1
-                return len(chunk2)
-
-            with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
-                result = _async_socket_receive(mock_socket, length, loop)
-            self.assertEqual(bytes(result), data)
-
-        def test_raises_on_connection_closed(self):
-            mock_socket = MagicMock()
-            loop = asyncio.get_running_loop()
-
-            def fake_recv_into(sock, buf):
-                return 0
-
-            with patch.object(loop, "sock_recv_into", new=MagicMock(side_effect=fake_recv_into)):
-                with self.assertRaises(OSError) as ctx:
-                    _async_socket_receive(mock_socket, 10, loop)
-            self.assertIn("connection closed", str(ctx.exception))
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/tools/synchro.py b/tools/synchro.py
index 398e353f89..850921d65d 100644
--- a/tools/synchro.py
+++ b/tools/synchro.py
@@ -191,6 +191,7 @@ def async_only_test(f: str) -> bool:
         "test_async_loop_safety.py",
         "test_async_contextvars_reset.py",
         "test_async_loop_unblocked.py",
+        "test_async_network_layer.py",
     ]