Add test demonstrating issue #1027 and verifying PR #1044 fixes it

This test shows that MCP server cleanup code in lifespan doesn't run
when the process is terminated, but does run when stdin is closed first
(as implemented in PR #1044).

The test includes:
- Demonstration of current broken behavior (cleanup doesn't run)
- Verification that stdin closure allows graceful shutdown
- Windows-specific ResourceWarning handling
- Detailed documentation of the issue and solution

Github-Issue:#1027

Author: felixweinberger

tests/issues/test_1027_win_unreachable_cleanup.py

@@ -0,0 +1,238 @@
+"""
+Test for issue #1027: The cleanup procedure after "yield" in lifespan is unreachable on Windows
+
+This test demonstrates that on Windows, when an MCP server is terminated via process.terminate(),
+the cleanup code after yield in the lifespan context manager is not executed.
+
+The issue occurs because Windows' TerminateProcess() forcefully kills the process without
+allowing cleanup handlers to run.
+"""
+
+import asyncio
+import sys
+import tempfile
+import textwrap
+from pathlib import Path
+
+import anyio
+import pytest
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import _create_platform_compatible_process, stdio_client
+
+
+@pytest.mark.anyio
+async def test_lifespan_cleanup_executed():
+    """
+    Test that verifies cleanup code in MCP server lifespan is executed.
+
+    This test creates an MCP server that writes to marker files:
+    1. When the server starts (before yield)
+    2. When the server cleanup runs (after yield)
+
+    On Windows with the current implementation, the cleanup file is never created
+    because process.terminate() kills the process immediately.
+    """
+
+    # Create marker files to track server lifecycle
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as f:
+        startup_marker = f.name
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as f:
+        cleanup_marker = f.name
+
+    # Remove the files so we can detect when they're created
+    Path(startup_marker).unlink()
+    Path(cleanup_marker).unlink()
+
+    # Create a minimal MCP server using FastMCP that tracks lifecycle
+    server_code = textwrap.dedent(f"""
+        import asyncio
+        import sys
+        from pathlib import Path
+        from contextlib import asynccontextmanager
+        from mcp.server.fastmcp import FastMCP
+        
+        STARTUP_MARKER = {repr(startup_marker)}
+        CLEANUP_MARKER = {repr(cleanup_marker)}
+        
+        @asynccontextmanager
+        async def lifespan(server):
+            # Write startup marker
+            Path(STARTUP_MARKER).write_text("started")
+            try:
+                yield {{"started": True}}
+            finally:
+                # This cleanup code should run when server shuts down
+                Path(CLEANUP_MARKER).write_text("cleaned up")
+        
+        mcp = FastMCP("test-server", lifespan=lifespan)
+        
+        @mcp.tool()
+        def echo(text: str) -> str:
+            return text
+        
+        if __name__ == "__main__":
+            mcp.run()
+    """)
+
+    # Write the server script to a temporary file
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".py") as f:
+        server_script = f.name
+        f.write(server_code)
+
+    try:
+        # Launch the MCP server
+        params = StdioServerParameters(command=sys.executable, args=[server_script])
+
+        async with stdio_client(params) as (read, write):
+            async with ClientSession(read, write) as session:
+                # Initialize the session
+                result = await session.initialize()
+                assert result.protocolVersion in ["2024-11-05", "2025-06-18"]
+
+                # Verify startup marker was created
+                assert Path(startup_marker).exists(), "Server startup marker not created"
+                assert Path(startup_marker).read_text() == "started"
+
+                # Make a test request to ensure server is working
+                response = await session.call_tool("echo", {"text": "hello"})
+                assert response.content[0].text == "hello"
+
+                # Session will be closed when exiting the context manager
+
+        # Give server a moment to run cleanup (if it can)
+        await asyncio.sleep(0.5)
+
+        # Check if cleanup marker was created
+        # This currently fails on all platforms because process.terminate()
+        # doesn't allow cleanup code to run
+        if not Path(cleanup_marker).exists():
+            pytest.xfail("Cleanup code after yield is not executed when process is terminated (issue #1027)")
+        else:
+            # If cleanup succeeded, the issue may be fixed
+            assert Path(cleanup_marker).read_text() == "cleaned up"
+
+    finally:
+        # Clean up files
+        for path in [server_script, startup_marker, cleanup_marker]:
+            try:
+                Path(path).unlink()
+            except FileNotFoundError:
+                pass
+
+
+@pytest.mark.anyio
+@pytest.mark.filterwarnings("ignore::ResourceWarning" if sys.platform == "win32" else "default")
+async def test_stdin_close_triggers_cleanup():
+    """
+    Test that verifies if closing stdin allows cleanup to run.
+
+    This is the proposed solution from PR #1044 - close stdin first
+    and wait for the server to exit gracefully before terminating.
+
+    Note on Windows ResourceWarning:
+    On Windows, we may see ResourceWarning about unclosed file descriptors.
+    This is expected behavior because:
+    - We're manually managing the process lifecycle
+    - Windows file handle cleanup works differently than Unix
+    - The warning doesn't indicate a real issue - cleanup still works
+    We filter this warning on Windows only to avoid test noise.
+    """
+
+    # Create marker files to track server lifecycle
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as f:
+        startup_marker = f.name
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".txt") as f:
+        cleanup_marker = f.name
+
+    # Remove the files so we can detect when they're created
+    Path(startup_marker).unlink()
+    Path(cleanup_marker).unlink()
+
+    # Create an MCP server that handles stdin closure gracefully
+    server_code = textwrap.dedent(f"""
+        import asyncio
+        import sys
+        from pathlib import Path
+        from contextlib import asynccontextmanager
+        from mcp.server.fastmcp import FastMCP
+        
+        STARTUP_MARKER = {repr(startup_marker)}
+        CLEANUP_MARKER = {repr(cleanup_marker)}
+        
+        @asynccontextmanager
+        async def lifespan(server):
+            # Write startup marker
+            Path(STARTUP_MARKER).write_text("started")
+            try:
+                yield {{"started": True}}
+            finally:
+                # This cleanup code should run when stdin closes
+                Path(CLEANUP_MARKER).write_text("cleaned up")
+        
+        mcp = FastMCP("test-server", lifespan=lifespan)
+        
+        @mcp.tool()
+        def echo(text: str) -> str:
+            return text
+        
+        if __name__ == "__main__":
+            # The server should exit gracefully when stdin closes
+            try:
+                mcp.run()
+            except Exception:
+                # Server might get EOF or other errors when stdin closes
+                pass
+    """)
+
+    # Write the server script to a temporary file
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".py") as f:
+        server_script = f.name
+        f.write(server_code)
+
+    try:
+        # This test manually manages the process to test stdin closure
+        # Start the server process
+        process = await _create_platform_compatible_process(
+            command=sys.executable, args=[server_script], env=None, errlog=sys.stderr, cwd=None
+        )
+
+        # Wait for server to start
+        await asyncio.sleep(1.0)  # Give more time on Windows
+
+        # Check if process is still running
+        if hasattr(process, "returncode") and process.returncode is not None:
+            pytest.fail(f"Server process exited with code {process.returncode}")
+
+        assert Path(startup_marker).exists(), "Server startup marker not created"
+
+        # Close stdin to signal shutdown
+        if process.stdin:
+            await process.stdin.aclose()
+
+        # Wait for process to exit gracefully
+        try:
+            with anyio.fail_after(2.0):
+                await process.wait()
+        except TimeoutError:
+            # If it doesn't exit after stdin close, terminate it
+            process.terminate()
+            await process.wait()
+
+        # Check if cleanup ran
+        await asyncio.sleep(0.5)
+
+        # This should work if the server properly handles stdin closure
+        if Path(cleanup_marker).exists():
+            assert Path(cleanup_marker).read_text() == "cleaned up"
+            # If this works, it shows stdin closure can trigger graceful shutdown
+        else:
+            pytest.xfail("Server did not run cleanup after stdin closure - " "may need additional server-side handling")
+
+    finally:
+        # Clean up files
+        for path in [server_script, startup_marker, cleanup_marker]:
+            try:
+                Path(path).unlink()
+            except FileNotFoundError:
+                pass