Rewrite Windows hang test to actually test issue #552

- Remove confusing parametrized tests with cmd.exe
- Add simple test that verifies stdio_client doesn't hang on Windows
- Add echo server test for more comprehensive verification
- Both tests use Python subprocess for cross-version compatibility
- Tests focus on the actual issue: stdio_client hanging on Windows

Author: felixweinberger

tests/issues/test_552_windows_hang.py

@@ -1,53 +1,77 @@
 import sys
-
 import anyio
 import pytest
-
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 
 
 @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific test")
-@pytest.mark.parametrize(
-    "args,should_fail",
-    [
-        (["/C", "echo", '{"jsonrpc": "2.0", "id": 1, "result": null}'], False),
-        (["dfghfgh"], True),
-        (["/C", "echo"], False),
-    ],
-)
 @pytest.mark.anyio
-async def test_windows_process_creation(args, should_fail):
+async def test_windows_stdio_client_no_hang():
     """
-    Test that directly tests the process creation function that was fixed in issue #552.
-    This simpler test verifies that Windows process creation works without hanging.
+    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. The original issue was that the
+    client would hang indefinitely during initialization or cleanup.
     """
-    # Use a simple command that should complete quickly on Windows
+    # Use Python as a simple subprocess that exits cleanly
     params = StdioServerParameters(
-        command="cmd",
-        # Echo a valid JSON-RPC response message that will be parsed correctly
-        args=args,
+        command=sys.executable,
+        args=["-c", "import sys; sys.exit(0)"],
     )
-
-    # Directly test the fixed function that was causing the hanging issue
-    if should_fail:
-        # For commands we expect to fail, ensure they fail quickly without hanging
-        with pytest.raises((TimeoutError, Exception)) as exc_info:
-            with anyio.fail_after(5):
-                async with stdio_client(params) as (read, write):
-                    async with ClientSession(read, write) as c:
-                        await c.initialize()
-        # Verify it failed as expected (timeout or process error)
-        assert isinstance(exc_info.value, (TimeoutError, Exception))
-    else:
-        # For valid commands, they should complete without hanging
+    
+    # The test passes if we can create and close the client without hanging
+    # We use a timeout to ensure the test fails if the hang issue persists
+    with anyio.fail_after(10):  # 10 second timeout
         try:
-            with anyio.fail_after(5):
-                async with stdio_client(params) as (read, write):
-                    async with ClientSession(read, write) as c:
-                        await c.initialize()
-        except Exception as e:
-            # These commands might fail due to protocol issues, but shouldn't hang
-            # The important thing is they complete within the timeout
-            print(f"Command failed with: {e}")
-            # As long as it didn't timeout, the test passes (no hang)
+            async with stdio_client(params) as (read, write):
+                # Just creating the client successfully is enough
+                # The original issue was it would hang here
+                pass
+        except Exception:
+            # We expect the subprocess to exit immediately
+            # Any exception is fine as long as we don't hang
+            pass
+    
+    # If we get here without timing out, the hang issue is fixed
+    assert True
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific test")
+@pytest.mark.anyio
+async def test_windows_stdio_client_with_echo_server():
+    """
+    Test stdio_client with a simple echo server on Windows.
+    
+    This is a more comprehensive test that creates a subprocess that
+    echoes stdin to stdout, verifying bidirectional communication works.
+    """
+    # Create a simple Python echo server
+    echo_script = '''
+import sys
+while True:
+    line = sys.stdin.readline()
+    if not line:
+        break
+    sys.stdout.write(line)
+    sys.stdout.flush()
+'''
+    
+    params = StdioServerParameters(
+        command=sys.executable,
+        args=["-c", echo_script],
+    )
+    
+    # Test should complete without hanging
+    with anyio.fail_after(10):
+        async with stdio_client(params) as (read, write):
+            # Send a test message
+            test_message = b"Hello Windows\\n"
+            await write.send(test_message)
+            
+            # Read the echo back
+            response = await read.receive()
+            assert response == test_message.rstrip()
+            
+            # Client should close cleanly when exiting context