test

Author: felixweinberger

src/mcp/os/win32/utilities.py

@@ -184,6 +184,14 @@ async def create_windows_process(
     Returns:
         Process | FallbackProcess: Async-compatible subprocess with stdin and stdout streams
     """
+    # Log event loop information for debugging CI behavior
+    try:
+        import asyncio
+        loop = asyncio.get_running_loop()
+        logger.warning(f"[DIAGNOSTIC] Windows process creation - Event loop: {loop.__class__.__name__} from {loop.__class__.__module__}")
+    except Exception:
+        pass  # Don't fail if we can't get loop info
+    
     job = _create_job_object()
     process = None
 
@@ -199,19 +207,34 @@ async def create_windows_process(
             stderr=errlog,
             cwd=cwd,
         )
-    except NotImplementedError:
+    except NotImplementedError as e:
         # If Windows doesn't support async subprocess creation, use fallback
+        logger.warning(f"[DIAGNOSTIC] anyio.open_process raised NotImplementedError: {e}")
+        logger.warning("[DIAGNOSTIC] Using FallbackProcess (likely SelectorEventLoop on Windows)")
         process = await _create_windows_fallback_process(command, args, env, errlog, cwd)
-    except Exception:
+    except Exception as e:
         # Try again without creation flags
-        process = await anyio.open_process(
-            [command, *args],
-            env=env,
-            stderr=errlog,
-            cwd=cwd,
-        )
+        logger.warning(f"[DIAGNOSTIC] anyio.open_process failed with {type(e).__name__}: {e}")
+        logger.warning("[DIAGNOSTIC] Retrying without creation flags")
+        try:
+            process = await anyio.open_process(
+                [command, *args],
+                env=env,
+                stderr=errlog,
+                cwd=cwd,
+            )
+        except Exception as e2:
+            logger.warning(f"[DIAGNOSTIC] Retry also failed with {type(e2).__name__}: {e2}")
+            logger.warning("[DIAGNOSTIC] Falling back to FallbackProcess")
+            process = await _create_windows_fallback_process(command, args, env, errlog, cwd)
 
     _maybe_assign_process_to_job(process, job)
+    
+    # Log which type of process was created
+    process_type = type(process).__name__
+    process_module = type(process).__module__
+    logger.warning(f"[DIAGNOSTIC] Created process type: {process_type} from {process_module} (pid: {process.pid})")
+    
     return process
 
 

tests/issues/test_1027_process_type_diagnostic.py

@@ -0,0 +1,93 @@
+"""
+Diagnostic test to determine which process type is created in Windows CI.
+This test intentionally fails to ensure output appears in CI logs.
+"""
+
+import asyncio
+import sys
+import tempfile
+import textwrap
+from pathlib import Path
+
+import pytest
+
+# Import the Windows-specific process creation function
+if sys.platform == "win32":
+    from mcp.os.win32.utilities import create_windows_process, FallbackProcess
+    from anyio.abc import Process
+
+
+@pytest.mark.anyio
+@pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific process type detection")
+async def test_windows_process_type_diagnostic():
+    """Diagnostic test to determine if FallbackProcess is used in Windows CI."""
+    
+    # Get event loop info
+    loop = asyncio.get_running_loop()
+    loop_info = {
+        "class": loop.__class__.__name__,
+        "module": loop.__class__.__module__,
+    }
+    
+    # Create a simple test script
+    test_script = textwrap.dedent("""
+        import sys
+        print("Test process started")
+        sys.exit(0)
+    """)
+    
+    # Write script to temp file
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".py") as f:
+        script_path = f.name
+        f.write(test_script)
+    
+    try:
+        # Call create_windows_process directly
+        process = await create_windows_process(
+            command=sys.executable,
+            args=[script_path],
+            env=None,
+            errlog=sys.stderr,
+            cwd=None
+        )
+        
+        # Get process type info
+        process_type = type(process).__name__
+        process_module = type(process).__module__
+        is_fallback = isinstance(process, FallbackProcess)
+        is_anyio_process = process_module.startswith("anyio")
+        
+        # Wait for process to complete
+        try:
+            await process.wait()
+        except Exception:
+            pass
+        
+        # Clean up process
+        if hasattr(process, "__aexit__"):
+            await process.__aexit__(None, None, None)
+    
+    finally:
+        # Clean up script file
+        Path(script_path).unlink(missing_ok=True)
+    
+    # Create detailed diagnostic message
+    diagnostic_msg = f"""
+    WINDOWS PROCESS TYPE DIAGNOSTICS:
+    ================================
+    Event Loop: {loop_info['class']} from {loop_info['module']}
+    
+    Process Created:
+    - Type: {process_type}
+    - Module: {process_module}
+    - Is FallbackProcess: {is_fallback}
+    - Is anyio Process: {is_anyio_process}
+    
+    Analysis:
+    - ProactorEventLoop should support anyio.open_process
+    - If FallbackProcess is used, anyio.open_process must have failed
+    - This would indicate a problem with anyio on Windows CI
+    """
+    
+    # Intentionally fail to ensure output appears in CI logs
+    pytest.fail(f"DIAGNOSTIC TEST - Process type analysis\n{diagnostic_msg}")

tests/issues/test_1027_win_unreachable_cleanup.py

@@ -21,6 +21,8 @@
 from mcp.client.stdio import _create_platform_compatible_process, stdio_client
 
 
+
+
 @pytest.mark.anyio
 async def test_lifespan_cleanup_executed():
     """