test: use in-process threads for test servers to enable coverage tracking

Refactor basic_server, event_server, and json_response_server fixtures
to use threading.Thread + uvicorn.Server instead of multiprocessing.Process.

Since coverage tools cannot track code running in child processes, this
change runs test servers in background threads within the same process,
allowing coverage to instrument the server handler functions, create_app(),
_create_server(), and fixture code.

This removes 8 'pragma: no cover' markers from functions that are now
covered. The remaining markers are on context_aware_server (PR 2),
defensive returns in tests, and one unreachable raise.

Fixes #1678 (partial)

Author: perhapzz

tests/shared/test_streamable_http.py

@@ -7,6 +7,7 @@
 
 import json
 import multiprocessing
+import threading
 import socket
 import time
 import traceback
@@ -108,7 +109,7 @@ async def store_event(self, stream_id: StreamId, message: types.JSONRPCMessage |
         self._events.append((stream_id, event_id, message))
         return event_id
 
-    async def replay_events_after(  # pragma: no cover
+    async def replay_events_after(
         self,
         last_event_id: EventId,
         send_callback: EventCallback,
@@ -144,11 +145,11 @@ class ServerState:
 
 
 @asynccontextmanager
-async def _server_lifespan(_server: Server[ServerState]) -> AsyncIterator[ServerState]:  # pragma: no cover
+async def _server_lifespan(_server: Server[ServerState]) -> AsyncIterator[ServerState]:
     yield ServerState()
 
 
-async def _handle_read_resource(  # pragma: no cover
+async def _handle_read_resource(
     ctx: ServerRequestContext[ServerState], params: ReadResourceRequestParams
 ) -> ReadResourceResult:
     uri = str(params.uri)
@@ -163,7 +164,7 @@ async def _handle_read_resource(  # pragma: no cover
     return ReadResourceResult(contents=[TextResourceContents(uri=uri, text=text, mime_type="text/plain")])
 
 
-async def _handle_list_tools(  # pragma: no cover
+async def _handle_list_tools(
     ctx: ServerRequestContext[ServerState], params: PaginatedRequestParams | None
 ) -> ListToolsResult:
     return ListToolsResult(
@@ -228,7 +229,7 @@ async def _handle_list_tools(  # pragma: no cover
     )
 
 
-async def _handle_call_tool(  # pragma: no cover
+async def _handle_call_tool(
     ctx: ServerRequestContext[ServerState], params: CallToolRequestParams
 ) -> CallToolResult:
     name = params.name
@@ -382,7 +383,7 @@ async def _handle_call_tool(  # pragma: no cover
     return CallToolResult(content=[TextContent(type="text", text=f"Called {name}")])
 
 
-def _create_server() -> Server[ServerState]:  # pragma: no cover
+def _create_server() -> Server[ServerState]:
     return Server(
         SERVER_NAME,
         lifespan=_server_lifespan,
@@ -396,7 +397,7 @@ def create_app(
     is_json_response_enabled: bool = False,
     event_store: EventStore | None = None,
     retry_interval: int | None = None,
-) -> Starlette:  # pragma: no cover
+) -> Starlette:
     """Create a Starlette application for testing using the session manager.
 
     Args:
@@ -437,7 +438,7 @@ def run_server(
     event_store: EventStore | None = None,
     retry_interval: int | None = None,
 ) -> None:  # pragma: no cover
-    """Run the test server.
+    """Run the test server in a subprocess (used only by context_aware_server).
 
     Args:
         port: Port to listen on.
@@ -468,6 +469,33 @@ def run_server(
         traceback.print_exc()
 
 
+def _start_server_thread(
+    port: int,
+    is_json_response_enabled: bool = False,
+    event_store: EventStore | None = None,
+    retry_interval: int | None = None,
+) -> tuple[threading.Thread, uvicorn.Server]:
+    """Start a test server in a background thread (in-process for coverage).
+
+    Returns:
+        A tuple of (thread, uvicorn_server) for cleanup.
+    """
+    app = create_app(is_json_response_enabled, event_store, retry_interval)
+    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,
+    )
+    server = uvicorn.Server(config=config)
+    thread = threading.Thread(target=server.run, daemon=True)
+    thread.start()
+    return thread, server
+
+
 # Test fixtures - using same approach as SSE tests
 @pytest.fixture
 def basic_server_port() -> int:
@@ -487,18 +515,17 @@ def json_server_port() -> int:
 
 @pytest.fixture
 def basic_server(basic_server_port: int) -> Generator[None, None, None]:
-    """Start a basic server."""
-    proc = multiprocessing.Process(target=run_server, kwargs={"port": basic_server_port}, daemon=True)
-    proc.start()
+    """Start a basic server in a background thread (in-process for coverage)."""
+    thread, server = _start_server_thread(port=basic_server_port)
 
     # Wait for server to be running
     wait_for_server(basic_server_port)
 
     yield
 
     # Clean up
-    proc.kill()
-    proc.join(timeout=2)
+    server.should_exit = True
+    thread.join(timeout=5)
 
 
 @pytest.fixture
@@ -519,42 +546,36 @@ def event_server_port() -> int:
 def event_server(
     event_server_port: int, event_store: SimpleEventStore
 ) -> Generator[tuple[SimpleEventStore, str], None, None]:
-    """Start a server with event store and retry_interval enabled."""
-    proc = multiprocessing.Process(
-        target=run_server,
-        kwargs={"port": event_server_port, "event_store": event_store, "retry_interval": 500},
-        daemon=True,
+    """Start a server with event store and retry_interval enabled (in-process for coverage)."""
+    thread, server = _start_server_thread(
+        port=event_server_port, event_store=event_store, retry_interval=500
     )
-    proc.start()
 
     # Wait for server to be running
     wait_for_server(event_server_port)
 
     yield event_store, f"http://127.0.0.1:{event_server_port}"
 
     # Clean up
-    proc.kill()
-    proc.join(timeout=2)
+    server.should_exit = True
+    thread.join(timeout=5)
 
 
 @pytest.fixture
 def json_response_server(json_server_port: int) -> Generator[None, None, None]:
-    """Start a server with JSON response enabled."""
-    proc = multiprocessing.Process(
-        target=run_server,
-        kwargs={"port": json_server_port, "is_json_response_enabled": True},
-        daemon=True,
+    """Start a server with JSON response enabled (in-process for coverage)."""
+    thread, server = _start_server_thread(
+        port=json_server_port, is_json_response_enabled=True
     )
-    proc.start()
 
     # Wait for server to be running
     wait_for_server(json_server_port)
 
     yield
 
     # Clean up
-    proc.kill()
-    proc.join(timeout=2)
+    server.should_exit = True
+    thread.join(timeout=5)
 
 
 @pytest.fixture
@@ -1044,7 +1065,7 @@ def test_get_validation(basic_server: None, basic_server_url: str):
 
 # Client-specific fixtures
 @pytest.fixture
-async def http_client(basic_server: None, basic_server_url: str):  # pragma: no cover
+async def http_client(basic_server: None, basic_server_url: str):
     """Create test client matching the SSE test pattern."""
     async with httpx.AsyncClient(base_url=basic_server_url) as client:
         yield client