gh-142352: simplify start_tls buffered-data test

Replace the proxy-based combined/separate cases with a deterministic
buffered-ClientHello check and a ping/pong verification after start_tls.

Author: kasimov-maxim

Lib/test/test_asyncio/test_streams.py

@@ -14,7 +14,7 @@
 
 import asyncio
 from test.test_asyncio import utils as test_utils
-from test.support import socket_helper
+from test.support import socket_helper, LOOPBACK_TIMEOUT
 
 
 def tearDownModule():
@@ -819,60 +819,34 @@ async def client(addr):
         self.assertEqual(msg1, b"hello world 1!\n")
         self.assertEqual(msg2, b"hello world 2!\n")
 
-    def _test_start_tls_buffered_data(self, send_combined):
+    @unittest.skipIf(ssl is None, 'No ssl module')
+    def test_start_tls_buffered_data(self):
         # gh-142352: test start_tls() with buffered data
 
-        PROXY_LINE = b"PROXY TCP4 127.0.0.1 127.0.0.1 54321 443\r\n"
-        TEST_MESSAGE = b"hello world\n"
-
-        async def pipe(src, dst):
-            try:
-                while data := await src.read(4096):
-                    dst.write(data)
-                    await dst.drain()
-            finally:
-                dst.close()
-                await dst.wait_closed()
-
-        async def proxy_handler(client_reader, client_writer, backend_addr):
-            backend_reader, backend_writer = await asyncio.open_connection(
-                *backend_addr)
-            try:
-                tls_data = await client_reader.read(4096)
-                if send_combined:
-                    backend_writer.write(PROXY_LINE + tls_data)
-                else:
-                    backend_writer.write(PROXY_LINE)
-                    await backend_writer.drain()
-                    await asyncio.sleep(0.01)
-                    backend_writer.write(tls_data)
-                await backend_writer.drain()
-
-                await asyncio.gather(
-                    pipe(client_reader, backend_writer),
-                    pipe(backend_reader, client_writer),
-                )
-            finally:
-                client_writer.close()
-                backend_writer.close()
-                await asyncio.gather(
-                    client_writer.wait_closed(),
-                    backend_writer.wait_closed(),
-                    return_exceptions=True
-                )
-
         async def server_handler(client_reader, client_writer):
-            self.assertEqual(await client_reader.readline(), PROXY_LINE)
+            # Wait for TLS ClientHello to be buffered before start_tls().
+            await asyncio.wait_for(
+                client_reader._wait_for_data('test_start_tls_buffered_data'),
+                LOOPBACK_TIMEOUT,
+            )
+            self.assertTrue(client_reader._buffer)
             await client_writer.start_tls(test_utils.simple_server_sslcontext())
-            self.assertEqual(await client_reader.readline(), TEST_MESSAGE)
+
+            line = await asyncio.wait_for(client_reader.readline(), LOOPBACK_TIMEOUT)
+            self.assertEqual(line, b"ping\n")
+            client_writer.write(b"pong\n")
+            await client_writer.drain()
             client_writer.close()
             await client_writer.wait_closed()
 
         async def client(addr):
-            _, writer = await asyncio.open_connection(*addr)
+            reader, writer = await asyncio.open_connection(*addr)
             await writer.start_tls(test_utils.simple_client_sslcontext())
-            writer.write(TEST_MESSAGE)
+
+            writer.write(b"ping\n")
             await writer.drain()
+            line = await asyncio.wait_for(reader.readline(), LOOPBACK_TIMEOUT)
+            self.assertEqual(line, b"pong\n")
             writer.close()
             await writer.wait_closed()
 
@@ -881,31 +855,15 @@ async def run_test():
                 server_handler, socket_helper.HOSTv4, 0)
             server_addr = server.sockets[0].getsockname()
 
-            proxy = await asyncio.start_server(
-                lambda r, w: proxy_handler(r, w, server_addr),
-                socket_helper.HOSTv4, 0)
-            proxy_addr = proxy.sockets[0].getsockname()
-
-            await asyncio.wait_for(client(proxy_addr), timeout=5.0)
-            proxy.close()
+            await asyncio.wait_for(client(server_addr), timeout=5.0)
             server.close()
-            await asyncio.gather(proxy.wait_closed(), server.wait_closed())
+            await server.wait_closed()
 
         messages = []
         self.loop.set_exception_handler(lambda loop, ctx: messages.append(ctx))
         self.loop.run_until_complete(run_test())
         self.assertEqual(messages, [])
 
-    @unittest.skipIf(ssl is None, 'No ssl module')
-    def test_start_tls_buffered_data_combined(self):
-        # gh-142352: Test TLS data buffered before start_tls
-        self._test_start_tls_buffered_data(send_combined=True)
-
-    @unittest.skipIf(ssl is None, 'No ssl module')
-    def test_start_tls_buffered_data_separate(self):
-        # gh-142352: Test TLS data sent separately
-        self._test_start_tls_buffered_data(send_combined=False)
-
     def test_streamreader_constructor_without_loop(self):
         with self.assertRaisesRegex(RuntimeError, 'no current event loop'):
             asyncio.StreamReader()