fix: convert all pragma no cover to lax no cover in source files

Server code running in-thread has non-deterministic coverage. Use
lax annotation which is excluded by coverage.py but not checked
by strict-no-cover, avoiding flaky CI failures.

Author: perhapzz

src/mcp/server/session.py

@@ -200,7 +200,7 @@ async def _received_notification(self, notification: types.ClientNotification) -
             case types.InitializedNotification():
                 self._initialization_state = InitializationState.Initialized
             case _:
-                if self._initialization_state != InitializationState.Initialized:  # pragma: no cover
+                if self._initialization_state != InitializationState.Initialized:  # pragma: lax no cover
                     raise RuntimeError("Received notification before initialization was complete")
 
     async def send_log_message(
@@ -446,7 +446,7 @@ async def elicit_url(
             metadata=ServerMessageMetadata(related_request_id=related_request_id),
         )
 
-    async def send_ping(self) -> types.EmptyResult:  # pragma: no cover
+    async def send_ping(self) -> types.EmptyResult:  # pragma: lax no cover
         """Send a ping request."""
         return await self.send_request(
             types.PingRequest(),
@@ -478,11 +478,11 @@ async def send_resource_list_changed(self) -> None:
         """Send a resource list changed notification."""
         await self.send_notification(types.ResourceListChangedNotification())
 
-    async def send_tool_list_changed(self) -> None:  # pragma: no cover
+    async def send_tool_list_changed(self) -> None:  # pragma: lax no cover
         """Send a tool list changed notification."""
         await self.send_notification(types.ToolListChangedNotification())
 
-    async def send_prompt_list_changed(self) -> None:  # pragma: no cover
+    async def send_prompt_list_changed(self) -> None:  # pragma: lax no cover
         """Send a prompt list changed notification."""
         await self.send_notification(types.PromptListChangedNotification())
 

src/mcp/server/streamable_http.py

@@ -91,7 +91,7 @@ async def store_event(self, stream_id: StreamId, message: JSONRPCMessage | None)
         Returns:
             The generated event ID for the stored event.
         """
-        pass  # pragma: no cover
+        pass  # pragma: lax no cover
 
     @abstractmethod
     async def replay_events_after(
@@ -108,7 +108,7 @@ async def replay_events_after(
         Returns:
             The stream ID of the replayed events, or None if no events were found.
         """
-        pass  # pragma: no cover
+        pass  # pragma: lax no cover
 
 
 class StreamableHTTPServerTransport:
@@ -354,7 +354,7 @@ async def _clean_up_memory_streams(self, request_id: RequestId) -> None:
                 # Close the request stream
                 await self._request_streams[request_id][0].aclose()
                 await self._request_streams[request_id][1].aclose()
-            except Exception:  # pragma: no cover
+            except Exception:  # pragma: lax no cover
                 # During cleanup, we catch all exceptions since streams might be in various states
                 logger.debug("Error closing memory streams - may already be closed")
             finally:
@@ -439,15 +439,15 @@ async def _validate_accept_header(self, request: Request, scope: Scope, send: Se
     async def _handle_post_request(self, scope: Scope, request: Request, receive: Receive, send: Send) -> None:
         """Handle POST requests containing JSON-RPC messages."""
         writer = self._read_stream_writer
-        if writer is None:  # pragma: no cover
+        if writer is None:  # pragma: lax no cover
             raise ValueError("No read stream writer available. Ensure connect() is called first.")
         try:
             # Validate Accept header
             if not await self._validate_accept_header(request, scope, send):
                 return
 
             # Validate Content-Type
-            if not self._check_content_type(request):  # pragma: no cover
+            if not self._check_content_type(request):  # pragma: lax no cover
                 response = self._create_error_response(
                     "Unsupported Media Type: Content-Type must be application/json",
                     HTTPStatus.UNSUPPORTED_MEDIA_TYPE,
@@ -486,7 +486,7 @@ async def _handle_post_request(self, scope: Scope, request: Request, receive: Re
                     request_session_id = self._get_session_id(request)
 
                     # If request has a session ID but doesn't match, return 404
-                    if request_session_id and request_session_id != self.mcp_session_id:  # pragma: no cover
+                    if request_session_id and request_session_id != self.mcp_session_id:  # pragma: lax no cover
                         response = self._create_error_response(
                             "Not Found: Invalid or expired session ID",
                             HTTPStatus.NOT_FOUND,
@@ -544,23 +544,23 @@ async def _handle_post_request(self, scope: Scope, request: Request, receive: Re
                             response_message = event_message.message
                             break
                         # For notifications and requests, keep waiting
-                        else:  # pragma: no cover
+                        else:  # pragma: lax no cover
                             logger.debug(f"received: {event_message.message.method}")
 
                     # At this point we should have a response
                     if response_message:
                         # Create JSON response
                         response = self._create_json_response(response_message)
                         await response(scope, receive, send)
-                    else:  # pragma: no cover
+                    else:  # pragma: lax no cover
                         # This shouldn't happen in normal operation
                         logger.error("No response message received before stream closed")
                         response = self._create_error_response(
                             "Error processing request: No response received",
                             HTTPStatus.INTERNAL_SERVER_ERROR,
                         )
                         await response(scope, receive, send)
-                except Exception:  # pragma: no cover
+                except Exception:  # pragma: lax no cover
                     logger.exception("Error processing JSON response")
                     response = self._create_error_response(
                         "Error processing request",
@@ -626,14 +626,14 @@ async def sse_writer():  # pragma: lax no cover
                         # Then send the message to be processed by the server
                         session_message = self._create_session_message(message, request, request_id, protocol_version)
                         await writer.send(session_message)
-                except Exception:  # pragma: no cover
+                except Exception:  # pragma: lax no cover
                     logger.exception("SSE response error")
                     await sse_stream_writer.aclose()
                     await self._clean_up_memory_streams(request_id)
                 finally:
                     await sse_stream_reader.aclose()
 
-        except Exception as err:  # pragma: no cover
+        except Exception as err:  # pragma: lax no cover
             logger.exception("Error handling POST request")
             response = self._create_error_response(
                 f"Error handling POST request: {err}",
@@ -653,7 +653,7 @@ async def _handle_get_request(self, request: Request, send: Send) -> None:
         and notifications on this stream.
         """
         writer = self._read_stream_writer
-        if writer is None:  # pragma: no cover
+        if writer is None:  # pragma: lax no cover
             raise ValueError("No read stream writer available. Ensure connect() is called first.")
 
         # Validate Accept header - must include text/event-stream
@@ -667,7 +667,7 @@ async def _handle_get_request(self, request: Request, send: Send) -> None:
             await response(request.scope, request.receive, send)
             return
 
-        if not await self._validate_request_headers(request, send):  # pragma: no cover
+        if not await self._validate_request_headers(request, send):  # pragma: lax no cover
             return
 
         # Handle resumability: check for Last-Event-ID header
@@ -740,7 +740,7 @@ async def standalone_sse_writer():
     async def _handle_delete_request(self, request: Request, send: Send) -> None:
         """Handle DELETE requests for explicit session termination."""
         # Validate session ID
-        if not self.mcp_session_id:  # pragma: no cover
+        if not self.mcp_session_id:  # pragma: lax no cover
             # If no session ID set, return Method Not Allowed
             response = self._create_error_response(
                 "Method Not Allowed: Session termination not supported",
@@ -749,7 +749,7 @@ async def _handle_delete_request(self, request: Request, send: Send) -> None:
             await response(request.scope, request.receive, send)
             return
 
-        if not await self._validate_request_headers(request, send):  # pragma: no cover
+        if not await self._validate_request_headers(request, send):  # pragma: lax no cover
             return
 
         await self.terminate()
@@ -787,7 +787,7 @@ async def terminate(self) -> None:
                 await self._write_stream_reader.aclose()
             if self._write_stream is not None:  # pragma: no branch
                 await self._write_stream.aclose()
-        except Exception as e:  # pragma: no cover
+        except Exception as e:  # pragma: lax no cover
             # During cleanup, we catch all exceptions since streams might be in various states
             logger.debug(f"Error closing streams: {e}")
 
@@ -816,7 +816,7 @@ async def _validate_request_headers(self, request: Request, send: Send) -> bool:
 
     async def _validate_session(self, request: Request, send: Send) -> bool:
         """Validate the session ID in the request."""
-        if not self.mcp_session_id:  # pragma: no cover
+        if not self.mcp_session_id:  # pragma: lax no cover
             # If we're not using session IDs, return True
             return True
 
@@ -833,7 +833,7 @@ async def _validate_session(self, request: Request, send: Send) -> bool:
             return False
 
         # If session ID doesn't match, return error
-        if request_session_id != self.mcp_session_id:  # pragma: no cover
+        if request_session_id != self.mcp_session_id:  # pragma: lax no cover
             response = self._create_error_response(
                 "Not Found: Invalid or expired session ID",
                 HTTPStatus.NOT_FOUND,
@@ -872,7 +872,7 @@ async def _replay_events(self, last_event_id: str, request: Request, send: Send)
         """
         event_store = self._event_store
         if not event_store:
-            return  # pragma: no cover
+            return  # pragma: lax no cover
 
         try:
             headers = {
@@ -921,9 +921,9 @@ async def send_event(event_message: EventMessage) -> None:
                                     await sse_stream_writer.send(event_data)
                 except anyio.ClosedResourceError:
                     # Expected when close_sse_stream() is called
-                    logger.debug("Replay SSE stream closed by close_sse_stream()")  # pragma: no cover
+                    logger.debug("Replay SSE stream closed by close_sse_stream()")  # pragma: lax no cover
                 except Exception:  # pragma: lax no cover
-                    logger.exception("Error in replay sender")  # pragma: no cover
+                    logger.exception("Error in replay sender")  # pragma: lax no cover
 
             # Create and start EventSourceResponse
             response = EventSourceResponse(
@@ -934,20 +934,20 @@ async def send_event(event_message: EventMessage) -> None:
 
             try:
                 await response(request.scope, request.receive, send)
-            except Exception:  # pragma: no cover
-                logger.exception("Error in replay response")  # pragma: no cover
+            except Exception:  # pragma: lax no cover
+                logger.exception("Error in replay response")  # pragma: lax no cover
             finally:
                 await sse_stream_writer.aclose()
                 await sse_stream_reader.aclose()
 
-        except Exception:  # pragma: no cover
-            logger.exception("Error replaying events")  # pragma: no cover
-            response = self._create_error_response(  # pragma: no cover
-                "Error replaying events",  # pragma: no cover
-                HTTPStatus.INTERNAL_SERVER_ERROR,  # pragma: no cover
-                INTERNAL_ERROR,  # pragma: no cover
-            )  # pragma: no cover
-            await response(request.scope, request.receive, send)  # pragma: no cover
+        except Exception:  # pragma: lax no cover
+            logger.exception("Error replaying events")  # pragma: lax no cover
+            response = self._create_error_response(  # pragma: lax no cover
+                "Error replaying events",  # pragma: lax no cover
+                HTTPStatus.INTERNAL_SERVER_ERROR,  # pragma: lax no cover
+                INTERNAL_ERROR,  # pragma: lax no cover
+            )  # pragma: lax no cover
+            await response(request.scope, request.receive, send)  # pragma: lax no cover
 
     @asynccontextmanager
     async def connect(
@@ -1049,6 +1049,6 @@ async def message_router():
                     await read_stream.aclose()
                     await write_stream_reader.aclose()
                     await write_stream.aclose()
-                except Exception as e:  # pragma: no cover
+                except Exception as e:  # pragma: lax no cover
                     # During cleanup, we catch all exceptions since streams might be in various states
                     logger.debug(f"Error closing streams: {e}")

src/mcp/server/transport_security.py

@@ -43,12 +43,12 @@ def __init__(self, settings: TransportSecuritySettings | None = None):
     def _validate_host(self, host: str | None) -> bool:
         """Validate the Host header against allowed values."""
         if not host:
-            logger.warning("Missing Host header in request")  # pragma: no cover
-            return False  # pragma: no cover
+            logger.warning("Missing Host header in request")  # pragma: lax no cover
+            return False  # pragma: lax no cover
 
         # Check exact match first
         if host in self.settings.allowed_hosts:
-            return True  # pragma: no cover
+            return True  # pragma: lax no cover
 
         # Check wildcard port patterns
         for allowed in self.settings.allowed_hosts:
@@ -59,8 +59,8 @@ def _validate_host(self, host: str | None) -> bool:
                 if host.startswith(base_host + ":"):  # pragma: no branch
                     return True
 
-        logger.warning(f"Invalid Host header: {host}")  # pragma: no cover
-        return False  # pragma: no cover
+        logger.warning(f"Invalid Host header: {host}")  # pragma: lax no cover
+        return False  # pragma: lax no cover
 
     def _validate_origin(self, origin: str | None) -> bool:
         """Validate the Origin header against allowed values."""
@@ -69,20 +69,20 @@ def _validate_origin(self, origin: str | None) -> bool:
             return True
 
         # Check exact match first
-        if origin in self.settings.allowed_origins:  # pragma: no cover
-            return True  # pragma: no cover
+        if origin in self.settings.allowed_origins:  # pragma: lax no cover
+            return True  # pragma: lax no cover
 
         # Check wildcard port patterns
-        for allowed in self.settings.allowed_origins:  # pragma: no cover
-            if allowed.endswith(":*"):  # pragma: no cover
+        for allowed in self.settings.allowed_origins:  # pragma: lax no cover
+            if allowed.endswith(":*"):  # pragma: lax no cover
                 # Extract base origin from pattern
-                base_origin = allowed[:-2]  # pragma: no cover
+                base_origin = allowed[:-2]  # pragma: lax no cover
                 # Check if the actual origin starts with base origin and has a port
-                if origin.startswith(base_origin + ":"):  # pragma: no cover
-                    return True  # pragma: no cover
+                if origin.startswith(base_origin + ":"):  # pragma: lax no cover
+                    return True  # pragma: lax no cover
 
-        logger.warning(f"Invalid Origin header: {origin}")  # pragma: no cover
-        return False  # pragma: no cover
+        logger.warning(f"Invalid Origin header: {origin}")  # pragma: lax no cover
+        return False  # pragma: lax no cover
 
     def _validate_content_type(self, content_type: str | None) -> bool:
         """Validate the Content-Type header for POST requests."""
@@ -106,11 +106,11 @@ async def validate_request(self, request: Request, is_post: bool = False) -> Res
         # Validate Host header
         host = request.headers.get("host")
         if not self._validate_host(host):
-            return Response("Invalid Host header", status_code=421)  # pragma: no cover
+            return Response("Invalid Host header", status_code=421)  # pragma: lax no cover
 
         # Validate Origin header
         origin = request.headers.get("origin")
         if not self._validate_origin(origin):
-            return Response("Invalid Origin header", status_code=403)  # pragma: no cover
+            return Response("Invalid Origin header", status_code=403)  # pragma: lax no cover
 
         return None