test: convert context_aware_server to in-process threads for coverage

- Replace multiprocessing.Process with threading.Thread for
  context_aware_server fixture (same pattern as PR #2341)
- Remove 5 pragma: no cover markers from context-aware server code
- Remove dead run_server() function and unused imports
- Remaining 5 pragmas are on genuinely unreachable defensive code

Author: perhapzz

tests/shared/test_streamable_http.py

@@ -6,11 +6,9 @@
 from __future__ import annotations as _annotations
 
 import json
-import multiprocessing
 import socket
 import threading
 import time
-import traceback
 from collections.abc import AsyncIterator, Generator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
@@ -430,43 +428,6 @@ def create_app(
     return app
 
 
-def run_server(
-    port: int,
-    is_json_response_enabled: bool = False,
-    event_store: EventStore | None = None,
-    retry_interval: int | None = None,
-) -> None:  # pragma: no cover
-    """Run the test server in a subprocess (used only by context_aware_server).
-
-    Args:
-        port: Port to listen on.
-        is_json_response_enabled: If True, use JSON responses instead of SSE streams.
-        event_store: Optional event store for testing resumability.
-        retry_interval: Retry interval in milliseconds for SSE polling.
-    """
-
-    app = create_app(is_json_response_enabled, event_store, retry_interval)
-    # Configure server
-    config = uvicorn.Config(
-        app=app,
-        host="127.0.0.1",
-        port=port,
-        log_level="info",
-        limit_concurrency=10,
-        timeout_keep_alive=5,
-        access_log=False,
-    )
-
-    # Start the server
-    server = uvicorn.Server(config=config)
-
-    # This is important to catch exceptions and prevent test hangs
-    try:
-        server.run()
-    except Exception:
-        traceback.print_exc()
-
-
 def _start_server_thread(
     port: int,
     is_json_response_enabled: bool = False,
@@ -1477,7 +1438,7 @@ async def sampling_callback(
 
 
 # Context-aware server implementation for testing request context propagation
-async def _handle_context_list_tools(  # pragma: no cover
+async def _handle_context_list_tools(
     ctx: ServerRequestContext, params: PaginatedRequestParams | None
 ) -> ListToolsResult:
     return ListToolsResult(
@@ -1502,9 +1463,7 @@ async def _handle_context_list_tools(  # pragma: no cover
     )
 
 
-async def _handle_context_call_tool(  # pragma: no cover
-    ctx: ServerRequestContext, params: CallToolRequestParams
-) -> CallToolResult:
+async def _handle_context_call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
     name = params.name
     args = params.arguments or {}
 
@@ -1532,8 +1491,8 @@ async def _handle_context_call_tool(  # pragma: no cover
 
 
 # Server runner for context-aware testing
-def run_context_aware_server(port: int):  # pragma: no cover
-    """Run the context-aware test server."""
+def _create_context_aware_app(port: int) -> tuple[uvicorn.Server, Starlette]:
+    """Create the context-aware test server app and uvicorn.Server."""
     server = Server(
         "ContextAwareServer",
         on_list_tools=_handle_context_list_tools,
@@ -1562,24 +1521,22 @@ def run_context_aware_server(port: int):  # pragma: no cover
             log_level="error",
         )
     )
-    server_instance.run()
+    return server_instance, app
 
 
 @pytest.fixture
 def context_aware_server(basic_server_port: int) -> Generator[None, None, None]:
-    """Start the context-aware server in a separate process."""
-    proc = multiprocessing.Process(target=run_context_aware_server, args=(basic_server_port,), daemon=True)
-    proc.start()
+    """Start the context-aware server on a background thread (in-process for coverage)."""
+    server_instance, _ = _create_context_aware_app(basic_server_port)
+    thread = threading.Thread(target=server_instance.run, daemon=True)
+    thread.start()
 
-    # Wait for server to be running
     wait_for_server(basic_server_port)
 
     yield
 
-    proc.kill()
-    proc.join(timeout=2)
-    if proc.is_alive():  # pragma: no cover
-        print("Context-aware server process failed to terminate")
+    server_instance.should_exit = True
+    thread.join(timeout=5)
 
 
 @pytest.mark.anyio