test: add Windows FallbackProcess graceful shutdown tests

Add comprehensive test suite for Windows-specific FallbackProcess to verify
that CTRL_C_EVENT signal properly triggers cleanup code in lifespan context
managers. These tests will fail until issue #1027 is fixed.

Tests include:
- Graceful shutdown with CTRL_C_EVENT signal
- Timeout fallback to terminate() when signal is ignored
- CTRL_C_EVENT availability verification
- Async stdio stream functionality

Tests pass silently on non-Windows platforms since FallbackProcess
is Windows-specific functionality.

Github-Issue: #1027

Author: felixweinberger

tests/client/test_windows_fallback.py

@@ -0,0 +1,170 @@
+"""Test Windows-specific FallbackProcess functionality."""
+
+import os
+import signal
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+
+if TYPE_CHECKING or sys.platform == "win32":
+    from mcp.client.stdio.win32 import create_windows_process
+
+
+class TestFallbackProcess:
+    """Test suite for Windows FallbackProcess graceful shutdown."""
+
+    @pytest.mark.anyio
+    async def test_fallback_process_graceful_shutdown(self, tmp_path: Path):
+        """Test that FallbackProcess sends CTRL_C_EVENT for graceful shutdown."""
+        if sys.platform != "win32":
+            # Test only applies to Windows where FallbackProcess is used
+            return
+        
+        # Create a test script that writes a marker on cleanup
+        test_script = tmp_path / "test_cleanup.py"
+        marker_file = tmp_path / "cleanup_marker.txt"
+
+        test_script.write_text(f"""
+import signal
+import time
+from pathlib import Path
+
+marker = Path(r"{marker_file}")
+marker.write_text("STARTED")
+
+def cleanup_handler(signum, frame):
+    marker.write_text("CLEANED_UP")
+    exit(0)
+
+# Register CTRL_C_EVENT handler
+signal.signal(signal.SIGINT, cleanup_handler)
+
+# Keep process alive
+while True:
+    time.sleep(0.1)
+""")
+
+        # Create process using FallbackProcess
+        process = await create_windows_process(sys.executable, [str(test_script)], cwd=tmp_path)
+
+        # Wait for process to start
+        import asyncio
+
+        await asyncio.sleep(0.5)
+
+        # Verify process started
+        assert marker_file.exists()
+        assert marker_file.read_text() == "STARTED"
+
+        # Exit context manager - should trigger CTRL_C_EVENT
+        await process.__aexit__(None, None, None)
+
+        # Check if cleanup ran
+        await asyncio.sleep(0.5)
+
+        # This is the critical test: cleanup should have executed
+        assert marker_file.read_text() == "CLEANED_UP", "CTRL_C_EVENT cleanup did not execute - issue #1027 not fixed"
+
+    @pytest.mark.anyio
+    async def test_fallback_process_timeout_fallback(self, tmp_path: Path):
+        """Test that FallbackProcess falls back to terminate() if CTRL_C_EVENT times out."""
+        if sys.platform != "win32":
+            # Test only applies to Windows where FallbackProcess is used
+            return
+        
+        # Create a test script that ignores CTRL_C_EVENT
+        test_script = tmp_path / "test_ignore_signal.py"
+        marker_file = tmp_path / "status_marker.txt"
+
+        test_script.write_text(f"""
+import signal
+import time
+from pathlib import Path
+
+marker = Path(r"{marker_file}")
+marker.write_text("STARTED")
+
+# Ignore CTRL_C_EVENT
+signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+# Keep process alive
+while True:
+    time.sleep(0.1)
+""")
+
+        # Create process
+        process = await create_windows_process(sys.executable, [str(test_script)], cwd=tmp_path)
+
+        # Wait for process to start
+        import asyncio
+
+        await asyncio.sleep(0.5)
+
+        assert marker_file.exists()
+        assert marker_file.read_text() == "STARTED"
+
+        # Exit context manager - should try CTRL_C_EVENT, timeout, then terminate
+        await process.__aexit__(None, None, None)
+
+        # Process should be terminated even though it ignored CTRL_C_EVENT
+        # Check that process is no longer running
+        try:
+            # This should raise because process is terminated
+            os.kill(process.popen.pid, 0)
+            pytest.fail("Process should have been terminated")
+        except (ProcessLookupError, OSError):
+            # Expected - process is terminated
+            pass
+
+    def test_ctrl_c_event_availability(self):
+        """Test that CTRL_C_EVENT is available on Windows."""
+        if sys.platform != "win32":
+            # Test only applies to Windows
+            return
+        
+        assert hasattr(signal, "CTRL_C_EVENT"), "CTRL_C_EVENT not available on this Windows system"
+
+        # Verify it's the expected value (should be 0)
+        assert signal.CTRL_C_EVENT == 0
+
+    @pytest.mark.anyio
+    async def test_fallback_process_with_stdio(self, tmp_path: Path):
+        """Test that FallbackProcess properly wraps stdin/stdout streams."""
+        if sys.platform != "win32":
+            # Test only applies to Windows where FallbackProcess is used
+            return
+        
+        # Create a simple echo script
+        echo_script = tmp_path / "echo.py"
+        echo_script.write_text("""
+import sys
+while True:
+    line = sys.stdin.readline()
+    if not line:
+        break
+    sys.stdout.write(f"ECHO: {line}")
+    sys.stdout.flush()
+""")
+
+        # Create process
+        process = await create_windows_process(sys.executable, [str(echo_script)], cwd=tmp_path)
+
+        # Test async I/O
+        assert process.stdin is not None
+        assert process.stdout is not None
+
+        # Write to stdin
+        test_message = b"Hello Windows\\n"
+        await process.stdin.send(test_message)
+
+        # Read from stdout
+        import asyncio
+
+        response = await asyncio.wait_for(process.stdout.receive(1024), timeout=2.0)
+
+        assert b"ECHO: Hello Windows" in response
+
+        # Cleanup
+        await process.__aexit__(None, None, None)