Simplify Windows hang test to focus only on hang detection

- Remove complex test logic and expectations
- Two simple tests: delayed exit and immediate exit
- Test passes if it completes without timeout (no hang)
- Don't assert on specific exceptions - just verify no hang

Author: felixweinberger

tests/issues/test_552_windows_hang.py

@@ -1,5 +1,6 @@
+"""Test for issue #552: stdio_client hangs on Windows."""
+
 import sys
-from textwrap import dedent
 
 import anyio
 import pytest
@@ -10,66 +11,57 @@
 
 @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific test")
 @pytest.mark.anyio
-async def test_windows_stdio_client_no_hang():
+async def test_windows_stdio_client_no_hang_on_exit():
     """
     Test for issue #552: stdio_client hangs on Windows 11.
 
-    This test verifies that the stdio_client can be created and properly
-    closed on Windows without hanging, even when the subprocess exits immediately.
-    The original issue was that the client would hang indefinitely.
+    This test verifies that the stdio_client properly handles subprocess
+    termination on Windows without hanging. The key is that the test
+    completes within the timeout period.
     """
-    # Use Python as a simple subprocess that exits immediately
-    # This tests the edge case where the server process dies right away
+    # Create a subprocess that exits after a short delay
+    # This gives stdio_client time to set up pipes before the process exits
+    exit_script = "import time; time.sleep(0.1); import sys; sys.exit(0)"
+
     params = StdioServerParameters(
         command=sys.executable,
-        args=["-c", "import sys; sys.exit(0)"],
+        args=["-c", exit_script],
     )
 
-    # The test passes if we can attempt to create the client without hanging
-    # We expect it to fail quickly when the subprocess exits
-    with anyio.fail_after(5):  # 5 second timeout - should fail much faster
-        with pytest.raises(Exception):  # We expect an error when subprocess exits
+    # The test passes if this completes without timing out
+    # We don't care about exceptions - just that it doesn't hang
+    with anyio.fail_after(10):  # Generous timeout - should complete in < 1s
+        try:
             async with stdio_client(params) as (read, write):
-                # If we get here, the subprocess didn't exit as expected
-                pytest.fail("Subprocess should have exited immediately")
+                # If we get here, the connection was established
+                # The subprocess will exit soon, causing cleanup
+                await anyio.sleep(0.5)  # Wait for subprocess to exit
+        except Exception:
+            # Any exception is fine - we're just testing for hangs
+            pass
 
 
 @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific test")
 @pytest.mark.anyio
-async def test_windows_stdio_client_json_echo():
+async def test_windows_stdio_client_immediate_exit():
     """
-    Test stdio_client with a JSON echo server on Windows.
+    Test that stdio_client handles immediate subprocess exit on Windows.
 
-    This test creates a subprocess that echoes JSON-RPC messages,
-    verifying that the stdio_client can communicate properly on Windows.
+    This tests the edge case where the subprocess exits before
+    stdio_client can fully initialize.
     """
-    # Create a Python script that echoes JSON messages
-    echo_script = dedent("""
-        import sys
-        import json
-        
-        # Read lines and echo them back
-        for line in sys.stdin:
-            try:
-                # Parse as JSON to ensure it's valid
-                data = json.loads(line.strip())
-                # Echo it back
-                print(json.dumps(data))
-                sys.stdout.flush()
-            except:
-                # If not valid JSON, just exit
-                break
-    """).strip()
-
+    # Subprocess exits immediately
     params = StdioServerParameters(
         command=sys.executable,
-        args=["-c", echo_script],
+        args=["-c", "import sys; sys.exit(1)"],
     )
 
-    # Test should complete without hanging
-    with anyio.fail_after(5):
-        async with stdio_client(params) as (read, write):
-            # The stdio_client should establish connection without hanging
-            # Just creating the client successfully is the main test
-            # The original issue was it would hang here
-            pass
+    # The test passes if this completes without timing out
+    with anyio.fail_after(10):  # Generous timeout
+        try:
+            async with stdio_client(params) as (read, write):
+                # Subprocess should have exited already
+                pass
+        except Exception:
+            # Expected - subprocess exited
+            pass