coverage: remove redundant pragmas

Author: maxisbey

src/mcp/client/streamable_http.py

@@ -422,21 +422,21 @@ async def handle_request_async():
             await read_stream_writer.aclose()
             await write_stream.aclose()
 
-    async def terminate_session(self, client: httpx.AsyncClient) -> None:
+    async def terminate_session(self, client: httpx.AsyncClient) -> None:  # pragma: no cover
         """Terminate the session by sending a DELETE request."""
-        if not self.session_id:  # pragma: no cover
-            return  # pragma: no cover
+        if not self.session_id:
+            return
 
-        try:  # pragma: no cover
-            headers = self._prepare_request_headers(self.request_headers)  # pragma: no cover
-            response = await client.delete(self.url, headers=headers)  # pragma: no cover
+        try:
+            headers = self._prepare_request_headers(self.request_headers)
+            response = await client.delete(self.url, headers=headers)
 
-            if response.status_code == 405:  # pragma: no cover
-                logger.debug("Server does not allow session termination")  # pragma: no cover
-            elif response.status_code not in (200, 204):  # pragma: no cover
-                logger.warning(f"Session termination failed: {response.status_code}")  # pragma: no cover
-        except Exception as exc:  # pragma: no cover
-            logger.warning(f"Session termination failed: {exc}")  # pragma: no cover
+            if response.status_code == 405:
+                logger.debug("Server does not allow session termination")
+            elif response.status_code not in (200, 204):
+                logger.warning(f"Session termination failed: {response.status_code}")
+        except Exception as exc:
+            logger.warning(f"Session termination failed: {exc}")
 
     def get_session_id(self) -> str | None:
         """Get the current session ID."""

src/mcp/server/streaming_asgi_transport.py

@@ -304,44 +304,6 @@ async def auth_code(
     }
 
 
-@pytest.fixture
-async def tokens(
-    test_client: httpx.AsyncClient,
-    registered_client: dict[str, Any],
-    auth_code: dict[str, str],
-    pkce_challenge: dict[str, str],
-    request: pytest.FixtureRequest,
-):
-    """Exchange authorization code for tokens.
-
-    Parameters can be customized via indirect parameterization:
-    @pytest.mark.parametrize("tokens",
-                            [{"code_verifier": "wrong_verifier"}],
-                            indirect=True)
-    """
-    # Default token request params  # pragma: no cover
-    token_params = {  # pragma: no cover
-        "grant_type": "authorization_code",  # pragma: no cover
-        "client_id": registered_client["client_id"],  # pragma: no cover
-        "client_secret": registered_client["client_secret"],  # pragma: no cover
-        "code": auth_code["code"],  # pragma: no cover
-        "code_verifier": pkce_challenge["code_verifier"],  # pragma: no cover
-        "redirect_uri": auth_code["redirect_uri"],  # pragma: no cover
-    }  # pragma: no cover
-
-    # Override with any parameters from the test  # pragma: no cover
-    if hasattr(request, "param") and request.param:  # pragma: no cover
-        token_params.update(request.param)
-
-    response = await test_client.post("/token", data=token_params)  # pragma: no cover
-
-    # Don't assert success here since some tests will intentionally cause errors
-    return {  # pragma: no cover
-        "response": response,
-        "params": token_params,
-    }
-
-
 class TestAuthEndpoints:
     @pytest.mark.anyio
     async def test_metadata_endpoint(self, test_client: httpx.AsyncClient):