Fix CI: news entry, lint fixes, and test updates (gh-109051)

- Remove unused imports flagged by ruff (asyncio.base_events,
  asyncio.sslproto).
- Add Misc/NEWS.d entry for gh-109051 (bedevere/news).
- test_ssl: rewrite test_remote_shutdown_receives_trailing_data_on_slow_socket
  to fill the transport buffer instead of the removed
  _test__append_write_backlog helper, mirroring the sibling test
  rewrite already in this PR.
- test_sslproto: stop mocking sslobj.write() failures; without an
  outgoing write buffer those errors propagate instead of being
  buffered and retried.

Co-authored-by: Muse Code (Meta Muse Spark)

Author: Muse Code

Lib/asyncio/base_events.py

@@ -48,7 +48,6 @@
 from . import staggered
 from . import tasks
 from . import timeouts
-from . import transports
 from . import trsock
 from .log import logger
 

Lib/asyncio/sslproto.py

@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: PSF-2.0 AND (MIT OR Apache-2.0)
 # SPDX-FileCopyrightText: Copyright (c) 2015-2021 MagicStack Inc.  http://magic.io
 
-import collections
 import enum
 import warnings
 try:

Lib/test/test_asyncio/test_ssl.py

@@ -1465,7 +1465,6 @@ def test_remote_shutdown_receives_trailing_data_on_slow_socket(self):
         # The slow path is triggered here by setting SO_SNDBUF, see code and comment below.
 
         CHUNK = 1024 * 128
-        SIZE = 32
 
         sslctx = self._create_server_ssl_context(
             test_utils.ONLYCERT,
@@ -1503,25 +1502,38 @@ def server(sock):
             sslobj.write(b'pong')
             sock.send(outgoing.read())
 
-            time.sleep(0.2)  # wait for the peer to fill its backlog
+            data_len = 0
+            filled.wait()
+            # trigger peer's resume_writing()
+            incoming.write(sock.recv(65536 * 4))
+            while True:
+                try:
+                    chunk = len(sslobj.read(16384))
+                    data_len += chunk
+                except ssl.SSLWantReadError:
+                    break
 
             # send close_notify but don't wait for response
             with self.assertRaises(ssl.SSLWantReadError):
                 sslobj.unwrap()
             sock.send(outgoing.read())
 
+            eof_received.wait()
             # should receive all data
-            data_len = 0
             while True:
                 try:
                     chunk = len(sslobj.read(16384))
                     data_len += chunk
                 except ssl.SSLWantReadError:
                     incoming.write(sock.recv(16384))
+                    if not incoming.pending:
+                        # EOF received
+                        break
                 except ssl.SSLZeroReturnError:
                     break
 
-            self.assertEqual(data_len, CHUNK * SIZE*2)
+            assert count > 0
+            self.assertEqual(data_len, CHUNK * count)
 
             # verify that close_notify is received
             sslobj.unwrap()
@@ -1533,19 +1545,20 @@ def eof_server(sock):
             self.assertEqual(sock.recv_all(4), b'ping')
             sock.send(b'pong')
 
-            time.sleep(0.2)  # wait for the peer to fill its backlog
+            filled.wait()
 
             # send EOF
             sock.shutdown(socket.SHUT_WR)
 
             # should receive all data
-            data = sock.recv_all(CHUNK * SIZE)
-            self.assertEqual(len(data), CHUNK * SIZE)
+            assert count > 0
+            data = sock.recv_all(CHUNK * count)
+            self.assertEqual(len(data), CHUNK * count)
 
             sock.close()
 
         async def client(addr):
-            nonlocal future
+            nonlocal future, count
             future = self.loop.create_future()
 
             reader, writer = await asyncio.open_connection(
@@ -1557,15 +1570,21 @@ async def client(addr):
             data = await reader.readexactly(4)
             self.assertEqual(data, b'pong')
 
-            # fill write backlog in a hacky way - renegotiation won't help
-            for _ in range(SIZE*2):
-                writer.transport._test__append_write_backlog(b'x' * CHUNK)
+            count = 0
+            # Fill the buffer - with a hack to ensure the protocol is
+            # paused without actually waiting on drain
+            while not writer._protocol._paused:
+                writer.write(b'x' * CHUNK)
+                count += 1
+                await asyncio.sleep(0)
+            filled.set()
 
             try:
                 data = await reader.read()
                 self.assertEqual(data, b'')
             except (BrokenPipeError, ConnectionResetError):
                 pass
+            eof_received.set()
 
             # Make sure _SelectorSocketTransport enters the delayed write
             # path in its `write` method by wrapping socket in a fake class
@@ -1614,9 +1633,15 @@ def wrapper(sock):
                     self.loop.call_soon_threadsafe(future.set_result, None)
             return wrapper
 
+        filled = threading.Event()
+        eof_received = threading.Event()
+        count = 0
         with self.tcp_server(run(server)) as srv:
             self.loop.run_until_complete(client(srv.addr))
 
+        filled = threading.Event()
+        eof_received = threading.Event()
+        count = 0
         with self.tcp_server(run(eof_server)) as srv:
             self.loop.run_until_complete(client(srv.addr))
 

Lib/test/test_asyncio/test_sslproto.py

@@ -47,7 +47,10 @@ def connection_made(self, ssl_proto, *, do_handshake=None):
         sslobj = mock.Mock()
         # emulate reading decompressed data
         sslobj.read.side_effect = ssl.SSLWantReadError
-        sslobj.write.side_effect = ssl.SSLWantReadError
+        # NOTE: sslobj.write is left as a plain Mock (writes succeed).
+        # There is no outgoing write buffer anymore, so an SSLWantReadError
+        # from write() would propagate to the caller instead of being
+        # buffered and retried.
         if do_handshake is not None:
             sslobj.do_handshake = do_handshake
         ssl_proto._sslobj = sslobj
@@ -169,7 +172,9 @@ def test_connection_lost_when_busy(self):
         # emulate reading decompressed data
         sslobj = mock.Mock()
         sslobj.read.side_effect = ssl.SSLWantReadError
-        sslobj.write.side_effect = ssl.SSLWantReadError
+        # NOTE: writes succeed (plain Mock). There is no outgoing write
+        # buffer anymore, so an SSLWantReadError from write() would
+        # propagate to the caller instead of being buffered and retried.
         ssl_proto._sslobj = sslobj
 
         # emulate outgoing data

Misc/NEWS.d/next/Library/2026-10-21-01-27-59.gh-issue-109051.q7ZmXk.rst

@@ -0,0 +1,4 @@
+Remove the redundant outgoing write buffer from :mod:`asyncio`
+TLS transports. Encrypted data is now written directly to the underlying
+transport, and write flow control is delegated to it. This also fixes an
+:exc:`AssertionError` when the buffer size was checked inconsistently.