test: reduce test_ws.py to just the WS smoke test

The three tests converted to in-memory transport in the previous commit
weren't testing WebSocket behavior anymore — they were sitting in
test_ws.py with misleading names.

- test_ws_client_happy_request_and_response: deleted. Duplicates
  tests/client/test_client.py::test_read_resource.

- test_ws_client_timeout: deleted. tests/issues/test_88_random_error.py
  covers the same session-recovery-after-timeout scenario more
  thoroughly (uses read_timeout_seconds and an anyio.Event to release
  the slow handler cleanly).

- test_ws_client_exception_handling: moved to test_client.py as
  test_read_resource_error_propagates. This was the only unique
  behavior — nothing else asserts that a handler-raised MCPError
  reaches the client with its error code intact.

test_ws.py now contains only what it says on the tin.

Author: maxisbey

tests/client/test_client.py

@@ -8,7 +8,7 @@
 import pytest
 from inline_snapshot import snapshot
 
-from mcp import types
+from mcp import MCPError, types
 from mcp.client._memory import InMemoryTransport
 from mcp.client.client import Client
 from mcp.server import Server, ServerRequestContext
@@ -175,6 +175,21 @@ async def test_read_resource(app: MCPServer):
         )
 
 
+async def test_read_resource_error_propagates():
+    """MCPError raised by a server handler propagates to the client with its code intact."""
+
+    async def handle_read_resource(
+        ctx: ServerRequestContext, params: types.ReadResourceRequestParams
+    ) -> ReadResourceResult:
+        raise MCPError(code=404, message="no resource with that URI was found")
+
+    server = Server("test", on_read_resource=handle_read_resource)
+    async with Client(server) as client:
+        with pytest.raises(MCPError) as exc_info:
+            await client.read_resource("unknown://example")
+        assert exc_info.value.error.code == 404
+
+
 async def test_get_prompt(app: MCPServer):
     """Test getting a prompt."""
     async with Client(app) as client:

tests/shared/test_ws.py

@@ -1,44 +1,27 @@
-"""Tests for the WebSocket transport.
+"""Smoke test for the WebSocket transport.
 
-The smoke test (``test_ws_client_basic_connection``) runs the full WS stack
-end-to-end over a real TCP connection and is what provides coverage of
-``src/mcp/client/websocket.py``.
-
-The remaining tests verify transport-agnostic MCP semantics (error
-propagation, client-side timeouts) and use the in-memory ``Client`` transport
-to avoid the cost and flakiness of real network servers.
+Runs the full WS stack end-to-end over a real TCP connection to provide
+coverage of ``src/mcp/client/websocket.py``. MCP semantics (error
+propagation, timeouts, etc.) are transport-agnostic and are covered in
+``tests/client/test_client.py`` and ``tests/issues/test_88_random_error.py``.
 """
 
 from collections.abc import Generator
-from urllib.parse import urlparse
 
-import anyio
 import pytest
 from starlette.applications import Starlette
 from starlette.routing import WebSocketRoute
 from starlette.websockets import WebSocket
 
-from mcp import Client, MCPError
 from mcp.client.session import ClientSession
 from mcp.client.websocket import websocket_client
-from mcp.server import Server, ServerRequestContext
+from mcp.server import Server
 from mcp.server.websocket import websocket_server
-from mcp.types import (
-    EmptyResult,
-    InitializeResult,
-    ReadResourceRequestParams,
-    ReadResourceResult,
-    TextResourceContents,
-)
+from mcp.types import EmptyResult, InitializeResult
 from tests.test_helpers import run_uvicorn_in_thread
 
 SERVER_NAME = "test_server_for_WS"
 
-pytestmark = pytest.mark.anyio
-
-
-# --- WebSocket transport smoke test (real TCP) -------------------------------
-
 
 def make_server_app() -> Starlette:
     srv = Server(SERVER_NAME)
@@ -56,6 +39,7 @@ def ws_server_url() -> Generator[str, None, None]:
         yield base_url.replace("http://", "ws://") + "/ws"
 
 
+@pytest.mark.anyio
 async def test_ws_client_basic_connection(ws_server_url: str) -> None:
     async with websocket_client(ws_server_url) as streams:
         async with ClientSession(*streams) as session:
@@ -65,57 +49,3 @@ async def test_ws_client_basic_connection(ws_server_url: str) -> None:
 
             ping_result = await session.send_ping()
             assert isinstance(ping_result, EmptyResult)
-
-
-# --- In-memory tests (transport-agnostic MCP semantics) ----------------------
-
-
-async def handle_read_resource(ctx: ServerRequestContext, params: ReadResourceRequestParams) -> ReadResourceResult:
-    parsed = urlparse(str(params.uri))
-    if parsed.scheme == "foobar":
-        return ReadResourceResult(
-            contents=[TextResourceContents(uri=str(params.uri), text=f"Read {parsed.netloc}", mime_type="text/plain")]
-        )
-    elif parsed.scheme == "slow":
-        # Block indefinitely so the client-side fail_after() fires; the pending
-        # server task is cancelled when the Client context manager exits.
-        await anyio.sleep_forever()
-    raise MCPError(code=404, message="OOPS! no resource with that URI was found")
-
-
-@pytest.fixture
-def server() -> Server:
-    return Server(SERVER_NAME, on_read_resource=handle_read_resource)
-
-
-async def test_ws_client_happy_request_and_response(server: Server) -> None:
-    async with Client(server) as client:
-        result = await client.read_resource("foobar://example")
-        assert isinstance(result, ReadResourceResult)
-        assert isinstance(result.contents, list)
-        assert len(result.contents) > 0
-        assert isinstance(result.contents[0], TextResourceContents)
-        assert result.contents[0].text == "Read example"
-
-
-async def test_ws_client_exception_handling(server: Server) -> None:
-    async with Client(server) as client:
-        with pytest.raises(MCPError) as exc_info:
-            await client.read_resource("unknown://example")
-        assert exc_info.value.error.code == 404
-
-
-async def test_ws_client_timeout(server: Server) -> None:
-    async with Client(server) as client:
-        with pytest.raises(TimeoutError):
-            with anyio.fail_after(0.1):
-                await client.read_resource("slow://example")
-
-        # Session remains usable after a client-side timeout abandons a request.
-        with anyio.fail_after(5):
-            result = await client.read_resource("foobar://example")
-            assert isinstance(result, ReadResourceResult)
-            assert isinstance(result.contents, list)
-            assert len(result.contents) > 0
-            assert isinstance(result.contents[0], TextResourceContents)
-            assert result.contents[0].text == "Read example"