Simplify stdio cleanup tests to reduce flakiness

- Remove test_stdio_client_immediate_completion (too prone to race conditions)
- Simplify test_stdio_client_cleanup_timeout to use consistent Python script
- Focus on core issue: ensuring cleanup doesn't hang forever

Author: felixweinberger

tests/client/test_stdio.py

@@ -97,26 +97,33 @@ async def test_stdio_client_nonexistent_command():
 
 
 @pytest.mark.anyio
-async def test_stdio_client_universal_cleanup():
+async def test_stdio_client_cleanup_timeout():
     """
     Test that stdio_client completes cleanup within reasonable time
-    even when connected to processes that exit slowly.
+    even when connected to processes that don't exit cleanly.
     """
 
-    # Use a simple sleep command that's available on all platforms
-    # This simulates a process that takes time to terminate
-    if sys.platform == "win32":
-        # Windows: use ping with timeout to simulate a running process
-        server_params = StdioServerParameters(
-            command="ping",
-            args=["127.0.0.1", "-n", "10"],  # Ping 10 times, takes ~10 seconds
-        )
-    else:
-        # Unix: use sleep command
-        server_params = StdioServerParameters(
-            command="sleep",
-            args=["10"],  # Sleep for 10 seconds
-        )
+    # Use a Python script that ignores SIGTERM and runs forever
+    # This simulates a stubborn process that won't terminate cleanly
+    script_content = textwrap.dedent(
+        """
+        import signal
+        import time
+        
+        # Ignore SIGTERM on Unix
+        if hasattr(signal, 'SIGTERM'):
+            signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        
+        # Just keep running
+        while True:
+            time.sleep(0.1)
+        """
+    )
+    
+    server_params = StdioServerParameters(
+        command=sys.executable,
+        args=["-c", script_content],
+    )
 
     start_time = time.time()
 
@@ -143,45 +150,6 @@ async def test_stdio_client_universal_cleanup():
         )
 
 
-@pytest.mark.anyio
-async def test_stdio_client_immediate_completion():
-    """
-    Test that stdio_client doesn't introduce unnecessary delays
-    when processes exit normally and quickly.
-    """
-
-    # Use a Python script that prints and exits after a brief moment
-    # This avoids race conditions on fast systems where the process
-    # exits before async tasks are fully initialized
-    script_content = "import time; print('hello'); time.sleep(0.1)"
-
-    server_params = StdioServerParameters(
-        command=sys.executable,
-        args=["-c", script_content],
-    )
-
-    start_time = time.time()
-
-    # Use move_on_after which is more reliable for cleanup scenarios
-    with anyio.move_on_after(3.0) as cancel_scope:
-        async with stdio_client(server_params) as (read_stream, write_stream):
-            pass
-
-        end_time = time.time()
-        elapsed = end_time - start_time
-
-        # Should complete very quickly when process exits normally
-        assert elapsed < 2.0, (
-            f"stdio_client took {elapsed:.1f} seconds for fast-exiting process, "
-            f"expected < 2.0 seconds. Timeout mechanism may be introducing delays."
-        )
-
-    # Check if we timed out
-    if cancel_scope.cancelled_caught:
-        pytest.fail(
-            "stdio_client timed out after 3.0 seconds for fast-exiting process. "
-            "This indicates a serious hang in the cleanup mechanism."
-        )
 
 
 @pytest.mark.anyio