Update test to show cleanup issue exists on all platforms

The test now demonstrates that:
1. The cleanup issue affects all platforms, not just Windows
2. Closing stdin and waiting for graceful exit allows cleanup to run

This confirms that PR #1044's approach of implementing the MCP spec's
stdio shutdown sequence (close stdin first, then wait, then terminate)
could address issue #1027.

Github-Issue:#1027

Author: felixweinberger

tests/issues/test_1027_win_unreachable_cleanup.py

@@ -43,14 +43,13 @@ async def test_lifespan_cleanup_executed():
     Path(startup_marker).unlink()
     Path(cleanup_marker).unlink()
 
-    # Create a minimal MCP server that tracks lifecycle
+    # 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.lowlevel import Server
-from mcp.server.stdio import stdio_server
+from mcp.server.fastmcp import FastMCP
 
 STARTUP_MARKER = {repr(startup_marker)}
 CLEANUP_MARKER = {repr(cleanup_marker)}
@@ -60,31 +59,19 @@ async def lifespan(server):
     # Write startup marker
     Path(STARTUP_MARKER).write_text("started")
     try:
-        yield
+        yield {{"started": True}}
     finally:
         # This cleanup code should run when server shuts down
         Path(CLEANUP_MARKER).write_text("cleaned up")
 
-async def main():
-    async with stdio_server() as (read, write):
-        server = Server("test-server", version="1.0.0")
-        server.set_lifespan(lifespan)
-        
-        async def handle_initialize(params):
-            return {{"protocolVersion": "1.0.0", "capabilities": {{}}}}
-        
-        server.set_request_handler("initialize", handle_initialize)
-        
-        async def handle_echo(params):
-            return {{"text": params.get("text", "")}}
-        
-        server.set_request_handler("test/echo", handle_echo)
-        
-        await server.run(read, write)
+mcp = FastMCP("test-server", lifespan=lifespan)
+
+@mcp.tool()
+def echo(text: str) -> str:
+    return text
 
 if __name__ == "__main__":
-    import asyncio
-    asyncio.run(main())
+    mcp.run()
 """)
 
     # Write the server script to a temporary file
@@ -103,33 +90,30 @@ async def handle_echo(params):
             async with ClientSession(read, write) as session:
                 # Initialize the session
                 result = await session.initialize()
-                assert result.protocolVersion == "1.0.0"
+                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.send_request("test/echo", {"text": "hello"})
-                assert response.text == "hello"
+                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
-        if sys.platform == "win32":
-            # On Windows, this assertion currently fails because cleanup doesn't run
-            # When issue #1027 is fixed, this should pass
+        # 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 on Windows (issue #1027)"
-                if not Path(cleanup_marker).exists()
-                else "Cleanup unexpectedly succeeded - issue may be fixed!"
+                "Cleanup code after yield is not executed when process is terminated (issue #1027)"
             )
         else:
-            # On Unix systems, cleanup should work
-            assert Path(cleanup_marker).exists(), "Server cleanup marker not created"
+            # If cleanup succeeded, the issue may be fixed
             assert Path(cleanup_marker).read_text() == "cleaned up"
 
     finally:
@@ -166,8 +150,7 @@ async def test_stdin_close_triggers_cleanup():
 import sys
 from pathlib import Path
 from contextlib import asynccontextmanager
-from mcp.server.lowlevel import Server
-from mcp.server.stdio import stdio_server
+from mcp.server.fastmcp import FastMCP
 
 STARTUP_MARKER = {repr(startup_marker)}
 CLEANUP_MARKER = {repr(cleanup_marker)}
@@ -177,30 +160,24 @@ async def lifespan(server):
     # Write startup marker
     Path(STARTUP_MARKER).write_text("started")
     try:
-        yield
+        yield {{"started": True}}
     finally:
         # This cleanup code should run when stdin closes
         Path(CLEANUP_MARKER).write_text("cleaned up")
 
-async def main():
+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:
-        async with stdio_server() as (read, write):
-            server = Server("test-server", version="1.0.0")
-            server.set_lifespan(lifespan)
-            
-            async def handle_initialize(params):
-                return {{"protocolVersion": "1.0.0", "capabilities": {{}}}}
-            
-            server.set_request_handler("initialize", handle_initialize)
-            
-            # The server should exit gracefully when stdin closes
-            await server.run(read, write)
+        mcp.run()
     except Exception:
         # Server might get EOF or other errors when stdin closes
         pass
-
-if __name__ == "__main__":
-    asyncio.run(main())
 """)
 
     # Write the server script to a temporary file
@@ -218,7 +195,7 @@ async def handle_initialize(params):
             command=sys.executable,
             args=[server_script],
             env=None,
-            stderr=None,
+            errlog=sys.stderr,
             cwd=None
         )