同步完整源码 - 2026-05-25
This commit is contained in:
@@ -0,0 +1,140 @@
|
||||
"""Tests for OAuth 2.0 shared code."""
|
||||
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthMetadata
|
||||
|
||||
|
||||
def test_oauth():
|
||||
"""Should not throw when parsing OAuth metadata."""
|
||||
OAuthMetadata.model_validate(
|
||||
{
|
||||
"issuer": "https://example.com",
|
||||
"authorization_endpoint": "https://example.com/oauth2/authorize",
|
||||
"token_endpoint": "https://example.com/oauth2/token",
|
||||
"scopes_supported": ["read", "write"],
|
||||
"response_types_supported": ["code", "token"],
|
||||
"token_endpoint_auth_methods_supported": ["client_secret_basic", "client_secret_post"],
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def test_oidc():
|
||||
"""Should not throw when parsing OIDC metadata."""
|
||||
OAuthMetadata.model_validate(
|
||||
{
|
||||
"issuer": "https://example.com",
|
||||
"authorization_endpoint": "https://example.com/oauth2/authorize",
|
||||
"token_endpoint": "https://example.com/oauth2/token",
|
||||
"end_session_endpoint": "https://example.com/logout",
|
||||
"id_token_signing_alg_values_supported": ["RS256"],
|
||||
"jwks_uri": "https://example.com/.well-known/jwks.json",
|
||||
"response_types_supported": ["code", "token"],
|
||||
"revocation_endpoint": "https://example.com/oauth2/revoke",
|
||||
"scopes_supported": ["openid", "read", "write"],
|
||||
"subject_types_supported": ["public"],
|
||||
"token_endpoint_auth_methods_supported": ["client_secret_basic", "client_secret_post"],
|
||||
"userinfo_endpoint": "https://example.com/oauth2/userInfo",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def test_oauth_with_jarm():
|
||||
"""Should not throw when parsing OAuth metadata that includes JARM response modes."""
|
||||
OAuthMetadata.model_validate(
|
||||
{
|
||||
"issuer": "https://example.com",
|
||||
"authorization_endpoint": "https://example.com/oauth2/authorize",
|
||||
"token_endpoint": "https://example.com/oauth2/token",
|
||||
"scopes_supported": ["read", "write"],
|
||||
"response_types_supported": ["code", "token"],
|
||||
"response_modes_supported": [
|
||||
"query",
|
||||
"fragment",
|
||||
"form_post",
|
||||
"query.jwt",
|
||||
"fragment.jwt",
|
||||
"form_post.jwt",
|
||||
"jwt",
|
||||
],
|
||||
"token_endpoint_auth_methods_supported": ["client_secret_basic", "client_secret_post"],
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
# RFC 7591 §2 marks client_uri/logo_uri/tos_uri/policy_uri/jwks_uri as OPTIONAL.
|
||||
# Some authorization servers echo the client's omitted metadata back as ""
|
||||
# instead of dropping the keys; without coercion, AnyHttpUrl rejects "" and
|
||||
# the whole registration response is thrown away even though the server
|
||||
# returned a valid client_id.
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"empty_field",
|
||||
["client_uri", "logo_uri", "tos_uri", "policy_uri", "jwks_uri"],
|
||||
)
|
||||
def test_optional_url_empty_string_coerced_to_none(empty_field: str):
|
||||
data = {
|
||||
"redirect_uris": ["https://example.com/callback"],
|
||||
empty_field: "",
|
||||
}
|
||||
metadata = OAuthClientMetadata.model_validate(data)
|
||||
assert getattr(metadata, empty_field) is None
|
||||
|
||||
|
||||
def test_all_optional_urls_empty_together():
|
||||
data = {
|
||||
"redirect_uris": ["https://example.com/callback"],
|
||||
"client_uri": "",
|
||||
"logo_uri": "",
|
||||
"tos_uri": "",
|
||||
"policy_uri": "",
|
||||
"jwks_uri": "",
|
||||
}
|
||||
metadata = OAuthClientMetadata.model_validate(data)
|
||||
assert metadata.client_uri is None
|
||||
assert metadata.logo_uri is None
|
||||
assert metadata.tos_uri is None
|
||||
assert metadata.policy_uri is None
|
||||
assert metadata.jwks_uri is None
|
||||
|
||||
|
||||
def test_valid_url_passes_through_unchanged():
|
||||
data = {
|
||||
"redirect_uris": ["https://example.com/callback"],
|
||||
"client_uri": "https://udemy.com/",
|
||||
}
|
||||
metadata = OAuthClientMetadata.model_validate(data)
|
||||
assert str(metadata.client_uri) == "https://udemy.com/"
|
||||
|
||||
|
||||
def test_information_full_inherits_coercion():
|
||||
"""OAuthClientInformationFull subclasses OAuthClientMetadata, so the
|
||||
same coercion applies to DCR responses parsed via the full model."""
|
||||
data = {
|
||||
"client_id": "abc123",
|
||||
"redirect_uris": ["https://example.com/callback"],
|
||||
"client_uri": "",
|
||||
"logo_uri": "",
|
||||
"tos_uri": "",
|
||||
"policy_uri": "",
|
||||
"jwks_uri": "",
|
||||
}
|
||||
info = OAuthClientInformationFull.model_validate(data)
|
||||
assert info.client_id == "abc123"
|
||||
assert info.client_uri is None
|
||||
assert info.logo_uri is None
|
||||
assert info.tos_uri is None
|
||||
assert info.policy_uri is None
|
||||
assert info.jwks_uri is None
|
||||
|
||||
|
||||
def test_invalid_non_empty_url_still_rejected():
|
||||
"""Coercion must only touch empty strings — garbage URLs still raise."""
|
||||
data = {
|
||||
"redirect_uris": ["https://example.com/callback"],
|
||||
"client_uri": "not a url",
|
||||
}
|
||||
with pytest.raises(ValidationError):
|
||||
OAuthClientMetadata.model_validate(data)
|
||||
@@ -0,0 +1,123 @@
|
||||
"""Tests for OAuth 2.0 Resource Indicators utilities."""
|
||||
|
||||
from pydantic import HttpUrl
|
||||
|
||||
from mcp.shared.auth_utils import check_resource_allowed, resource_url_from_server_url
|
||||
|
||||
# Tests for resource_url_from_server_url function
|
||||
|
||||
|
||||
def test_resource_url_from_server_url_removes_fragment():
|
||||
"""Fragment should be removed per RFC 8707."""
|
||||
assert resource_url_from_server_url("https://example.com/path#fragment") == "https://example.com/path"
|
||||
assert resource_url_from_server_url("https://example.com/#fragment") == "https://example.com/"
|
||||
|
||||
|
||||
def test_resource_url_from_server_url_preserves_path():
|
||||
"""Path should be preserved."""
|
||||
assert (
|
||||
resource_url_from_server_url("https://example.com/path/to/resource") == "https://example.com/path/to/resource"
|
||||
)
|
||||
assert resource_url_from_server_url("https://example.com/") == "https://example.com/"
|
||||
assert resource_url_from_server_url("https://example.com") == "https://example.com"
|
||||
|
||||
|
||||
def test_resource_url_from_server_url_preserves_query():
|
||||
"""Query parameters should be preserved."""
|
||||
assert resource_url_from_server_url("https://example.com/path?foo=bar") == "https://example.com/path?foo=bar"
|
||||
assert resource_url_from_server_url("https://example.com/?key=value") == "https://example.com/?key=value"
|
||||
|
||||
|
||||
def test_resource_url_from_server_url_preserves_port():
|
||||
"""Non-default ports should be preserved."""
|
||||
assert resource_url_from_server_url("https://example.com:8443/path") == "https://example.com:8443/path"
|
||||
assert resource_url_from_server_url("http://example.com:8080/") == "http://example.com:8080/"
|
||||
|
||||
|
||||
def test_resource_url_from_server_url_lowercase_scheme_and_host():
|
||||
"""Scheme and host should be lowercase for canonical form."""
|
||||
assert resource_url_from_server_url("HTTPS://EXAMPLE.COM/path") == "https://example.com/path"
|
||||
assert resource_url_from_server_url("Http://Example.Com:8080/") == "http://example.com:8080/"
|
||||
|
||||
|
||||
def test_resource_url_from_server_url_handles_pydantic_urls():
|
||||
"""Should handle Pydantic URL types."""
|
||||
url = HttpUrl("https://example.com/path")
|
||||
assert resource_url_from_server_url(url) == "https://example.com/path"
|
||||
|
||||
|
||||
# Tests for check_resource_allowed function
|
||||
|
||||
|
||||
def test_check_resource_allowed_identical_urls():
|
||||
"""Identical URLs should match."""
|
||||
assert check_resource_allowed("https://example.com/path", "https://example.com/path") is True
|
||||
assert check_resource_allowed("https://example.com/", "https://example.com/") is True
|
||||
assert check_resource_allowed("https://example.com", "https://example.com") is True
|
||||
|
||||
|
||||
def test_check_resource_allowed_different_schemes():
|
||||
"""Different schemes should not match."""
|
||||
assert check_resource_allowed("https://example.com/path", "http://example.com/path") is False
|
||||
assert check_resource_allowed("http://example.com/", "https://example.com/") is False
|
||||
|
||||
|
||||
def test_check_resource_allowed_different_domains():
|
||||
"""Different domains should not match."""
|
||||
assert check_resource_allowed("https://example.com/path", "https://example.org/path") is False
|
||||
assert check_resource_allowed("https://sub.example.com/", "https://example.com/") is False
|
||||
|
||||
|
||||
def test_check_resource_allowed_different_ports():
|
||||
"""Different ports should not match."""
|
||||
assert check_resource_allowed("https://example.com:8443/path", "https://example.com/path") is False
|
||||
assert check_resource_allowed("https://example.com:8080/", "https://example.com:8443/") is False
|
||||
|
||||
|
||||
def test_check_resource_allowed_hierarchical_matching():
|
||||
"""Child paths should match parent paths."""
|
||||
# Parent resource allows child resources
|
||||
assert check_resource_allowed("https://example.com/api/v1/users", "https://example.com/api") is True
|
||||
assert check_resource_allowed("https://example.com/api/v1", "https://example.com/api") is True
|
||||
assert check_resource_allowed("https://example.com/mcp/server", "https://example.com/mcp") is True
|
||||
|
||||
# Exact match
|
||||
assert check_resource_allowed("https://example.com/api", "https://example.com/api") is True
|
||||
|
||||
# Parent cannot use child's token
|
||||
assert check_resource_allowed("https://example.com/api", "https://example.com/api/v1") is False
|
||||
assert check_resource_allowed("https://example.com/", "https://example.com/api") is False
|
||||
|
||||
|
||||
def test_check_resource_allowed_path_boundary_matching():
|
||||
"""Path matching should respect boundaries."""
|
||||
# Should not match partial path segments
|
||||
assert check_resource_allowed("https://example.com/apiextra", "https://example.com/api") is False
|
||||
assert check_resource_allowed("https://example.com/api123", "https://example.com/api") is False
|
||||
|
||||
# Should match with trailing slash
|
||||
assert check_resource_allowed("https://example.com/api/", "https://example.com/api") is True
|
||||
assert check_resource_allowed("https://example.com/api/v1", "https://example.com/api/") is True
|
||||
|
||||
|
||||
def test_check_resource_allowed_trailing_slash_handling():
|
||||
"""Trailing slashes should be handled correctly."""
|
||||
# With and without trailing slashes
|
||||
assert check_resource_allowed("https://example.com/api/", "https://example.com/api") is True
|
||||
assert check_resource_allowed("https://example.com/api", "https://example.com/api/") is True
|
||||
assert check_resource_allowed("https://example.com/api/v1", "https://example.com/api") is True
|
||||
assert check_resource_allowed("https://example.com/api/v1", "https://example.com/api/") is True
|
||||
|
||||
|
||||
def test_check_resource_allowed_case_insensitive_origin():
|
||||
"""Origin comparison should be case-insensitive."""
|
||||
assert check_resource_allowed("https://EXAMPLE.COM/path", "https://example.com/path") is True
|
||||
assert check_resource_allowed("HTTPS://example.com/path", "https://example.com/path") is True
|
||||
assert check_resource_allowed("https://Example.Com:8080/api", "https://example.com:8080/api") is True
|
||||
|
||||
|
||||
def test_check_resource_allowed_empty_paths():
|
||||
"""Empty paths should be handled correctly."""
|
||||
assert check_resource_allowed("https://example.com", "https://example.com") is True
|
||||
assert check_resource_allowed("https://example.com/", "https://example.com") is True
|
||||
assert check_resource_allowed("https://example.com/api", "https://example.com") is True
|
||||
@@ -0,0 +1,164 @@
|
||||
"""Tests for MCP exception classes."""
|
||||
|
||||
import pytest
|
||||
|
||||
from mcp.shared.exceptions import MCPError, UrlElicitationRequiredError
|
||||
from mcp.types import URL_ELICITATION_REQUIRED, ElicitRequestURLParams, ErrorData
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_create_with_single_elicitation() -> None:
|
||||
"""Test creating error with a single elicitation."""
|
||||
elicitation = ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Auth required",
|
||||
url="https://example.com/auth",
|
||||
elicitation_id="test-123",
|
||||
)
|
||||
error = UrlElicitationRequiredError([elicitation])
|
||||
|
||||
assert error.error.code == URL_ELICITATION_REQUIRED
|
||||
assert error.error.message == "URL elicitation required"
|
||||
assert len(error.elicitations) == 1
|
||||
assert error.elicitations[0].elicitation_id == "test-123"
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_create_with_multiple_elicitations() -> None:
|
||||
"""Test creating error with multiple elicitations uses plural message."""
|
||||
elicitations = [
|
||||
ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Auth 1",
|
||||
url="https://example.com/auth1",
|
||||
elicitation_id="test-1",
|
||||
),
|
||||
ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Auth 2",
|
||||
url="https://example.com/auth2",
|
||||
elicitation_id="test-2",
|
||||
),
|
||||
]
|
||||
error = UrlElicitationRequiredError(elicitations)
|
||||
|
||||
assert error.error.message == "URL elicitations required" # Plural
|
||||
assert len(error.elicitations) == 2
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_custom_message() -> None:
|
||||
"""Test creating error with a custom message."""
|
||||
elicitation = ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Auth required",
|
||||
url="https://example.com/auth",
|
||||
elicitation_id="test-123",
|
||||
)
|
||||
error = UrlElicitationRequiredError([elicitation], message="Custom message")
|
||||
|
||||
assert error.error.message == "Custom message"
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_from_error_data() -> None:
|
||||
"""Test reconstructing error from ErrorData."""
|
||||
error_data = ErrorData(
|
||||
code=URL_ELICITATION_REQUIRED,
|
||||
message="URL elicitation required",
|
||||
data={
|
||||
"elicitations": [
|
||||
{
|
||||
"mode": "url",
|
||||
"message": "Auth required",
|
||||
"url": "https://example.com/auth",
|
||||
"elicitationId": "test-123",
|
||||
}
|
||||
]
|
||||
},
|
||||
)
|
||||
|
||||
error = UrlElicitationRequiredError.from_error(error_data)
|
||||
|
||||
assert len(error.elicitations) == 1
|
||||
assert error.elicitations[0].elicitation_id == "test-123"
|
||||
assert error.elicitations[0].url == "https://example.com/auth"
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_from_error_data_wrong_code() -> None:
|
||||
"""Test that from_error raises ValueError for wrong error code."""
|
||||
error_data = ErrorData(
|
||||
code=-32600, # Wrong code
|
||||
message="Some other error",
|
||||
data={},
|
||||
)
|
||||
|
||||
with pytest.raises(ValueError, match="Expected error code"):
|
||||
UrlElicitationRequiredError.from_error(error_data)
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_serialization_roundtrip() -> None:
|
||||
"""Test that error can be serialized and reconstructed."""
|
||||
original = UrlElicitationRequiredError(
|
||||
[
|
||||
ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Auth required",
|
||||
url="https://example.com/auth",
|
||||
elicitation_id="test-123",
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
# Simulate serialization over wire
|
||||
error_data = original.error
|
||||
|
||||
# Reconstruct
|
||||
reconstructed = UrlElicitationRequiredError.from_error(error_data)
|
||||
|
||||
assert reconstructed.elicitations[0].elicitation_id == original.elicitations[0].elicitation_id
|
||||
assert reconstructed.elicitations[0].url == original.elicitations[0].url
|
||||
assert reconstructed.elicitations[0].message == original.elicitations[0].message
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_data_contains_elicitations() -> None:
|
||||
"""Test that error data contains properly serialized elicitations."""
|
||||
elicitation = ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Please authenticate",
|
||||
url="https://example.com/oauth",
|
||||
elicitation_id="oauth-flow-1",
|
||||
)
|
||||
error = UrlElicitationRequiredError([elicitation])
|
||||
|
||||
assert error.error.data is not None
|
||||
assert "elicitations" in error.error.data
|
||||
elicit_data = error.error.data["elicitations"][0]
|
||||
assert elicit_data["mode"] == "url"
|
||||
assert elicit_data["message"] == "Please authenticate"
|
||||
assert elicit_data["url"] == "https://example.com/oauth"
|
||||
assert elicit_data["elicitationId"] == "oauth-flow-1"
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_inherits_from_mcp_error() -> None:
|
||||
"""Test that UrlElicitationRequiredError inherits from MCPError."""
|
||||
elicitation = ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Auth required",
|
||||
url="https://example.com/auth",
|
||||
elicitation_id="test-123",
|
||||
)
|
||||
error = UrlElicitationRequiredError([elicitation])
|
||||
|
||||
assert isinstance(error, MCPError)
|
||||
assert isinstance(error, Exception)
|
||||
|
||||
|
||||
def test_url_elicitation_required_error_exception_message() -> None:
|
||||
"""Test that exception message is set correctly."""
|
||||
elicitation = ElicitRequestURLParams(
|
||||
mode="url",
|
||||
message="Auth required",
|
||||
url="https://example.com/auth",
|
||||
elicitation_id="test-123",
|
||||
)
|
||||
error = UrlElicitationRequiredError([elicitation])
|
||||
|
||||
# The exception's string representation should match the message
|
||||
assert str(error) == "URL elicitation required"
|
||||
@@ -0,0 +1,24 @@
|
||||
"""Tests for httpx utility functions."""
|
||||
|
||||
import httpx
|
||||
|
||||
from mcp.shared._httpx_utils import create_mcp_http_client
|
||||
|
||||
|
||||
def test_default_settings():
|
||||
"""Test that default settings are applied correctly."""
|
||||
client = create_mcp_http_client()
|
||||
|
||||
assert client.follow_redirects is True
|
||||
assert client.timeout.connect == 30.0
|
||||
|
||||
|
||||
def test_custom_parameters():
|
||||
"""Test custom headers and timeout are set correctly."""
|
||||
headers = {"Authorization": "Bearer token"}
|
||||
timeout = httpx.Timeout(60.0)
|
||||
|
||||
client = create_mcp_http_client(headers, timeout)
|
||||
|
||||
assert client.headers["Authorization"] == "Bearer token"
|
||||
assert client.timeout.connect == 60.0
|
||||
@@ -0,0 +1,44 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import pytest
|
||||
from logfire.testing import CaptureLogfire
|
||||
|
||||
from mcp import types
|
||||
from mcp.client.client import Client
|
||||
from mcp.server.mcpserver import MCPServer
|
||||
|
||||
pytestmark = pytest.mark.anyio
|
||||
|
||||
|
||||
# Logfire warns about propagated trace context by default (distributed_tracing=None).
|
||||
# This is expected here since we're testing cross-boundary context propagation.
|
||||
@pytest.mark.filterwarnings("ignore::RuntimeWarning")
|
||||
async def test_client_and_server_spans(capfire: CaptureLogfire):
|
||||
"""Verify that calling a tool produces client and server spans with correct attributes."""
|
||||
server = MCPServer("test")
|
||||
|
||||
@server.tool()
|
||||
def greet(name: str) -> str:
|
||||
"""Greet someone."""
|
||||
return f"Hello, {name}!"
|
||||
|
||||
async with Client(server) as client:
|
||||
result = await client.call_tool("greet", {"name": "World"})
|
||||
|
||||
assert isinstance(result.content[0], types.TextContent)
|
||||
assert result.content[0].text == "Hello, World!"
|
||||
|
||||
spans = capfire.exporter.exported_spans_as_dict()
|
||||
span_names = {s["name"] for s in spans}
|
||||
|
||||
assert "MCP send tools/call greet" in span_names
|
||||
assert "MCP handle tools/call greet" in span_names
|
||||
|
||||
client_span = next(s for s in spans if s["name"] == "MCP send tools/call greet")
|
||||
server_span = next(s for s in spans if s["name"] == "MCP handle tools/call greet")
|
||||
|
||||
assert client_span["attributes"]["mcp.method.name"] == "tools/call"
|
||||
assert server_span["attributes"]["mcp.method.name"] == "tools/call"
|
||||
|
||||
# Server span should be in the same trace as the client span (context propagation).
|
||||
assert server_span["context"]["trace_id"] == client_span["context"]["trace_id"]
|
||||
@@ -0,0 +1,264 @@
|
||||
from typing import Any
|
||||
from unittest.mock import patch
|
||||
|
||||
import anyio
|
||||
import pytest
|
||||
|
||||
from mcp import Client, types
|
||||
from mcp.client.session import ClientSession
|
||||
from mcp.server import Server, ServerRequestContext
|
||||
from mcp.server.lowlevel import NotificationOptions
|
||||
from mcp.server.models import InitializationOptions
|
||||
from mcp.server.session import ServerSession
|
||||
from mcp.shared.message import SessionMessage
|
||||
from mcp.shared.session import RequestResponder
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_bidirectional_progress_notifications():
|
||||
"""Test that both client and server can send progress notifications."""
|
||||
# Create memory streams for client/server
|
||||
server_to_client_send, server_to_client_receive = anyio.create_memory_object_stream[SessionMessage](5)
|
||||
client_to_server_send, client_to_server_receive = anyio.create_memory_object_stream[SessionMessage](5)
|
||||
|
||||
# Run a server session so we can send progress updates in tool
|
||||
async def run_server():
|
||||
# Create a server session
|
||||
async with ServerSession(
|
||||
client_to_server_receive,
|
||||
server_to_client_send,
|
||||
InitializationOptions(
|
||||
server_name="ProgressTestServer",
|
||||
server_version="0.1.0",
|
||||
capabilities=server.get_capabilities(NotificationOptions(), {}),
|
||||
),
|
||||
) as server_session:
|
||||
async for message in server_session.incoming_messages:
|
||||
try:
|
||||
await server._handle_message(message, server_session, {})
|
||||
except Exception as e: # pragma: no cover
|
||||
raise e
|
||||
|
||||
# Track progress updates
|
||||
server_progress_updates: list[dict[str, Any]] = []
|
||||
client_progress_updates: list[dict[str, Any]] = []
|
||||
|
||||
# Progress tokens
|
||||
server_progress_token = "server_token_123"
|
||||
client_progress_token = "client_token_456"
|
||||
|
||||
# Register progress handler
|
||||
async def handle_progress(ctx: ServerRequestContext, params: types.ProgressNotificationParams) -> None:
|
||||
server_progress_updates.append(
|
||||
{
|
||||
"token": params.progress_token,
|
||||
"progress": params.progress,
|
||||
"total": params.total,
|
||||
"message": params.message,
|
||||
}
|
||||
)
|
||||
|
||||
# Register list tool handler
|
||||
async def handle_list_tools(
|
||||
ctx: ServerRequestContext, params: types.PaginatedRequestParams | None
|
||||
) -> types.ListToolsResult:
|
||||
return types.ListToolsResult(
|
||||
tools=[
|
||||
types.Tool(
|
||||
name="test_tool",
|
||||
description="A tool that sends progress notifications <o/",
|
||||
input_schema={},
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
# Register tool handler
|
||||
async def handle_call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> types.CallToolResult:
|
||||
# Make sure we received a progress token
|
||||
if params.name == "test_tool":
|
||||
assert params.meta is not None
|
||||
progress_token = params.meta.get("progress_token")
|
||||
assert progress_token is not None
|
||||
assert progress_token == client_progress_token
|
||||
|
||||
# Send progress notifications using ctx.session
|
||||
await ctx.session.send_progress_notification(
|
||||
progress_token=progress_token,
|
||||
progress=0.25,
|
||||
total=1.0,
|
||||
message="Server progress 25%",
|
||||
)
|
||||
|
||||
await ctx.session.send_progress_notification(
|
||||
progress_token=progress_token,
|
||||
progress=0.5,
|
||||
total=1.0,
|
||||
message="Server progress 50%",
|
||||
)
|
||||
|
||||
await ctx.session.send_progress_notification(
|
||||
progress_token=progress_token,
|
||||
progress=1.0,
|
||||
total=1.0,
|
||||
message="Server progress 100%",
|
||||
)
|
||||
|
||||
return types.CallToolResult(content=[types.TextContent(type="text", text="Tool executed successfully")])
|
||||
|
||||
raise ValueError(f"Unknown tool: {params.name}") # pragma: no cover
|
||||
|
||||
# Create a server with progress capability
|
||||
server = Server(
|
||||
name="ProgressTestServer",
|
||||
on_progress=handle_progress,
|
||||
on_list_tools=handle_list_tools,
|
||||
on_call_tool=handle_call_tool,
|
||||
)
|
||||
|
||||
# Client message handler to store progress notifications
|
||||
async def handle_client_message(
|
||||
message: RequestResponder[types.ServerRequest, types.ClientResult] | types.ServerNotification | Exception,
|
||||
) -> None:
|
||||
if isinstance(message, Exception): # pragma: no cover
|
||||
raise message
|
||||
|
||||
if isinstance(message, types.ServerNotification): # pragma: no branch
|
||||
if isinstance(message, types.ProgressNotification): # pragma: no branch
|
||||
params = message.params
|
||||
client_progress_updates.append(
|
||||
{
|
||||
"token": params.progress_token,
|
||||
"progress": params.progress,
|
||||
"total": params.total,
|
||||
"message": params.message,
|
||||
}
|
||||
)
|
||||
|
||||
# Test using client
|
||||
async with (
|
||||
ClientSession(
|
||||
server_to_client_receive,
|
||||
client_to_server_send,
|
||||
message_handler=handle_client_message,
|
||||
) as client_session,
|
||||
anyio.create_task_group() as tg,
|
||||
):
|
||||
# Start the server in a background task
|
||||
tg.start_soon(run_server)
|
||||
|
||||
# Initialize the client connection
|
||||
await client_session.initialize()
|
||||
|
||||
# Call list_tools with progress token
|
||||
await client_session.list_tools()
|
||||
|
||||
# Call test_tool with progress token
|
||||
await client_session.call_tool("test_tool", meta={"progress_token": client_progress_token})
|
||||
|
||||
# Send progress notifications from client to server
|
||||
await client_session.send_progress_notification(
|
||||
progress_token=server_progress_token,
|
||||
progress=0.33,
|
||||
total=1.0,
|
||||
message="Client progress 33%",
|
||||
)
|
||||
|
||||
await client_session.send_progress_notification(
|
||||
progress_token=server_progress_token,
|
||||
progress=0.66,
|
||||
total=1.0,
|
||||
message="Client progress 66%",
|
||||
)
|
||||
|
||||
await client_session.send_progress_notification(
|
||||
progress_token=server_progress_token,
|
||||
progress=1.0,
|
||||
total=1.0,
|
||||
message="Client progress 100%",
|
||||
)
|
||||
|
||||
# Wait and exit
|
||||
await anyio.sleep(0.5)
|
||||
tg.cancel_scope.cancel()
|
||||
|
||||
# Verify client received progress updates from server
|
||||
assert len(client_progress_updates) == 3
|
||||
assert client_progress_updates[0]["token"] == client_progress_token
|
||||
assert client_progress_updates[0]["progress"] == 0.25
|
||||
assert client_progress_updates[0]["message"] == "Server progress 25%"
|
||||
assert client_progress_updates[2]["progress"] == 1.0
|
||||
|
||||
# Verify server received progress updates from client
|
||||
assert len(server_progress_updates) == 3
|
||||
assert server_progress_updates[0]["token"] == server_progress_token
|
||||
assert server_progress_updates[0]["progress"] == 0.33
|
||||
assert server_progress_updates[0]["message"] == "Client progress 33%"
|
||||
assert server_progress_updates[2]["progress"] == 1.0
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_progress_callback_exception_logging():
|
||||
"""Test that exceptions in progress callbacks are logged and \
|
||||
don't crash the session."""
|
||||
# Track logged warnings
|
||||
logged_errors: list[str] = []
|
||||
|
||||
def mock_log_exception(msg: str, *args: Any, **kwargs: Any) -> None:
|
||||
logged_errors.append(msg % args if args else msg)
|
||||
|
||||
# Create a progress callback that raises an exception
|
||||
async def failing_progress_callback(progress: float, total: float | None, message: str | None) -> None:
|
||||
raise ValueError("Progress callback failed!")
|
||||
|
||||
# Create a server with a tool that sends progress notifications
|
||||
async def handle_call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> types.CallToolResult:
|
||||
if params.name == "progress_tool":
|
||||
assert ctx.request_id is not None
|
||||
# Send a progress notification
|
||||
await ctx.session.send_progress_notification(
|
||||
progress_token=ctx.request_id,
|
||||
progress=50.0,
|
||||
total=100.0,
|
||||
message="Halfway done",
|
||||
)
|
||||
return types.CallToolResult(content=[types.TextContent(type="text", text="progress_result")])
|
||||
raise ValueError(f"Unknown tool: {params.name}") # pragma: no cover
|
||||
|
||||
async def handle_list_tools(
|
||||
ctx: ServerRequestContext, params: types.PaginatedRequestParams | None
|
||||
) -> types.ListToolsResult:
|
||||
return types.ListToolsResult(
|
||||
tools=[
|
||||
types.Tool(
|
||||
name="progress_tool",
|
||||
description="A tool that sends progress notifications",
|
||||
input_schema={},
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
server = Server(
|
||||
name="TestProgressServer",
|
||||
on_call_tool=handle_call_tool,
|
||||
on_list_tools=handle_list_tools,
|
||||
)
|
||||
|
||||
# Test with mocked logging
|
||||
with patch("mcp.shared.session.logging.exception", side_effect=mock_log_exception):
|
||||
async with Client(server) as client:
|
||||
# Call tool with a failing progress callback
|
||||
result = await client.call_tool(
|
||||
"progress_tool",
|
||||
arguments={},
|
||||
progress_callback=failing_progress_callback,
|
||||
)
|
||||
|
||||
# Verify the request completed successfully despite the callback failure
|
||||
assert len(result.content) == 1
|
||||
content = result.content[0]
|
||||
assert isinstance(content, types.TextContent)
|
||||
assert content.text == "progress_result"
|
||||
|
||||
# Check that a warning was logged for the progress callback exception
|
||||
assert len(logged_errors) > 0
|
||||
assert any("Progress callback raised an exception" in warning for warning in logged_errors)
|
||||
@@ -0,0 +1,418 @@
|
||||
import anyio
|
||||
import pytest
|
||||
|
||||
from mcp import Client, types
|
||||
from mcp.client.session import ClientSession
|
||||
from mcp.server import Server, ServerRequestContext
|
||||
from mcp.shared.exceptions import MCPError
|
||||
from mcp.shared.memory import create_client_server_memory_streams
|
||||
from mcp.shared.message import SessionMessage
|
||||
from mcp.shared.session import RequestResponder
|
||||
from mcp.types import (
|
||||
PARSE_ERROR,
|
||||
CancelledNotification,
|
||||
CancelledNotificationParams,
|
||||
ClientResult,
|
||||
EmptyResult,
|
||||
ErrorData,
|
||||
JSONRPCError,
|
||||
JSONRPCRequest,
|
||||
JSONRPCResponse,
|
||||
ServerNotification,
|
||||
ServerRequest,
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_in_flight_requests_cleared_after_completion():
|
||||
"""Verify that _in_flight is empty after all requests complete."""
|
||||
server = Server(name="test server")
|
||||
async with Client(server) as client:
|
||||
# Send a request and wait for response
|
||||
response = await client.send_ping()
|
||||
assert isinstance(response, EmptyResult)
|
||||
|
||||
# Verify _in_flight is empty
|
||||
assert len(client.session._in_flight) == 0
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_request_cancellation():
|
||||
"""Test that requests can be cancelled while in-flight."""
|
||||
ev_tool_called = anyio.Event()
|
||||
ev_cancelled = anyio.Event()
|
||||
request_id = None
|
||||
|
||||
# Create a server with a slow tool
|
||||
async def handle_call_tool(ctx: ServerRequestContext, params: types.CallToolRequestParams) -> types.CallToolResult:
|
||||
nonlocal request_id, ev_tool_called
|
||||
if params.name == "slow_tool":
|
||||
request_id = ctx.request_id
|
||||
ev_tool_called.set()
|
||||
await anyio.sleep(10) # Long enough to ensure we can cancel
|
||||
return types.CallToolResult(content=[]) # pragma: no cover
|
||||
raise ValueError(f"Unknown tool: {params.name}") # pragma: no cover
|
||||
|
||||
async def handle_list_tools(
|
||||
ctx: ServerRequestContext, params: types.PaginatedRequestParams | None
|
||||
) -> types.ListToolsResult:
|
||||
raise NotImplementedError
|
||||
|
||||
server = Server(
|
||||
name="TestSessionServer",
|
||||
on_call_tool=handle_call_tool,
|
||||
on_list_tools=handle_list_tools,
|
||||
)
|
||||
|
||||
async def make_request(client: Client):
|
||||
nonlocal ev_cancelled
|
||||
try:
|
||||
await client.session.send_request(
|
||||
types.CallToolRequest(
|
||||
params=types.CallToolRequestParams(name="slow_tool", arguments={}),
|
||||
),
|
||||
types.CallToolResult,
|
||||
)
|
||||
pytest.fail("Request should have been cancelled") # pragma: no cover
|
||||
except MCPError as e:
|
||||
# Expected - request was cancelled
|
||||
assert "Request cancelled" in str(e)
|
||||
ev_cancelled.set()
|
||||
|
||||
async with Client(server) as client:
|
||||
async with anyio.create_task_group() as tg: # pragma: no branch
|
||||
tg.start_soon(make_request, client)
|
||||
|
||||
# Wait for the request to be in-flight
|
||||
with anyio.fail_after(1): # Timeout after 1 second
|
||||
await ev_tool_called.wait()
|
||||
|
||||
# Send cancellation notification
|
||||
assert request_id is not None
|
||||
await client.session.send_notification(
|
||||
CancelledNotification(params=CancelledNotificationParams(request_id=request_id))
|
||||
)
|
||||
|
||||
# Give cancellation time to process
|
||||
with anyio.fail_after(1): # pragma: no branch
|
||||
await ev_cancelled.wait()
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_response_id_type_mismatch_string_to_int():
|
||||
"""Test that responses with string IDs are correctly matched to requests sent with
|
||||
integer IDs.
|
||||
|
||||
This handles the case where a server returns "id": "0" (string) but the client
|
||||
sent "id": 0 (integer). Without ID type normalization, this would cause a timeout.
|
||||
"""
|
||||
ev_response_received = anyio.Event()
|
||||
result_holder: list[types.EmptyResult] = []
|
||||
|
||||
async with create_client_server_memory_streams() as (client_streams, server_streams):
|
||||
client_read, client_write = client_streams
|
||||
server_read, server_write = server_streams
|
||||
|
||||
async def mock_server():
|
||||
"""Receive a request and respond with a string ID instead of integer."""
|
||||
message = await server_read.receive()
|
||||
assert isinstance(message, SessionMessage)
|
||||
root = message.message
|
||||
assert isinstance(root, JSONRPCRequest)
|
||||
# Get the original request ID (which is an integer)
|
||||
request_id = root.id
|
||||
assert isinstance(request_id, int), f"Expected int, got {type(request_id)}"
|
||||
|
||||
# Respond with the ID as a string (simulating a buggy server)
|
||||
response = JSONRPCResponse(
|
||||
jsonrpc="2.0",
|
||||
id=str(request_id), # Convert to string to simulate mismatch
|
||||
result={},
|
||||
)
|
||||
await server_write.send(SessionMessage(message=response))
|
||||
|
||||
async def make_request(client_session: ClientSession):
|
||||
nonlocal result_holder
|
||||
# Send a ping request (uses integer ID internally)
|
||||
result = await client_session.send_ping()
|
||||
result_holder.append(result)
|
||||
ev_response_received.set()
|
||||
|
||||
async with (
|
||||
anyio.create_task_group() as tg,
|
||||
ClientSession(read_stream=client_read, write_stream=client_write) as client_session,
|
||||
):
|
||||
tg.start_soon(mock_server)
|
||||
tg.start_soon(make_request, client_session)
|
||||
|
||||
with anyio.fail_after(2): # pragma: no branch
|
||||
await ev_response_received.wait()
|
||||
|
||||
assert len(result_holder) == 1
|
||||
assert isinstance(result_holder[0], EmptyResult)
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_error_response_id_type_mismatch_string_to_int():
|
||||
"""Test that error responses with string IDs are correctly matched to requests
|
||||
sent with integer IDs.
|
||||
|
||||
This handles the case where a server returns an error with "id": "0" (string)
|
||||
but the client sent "id": 0 (integer).
|
||||
"""
|
||||
ev_error_received = anyio.Event()
|
||||
error_holder: list[MCPError | Exception] = []
|
||||
|
||||
async with create_client_server_memory_streams() as (client_streams, server_streams):
|
||||
client_read, client_write = client_streams
|
||||
server_read, server_write = server_streams
|
||||
|
||||
async def mock_server():
|
||||
"""Receive a request and respond with an error using a string ID."""
|
||||
message = await server_read.receive()
|
||||
assert isinstance(message, SessionMessage)
|
||||
root = message.message
|
||||
assert isinstance(root, JSONRPCRequest)
|
||||
request_id = root.id
|
||||
assert isinstance(request_id, int)
|
||||
|
||||
# Respond with an error, using the ID as a string
|
||||
error_response = JSONRPCError(
|
||||
jsonrpc="2.0",
|
||||
id=str(request_id), # Convert to string to simulate mismatch
|
||||
error=ErrorData(code=-32600, message="Test error"),
|
||||
)
|
||||
await server_write.send(SessionMessage(message=error_response))
|
||||
|
||||
async def make_request(client_session: ClientSession):
|
||||
nonlocal error_holder
|
||||
try:
|
||||
await client_session.send_ping()
|
||||
pytest.fail("Expected MCPError to be raised") # pragma: no cover
|
||||
except MCPError as e:
|
||||
error_holder.append(e)
|
||||
ev_error_received.set()
|
||||
|
||||
async with (
|
||||
anyio.create_task_group() as tg,
|
||||
ClientSession(read_stream=client_read, write_stream=client_write) as client_session,
|
||||
):
|
||||
tg.start_soon(mock_server)
|
||||
tg.start_soon(make_request, client_session)
|
||||
|
||||
with anyio.fail_after(2): # pragma: no branch
|
||||
await ev_error_received.wait()
|
||||
|
||||
assert len(error_holder) == 1
|
||||
assert "Test error" in str(error_holder[0])
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_response_id_non_numeric_string_no_match():
|
||||
"""Test that responses with non-numeric string IDs don't incorrectly match
|
||||
integer request IDs.
|
||||
|
||||
If a server returns "id": "abc" (non-numeric string), it should not match
|
||||
a request sent with "id": 0 (integer).
|
||||
"""
|
||||
ev_timeout = anyio.Event()
|
||||
|
||||
async with create_client_server_memory_streams() as (client_streams, server_streams):
|
||||
client_read, client_write = client_streams
|
||||
server_read, server_write = server_streams
|
||||
|
||||
async def mock_server():
|
||||
"""Receive a request and respond with a non-numeric string ID."""
|
||||
message = await server_read.receive()
|
||||
assert isinstance(message, SessionMessage)
|
||||
|
||||
# Respond with a non-numeric string ID (should not match)
|
||||
response = JSONRPCResponse(
|
||||
jsonrpc="2.0",
|
||||
id="not_a_number", # Non-numeric string
|
||||
result={},
|
||||
)
|
||||
await server_write.send(SessionMessage(message=response))
|
||||
|
||||
async def make_request(client_session: ClientSession):
|
||||
try:
|
||||
# Use a short timeout since we expect this to fail
|
||||
await client_session.send_request(
|
||||
types.PingRequest(),
|
||||
types.EmptyResult,
|
||||
request_read_timeout_seconds=0.5,
|
||||
)
|
||||
pytest.fail("Expected timeout") # pragma: no cover
|
||||
except MCPError as e:
|
||||
assert "Timed out" in str(e)
|
||||
ev_timeout.set()
|
||||
|
||||
async with (
|
||||
anyio.create_task_group() as tg,
|
||||
ClientSession(read_stream=client_read, write_stream=client_write) as client_session,
|
||||
):
|
||||
tg.start_soon(mock_server)
|
||||
tg.start_soon(make_request, client_session)
|
||||
|
||||
with anyio.fail_after(2): # pragma: no branch
|
||||
await ev_timeout.wait()
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_connection_closed():
|
||||
"""Test that pending requests are cancelled when the connection is closed remotely."""
|
||||
|
||||
ev_closed = anyio.Event()
|
||||
ev_response = anyio.Event()
|
||||
|
||||
async with create_client_server_memory_streams() as (client_streams, server_streams):
|
||||
client_read, client_write = client_streams
|
||||
server_read, server_write = server_streams
|
||||
|
||||
async def make_request(client_session: ClientSession):
|
||||
"""Send a request in a separate task"""
|
||||
nonlocal ev_response
|
||||
try:
|
||||
# any request will do
|
||||
await client_session.initialize()
|
||||
pytest.fail("Request should have errored") # pragma: no cover
|
||||
except MCPError as e:
|
||||
# Expected - request errored
|
||||
assert "Connection closed" in str(e)
|
||||
ev_response.set()
|
||||
|
||||
async def mock_server():
|
||||
"""Wait for a request, then close the connection"""
|
||||
nonlocal ev_closed
|
||||
# Wait for a request
|
||||
await server_read.receive()
|
||||
# Close the connection, as if the server exited
|
||||
server_write.close()
|
||||
server_read.close()
|
||||
ev_closed.set()
|
||||
|
||||
async with (
|
||||
anyio.create_task_group() as tg,
|
||||
ClientSession(read_stream=client_read, write_stream=client_write) as client_session,
|
||||
):
|
||||
tg.start_soon(make_request, client_session)
|
||||
tg.start_soon(mock_server)
|
||||
|
||||
with anyio.fail_after(1):
|
||||
await ev_closed.wait()
|
||||
with anyio.fail_after(1): # pragma: no branch
|
||||
await ev_response.wait()
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_null_id_error_surfaced_via_message_handler():
|
||||
"""Test that a JSONRPCError with id=None is surfaced to the message handler.
|
||||
|
||||
Per JSON-RPC 2.0, error responses use id=null when the request id could not
|
||||
be determined (e.g., parse errors). These cannot be correlated to any pending
|
||||
request, so they are forwarded to the message handler as MCPError.
|
||||
"""
|
||||
ev_error_received = anyio.Event()
|
||||
error_holder: list[MCPError] = []
|
||||
|
||||
async def capture_errors(
|
||||
message: RequestResponder[ServerRequest, ClientResult] | ServerNotification | Exception,
|
||||
) -> None:
|
||||
assert isinstance(message, MCPError)
|
||||
error_holder.append(message)
|
||||
ev_error_received.set()
|
||||
|
||||
sent_error = ErrorData(code=PARSE_ERROR, message="Parse error")
|
||||
|
||||
async with create_client_server_memory_streams() as (client_streams, server_streams):
|
||||
client_read, client_write = client_streams
|
||||
_server_read, server_write = server_streams
|
||||
|
||||
async def mock_server():
|
||||
"""Send a null-id error (simulating a parse error)."""
|
||||
error_response = JSONRPCError(jsonrpc="2.0", id=None, error=sent_error)
|
||||
await server_write.send(SessionMessage(message=error_response))
|
||||
|
||||
async with (
|
||||
anyio.create_task_group() as tg,
|
||||
ClientSession(
|
||||
read_stream=client_read,
|
||||
write_stream=client_write,
|
||||
message_handler=capture_errors,
|
||||
) as _client_session,
|
||||
):
|
||||
tg.start_soon(mock_server)
|
||||
|
||||
with anyio.fail_after(2): # pragma: no branch
|
||||
await ev_error_received.wait()
|
||||
|
||||
assert len(error_holder) == 1
|
||||
assert error_holder[0].error == sent_error
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_null_id_error_does_not_affect_pending_request():
|
||||
"""Test that a null-id error doesn't interfere with an in-flight request.
|
||||
|
||||
When a null-id error arrives while a request is pending, the error should
|
||||
go to the message handler and the pending request should still complete
|
||||
normally with its own response.
|
||||
"""
|
||||
ev_error_received = anyio.Event()
|
||||
ev_response_received = anyio.Event()
|
||||
error_holder: list[MCPError] = []
|
||||
result_holder: list[EmptyResult] = []
|
||||
|
||||
async def capture_errors(
|
||||
message: RequestResponder[ServerRequest, ClientResult] | ServerNotification | Exception,
|
||||
) -> None:
|
||||
assert isinstance(message, MCPError)
|
||||
error_holder.append(message)
|
||||
ev_error_received.set()
|
||||
|
||||
sent_error = ErrorData(code=PARSE_ERROR, message="Parse error")
|
||||
|
||||
async with create_client_server_memory_streams() as (client_streams, server_streams):
|
||||
client_read, client_write = client_streams
|
||||
server_read, server_write = server_streams
|
||||
|
||||
async def mock_server():
|
||||
"""Read a request, inject a null-id error, then respond normally."""
|
||||
message = await server_read.receive()
|
||||
assert isinstance(message, SessionMessage)
|
||||
assert isinstance(message.message, JSONRPCRequest)
|
||||
request_id = message.message.id
|
||||
|
||||
# First, send a null-id error (should go to message handler)
|
||||
await server_write.send(SessionMessage(message=JSONRPCError(jsonrpc="2.0", id=None, error=sent_error)))
|
||||
|
||||
# Then, respond normally to the pending request
|
||||
await server_write.send(SessionMessage(message=JSONRPCResponse(jsonrpc="2.0", id=request_id, result={})))
|
||||
|
||||
async def make_request(client_session: ClientSession):
|
||||
result = await client_session.send_ping()
|
||||
result_holder.append(result)
|
||||
ev_response_received.set()
|
||||
|
||||
async with (
|
||||
anyio.create_task_group() as tg,
|
||||
ClientSession(
|
||||
read_stream=client_read,
|
||||
write_stream=client_write,
|
||||
message_handler=capture_errors,
|
||||
) as client_session,
|
||||
):
|
||||
tg.start_soon(mock_server)
|
||||
tg.start_soon(make_request, client_session)
|
||||
|
||||
with anyio.fail_after(2): # pragma: no branch
|
||||
await ev_error_received.wait()
|
||||
await ev_response_received.wait()
|
||||
|
||||
# Null-id error reached the message handler
|
||||
assert len(error_holder) == 1
|
||||
assert error_holder[0].error == sent_error
|
||||
|
||||
# Pending request completed successfully
|
||||
assert len(result_holder) == 1
|
||||
assert isinstance(result_holder[0], EmptyResult)
|
||||
@@ -0,0 +1,631 @@
|
||||
import json
|
||||
import multiprocessing
|
||||
import socket
|
||||
from collections.abc import AsyncGenerator, Generator
|
||||
from typing import Any
|
||||
from unittest.mock import AsyncMock, MagicMock, Mock, patch
|
||||
from urllib.parse import urlparse
|
||||
|
||||
import anyio
|
||||
import httpx
|
||||
import pytest
|
||||
import uvicorn
|
||||
from httpx_sse import ServerSentEvent
|
||||
from inline_snapshot import snapshot
|
||||
from starlette.applications import Starlette
|
||||
from starlette.requests import Request
|
||||
from starlette.responses import Response
|
||||
from starlette.routing import Mount, Route
|
||||
|
||||
import mcp.client.sse
|
||||
from mcp import types
|
||||
from mcp.client.session import ClientSession
|
||||
from mcp.client.sse import _extract_session_id_from_endpoint, sse_client
|
||||
from mcp.server import Server, ServerRequestContext
|
||||
from mcp.server.sse import SseServerTransport
|
||||
from mcp.server.transport_security import TransportSecuritySettings
|
||||
from mcp.shared.exceptions import MCPError
|
||||
from mcp.types import (
|
||||
CallToolRequestParams,
|
||||
CallToolResult,
|
||||
EmptyResult,
|
||||
Implementation,
|
||||
InitializeResult,
|
||||
JSONRPCResponse,
|
||||
ListToolsResult,
|
||||
PaginatedRequestParams,
|
||||
ReadResourceRequestParams,
|
||||
ReadResourceResult,
|
||||
ServerCapabilities,
|
||||
TextContent,
|
||||
TextResourceContents,
|
||||
Tool,
|
||||
)
|
||||
from tests.test_helpers import wait_for_server
|
||||
|
||||
SERVER_NAME = "test_server_for_SSE"
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def server_port() -> int:
|
||||
with socket.socket() as s:
|
||||
s.bind(("127.0.0.1", 0))
|
||||
return s.getsockname()[1]
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def server_url(server_port: int) -> str:
|
||||
return f"http://127.0.0.1:{server_port}"
|
||||
|
||||
|
||||
async def _handle_read_resource( # pragma: no cover
|
||||
ctx: ServerRequestContext, params: ReadResourceRequestParams
|
||||
) -> ReadResourceResult:
|
||||
uri = str(params.uri)
|
||||
parsed = urlparse(uri)
|
||||
if parsed.scheme == "foobar":
|
||||
text = f"Read {parsed.netloc}"
|
||||
elif parsed.scheme == "slow":
|
||||
await anyio.sleep(2.0)
|
||||
text = f"Slow response from {parsed.netloc}"
|
||||
else:
|
||||
raise MCPError(code=404, message="OOPS! no resource with that URI was found")
|
||||
return ReadResourceResult(contents=[TextResourceContents(uri=uri, text=text, mime_type="text/plain")])
|
||||
|
||||
|
||||
async def _handle_list_tools( # pragma: no cover
|
||||
ctx: ServerRequestContext, params: PaginatedRequestParams | None
|
||||
) -> ListToolsResult:
|
||||
return ListToolsResult(
|
||||
tools=[
|
||||
Tool(
|
||||
name="test_tool",
|
||||
description="A test tool",
|
||||
input_schema={"type": "object", "properties": {}},
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
async def _handle_call_tool( # pragma: no cover
|
||||
ctx: ServerRequestContext, params: CallToolRequestParams
|
||||
) -> CallToolResult:
|
||||
return CallToolResult(content=[TextContent(type="text", text=f"Called {params.name}")])
|
||||
|
||||
|
||||
def _create_server() -> Server: # pragma: no cover
|
||||
return Server(
|
||||
SERVER_NAME,
|
||||
on_read_resource=_handle_read_resource,
|
||||
on_list_tools=_handle_list_tools,
|
||||
on_call_tool=_handle_call_tool,
|
||||
)
|
||||
|
||||
|
||||
# Test fixtures
|
||||
def make_server_app() -> Starlette: # pragma: no cover
|
||||
"""Create test Starlette app with SSE transport"""
|
||||
# Configure security with allowed hosts/origins for testing
|
||||
security_settings = TransportSecuritySettings(
|
||||
allowed_hosts=["127.0.0.1:*", "localhost:*"], allowed_origins=["http://127.0.0.1:*", "http://localhost:*"]
|
||||
)
|
||||
sse = SseServerTransport("/messages/", security_settings=security_settings)
|
||||
server = _create_server()
|
||||
|
||||
async def handle_sse(request: Request) -> Response:
|
||||
async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
|
||||
await server.run(streams[0], streams[1], server.create_initialization_options())
|
||||
return Response()
|
||||
|
||||
app = Starlette(
|
||||
routes=[
|
||||
Route("/sse", endpoint=handle_sse),
|
||||
Mount("/messages/", app=sse.handle_post_message),
|
||||
]
|
||||
)
|
||||
|
||||
return app
|
||||
|
||||
|
||||
def run_server(server_port: int) -> None: # pragma: no cover
|
||||
app = make_server_app()
|
||||
server = uvicorn.Server(config=uvicorn.Config(app=app, host="127.0.0.1", port=server_port, log_level="error"))
|
||||
print(f"starting server on {server_port}")
|
||||
server.run()
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def server(server_port: int) -> Generator[None, None, None]:
|
||||
proc = multiprocessing.Process(target=run_server, kwargs={"server_port": server_port}, daemon=True)
|
||||
print("starting process")
|
||||
proc.start()
|
||||
|
||||
# Wait for server to be running
|
||||
print("waiting for server to start")
|
||||
wait_for_server(server_port)
|
||||
|
||||
yield
|
||||
|
||||
print("killing server")
|
||||
# Signal the server to stop
|
||||
proc.kill()
|
||||
proc.join(timeout=2)
|
||||
if proc.is_alive(): # pragma: no cover
|
||||
print("server process failed to terminate")
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
async def http_client(server: None, server_url: str) -> AsyncGenerator[httpx.AsyncClient, None]:
|
||||
"""Create test client"""
|
||||
async with httpx.AsyncClient(base_url=server_url) as client:
|
||||
yield client
|
||||
|
||||
|
||||
# Tests
|
||||
@pytest.mark.anyio
|
||||
async def test_raw_sse_connection(http_client: httpx.AsyncClient) -> None:
|
||||
"""Test the SSE connection establishment simply with an HTTP client."""
|
||||
async with anyio.create_task_group():
|
||||
|
||||
async def connection_test() -> None:
|
||||
async with http_client.stream("GET", "/sse") as response:
|
||||
assert response.status_code == 200
|
||||
assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
|
||||
|
||||
line_number = 0
|
||||
async for line in response.aiter_lines(): # pragma: no branch
|
||||
if line_number == 0:
|
||||
assert line == "event: endpoint"
|
||||
elif line_number == 1:
|
||||
assert line.startswith("data: /messages/?session_id=")
|
||||
else:
|
||||
return
|
||||
line_number += 1
|
||||
|
||||
# Add timeout to prevent test from hanging if it fails
|
||||
with anyio.fail_after(3):
|
||||
await connection_test()
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_client_basic_connection(server: None, server_url: str) -> None:
|
||||
async with sse_client(server_url + "/sse") as streams:
|
||||
async with ClientSession(*streams) as session:
|
||||
# Test initialization
|
||||
result = await session.initialize()
|
||||
assert isinstance(result, InitializeResult)
|
||||
assert result.server_info.name == SERVER_NAME
|
||||
|
||||
# Test ping
|
||||
ping_result = await session.send_ping()
|
||||
assert isinstance(ping_result, EmptyResult)
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_client_on_session_created(server: None, server_url: str) -> None:
|
||||
captured: list[str] = []
|
||||
|
||||
async with sse_client(server_url + "/sse", on_session_created=captured.append) as streams:
|
||||
async with ClientSession(*streams) as session:
|
||||
result = await session.initialize()
|
||||
assert isinstance(result, InitializeResult)
|
||||
# Callback fires when the endpoint event arrives, before sse_client yields.
|
||||
assert len(captured) == 1
|
||||
assert len(captured[0]) > 0
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"endpoint_url,expected",
|
||||
[
|
||||
("/messages?sessionId=abc123", "abc123"),
|
||||
("/messages?session_id=def456", "def456"),
|
||||
("/messages?sessionId=abc&session_id=def", "abc"),
|
||||
("/messages?other=value", None),
|
||||
("/messages", None),
|
||||
("", None),
|
||||
],
|
||||
)
|
||||
def test_extract_session_id_from_endpoint(endpoint_url: str, expected: str | None) -> None:
|
||||
assert _extract_session_id_from_endpoint(endpoint_url) == expected
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_client_on_session_created_not_called_when_no_session_id(
|
||||
server: None, server_url: str, monkeypatch: pytest.MonkeyPatch
|
||||
) -> None:
|
||||
callback_mock = Mock()
|
||||
|
||||
def mock_extract(url: str) -> None:
|
||||
return None
|
||||
|
||||
monkeypatch.setattr(mcp.client.sse, "_extract_session_id_from_endpoint", mock_extract)
|
||||
|
||||
async with sse_client(server_url + "/sse", on_session_created=callback_mock) as streams:
|
||||
async with ClientSession(*streams) as session:
|
||||
result = await session.initialize()
|
||||
assert isinstance(result, InitializeResult)
|
||||
# Callback would have fired by now (endpoint event arrives before
|
||||
# sse_client yields); if it hasn't, it won't.
|
||||
callback_mock.assert_not_called()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
async def initialized_sse_client_session(server: None, server_url: str) -> AsyncGenerator[ClientSession, None]:
|
||||
async with sse_client(server_url + "/sse", sse_read_timeout=0.5) as streams:
|
||||
async with ClientSession(*streams) as session:
|
||||
await session.initialize()
|
||||
yield session
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_client_happy_request_and_response(
|
||||
initialized_sse_client_session: ClientSession,
|
||||
) -> None:
|
||||
session = initialized_sse_client_session
|
||||
response = await session.read_resource(uri="foobar://should-work")
|
||||
assert len(response.contents) == 1
|
||||
assert isinstance(response.contents[0], TextResourceContents)
|
||||
assert response.contents[0].text == "Read should-work"
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_client_exception_handling(
|
||||
initialized_sse_client_session: ClientSession,
|
||||
) -> None:
|
||||
session = initialized_sse_client_session
|
||||
with pytest.raises(MCPError, match="OOPS! no resource with that URI was found"):
|
||||
await session.read_resource(uri="xxx://will-not-work")
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
@pytest.mark.skip("this test highlights a possible bug in SSE read timeout exception handling")
|
||||
async def test_sse_client_timeout( # pragma: no cover
|
||||
initialized_sse_client_session: ClientSession,
|
||||
) -> None:
|
||||
session = initialized_sse_client_session
|
||||
|
||||
# sanity check that normal, fast responses are working
|
||||
response = await session.read_resource(uri="foobar://1")
|
||||
assert isinstance(response, ReadResourceResult)
|
||||
|
||||
with anyio.move_on_after(3):
|
||||
with pytest.raises(MCPError, match="Read timed out"):
|
||||
response = await session.read_resource(uri="slow://2")
|
||||
# we should receive an error here
|
||||
return
|
||||
|
||||
pytest.fail("the client should have timed out and returned an error already")
|
||||
|
||||
|
||||
def run_mounted_server(server_port: int) -> None: # pragma: no cover
|
||||
app = make_server_app()
|
||||
main_app = Starlette(routes=[Mount("/mounted_app", app=app)])
|
||||
server = uvicorn.Server(config=uvicorn.Config(app=main_app, host="127.0.0.1", port=server_port, log_level="error"))
|
||||
print(f"starting server on {server_port}")
|
||||
server.run()
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def mounted_server(server_port: int) -> Generator[None, None, None]:
|
||||
proc = multiprocessing.Process(target=run_mounted_server, kwargs={"server_port": server_port}, daemon=True)
|
||||
print("starting process")
|
||||
proc.start()
|
||||
|
||||
# Wait for server to be running
|
||||
print("waiting for server to start")
|
||||
wait_for_server(server_port)
|
||||
|
||||
yield
|
||||
|
||||
print("killing server")
|
||||
# Signal the server to stop
|
||||
proc.kill()
|
||||
proc.join(timeout=2)
|
||||
if proc.is_alive(): # pragma: no cover
|
||||
print("server process failed to terminate")
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_client_basic_connection_mounted_app(mounted_server: None, server_url: str) -> None:
|
||||
async with sse_client(server_url + "/mounted_app/sse") as streams:
|
||||
async with ClientSession(*streams) as session:
|
||||
# Test initialization
|
||||
result = await session.initialize()
|
||||
assert isinstance(result, InitializeResult)
|
||||
assert result.server_info.name == SERVER_NAME
|
||||
|
||||
# Test ping
|
||||
ping_result = await session.send_ping()
|
||||
assert isinstance(ping_result, EmptyResult)
|
||||
|
||||
|
||||
async def _handle_context_call_tool( # pragma: no cover
|
||||
ctx: ServerRequestContext, params: CallToolRequestParams
|
||||
) -> CallToolResult:
|
||||
headers_info: dict[str, Any] = {}
|
||||
if ctx.request:
|
||||
headers_info = dict(ctx.request.headers)
|
||||
|
||||
if params.name == "echo_headers":
|
||||
return CallToolResult(content=[TextContent(type="text", text=json.dumps(headers_info))])
|
||||
elif params.name == "echo_context":
|
||||
context_data = {
|
||||
"request_id": (params.arguments or {}).get("request_id"),
|
||||
"headers": headers_info,
|
||||
}
|
||||
return CallToolResult(content=[TextContent(type="text", text=json.dumps(context_data))])
|
||||
|
||||
return CallToolResult(content=[TextContent(type="text", text=f"Called {params.name}")])
|
||||
|
||||
|
||||
async def _handle_context_list_tools( # pragma: no cover
|
||||
ctx: ServerRequestContext, params: PaginatedRequestParams | None
|
||||
) -> ListToolsResult:
|
||||
return ListToolsResult(
|
||||
tools=[
|
||||
Tool(
|
||||
name="echo_headers",
|
||||
description="Echoes request headers",
|
||||
input_schema={"type": "object", "properties": {}},
|
||||
),
|
||||
Tool(
|
||||
name="echo_context",
|
||||
description="Echoes request context",
|
||||
input_schema={
|
||||
"type": "object",
|
||||
"properties": {"request_id": {"type": "string"}},
|
||||
"required": ["request_id"],
|
||||
},
|
||||
),
|
||||
]
|
||||
)
|
||||
|
||||
|
||||
def run_context_server(server_port: int) -> None: # pragma: no cover
|
||||
"""Run a server that captures request context"""
|
||||
# Configure security with allowed hosts/origins for testing
|
||||
security_settings = TransportSecuritySettings(
|
||||
allowed_hosts=["127.0.0.1:*", "localhost:*"], allowed_origins=["http://127.0.0.1:*", "http://localhost:*"]
|
||||
)
|
||||
sse = SseServerTransport("/messages/", security_settings=security_settings)
|
||||
context_server = Server(
|
||||
"request_context_server",
|
||||
on_call_tool=_handle_context_call_tool,
|
||||
on_list_tools=_handle_context_list_tools,
|
||||
)
|
||||
|
||||
async def handle_sse(request: Request) -> Response:
|
||||
async with sse.connect_sse(request.scope, request.receive, request._send) as streams:
|
||||
await context_server.run(streams[0], streams[1], context_server.create_initialization_options())
|
||||
return Response()
|
||||
|
||||
app = Starlette(
|
||||
routes=[
|
||||
Route("/sse", endpoint=handle_sse),
|
||||
Mount("/messages/", app=sse.handle_post_message),
|
||||
]
|
||||
)
|
||||
|
||||
server = uvicorn.Server(config=uvicorn.Config(app=app, host="127.0.0.1", port=server_port, log_level="error"))
|
||||
print(f"starting context server on {server_port}")
|
||||
server.run()
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def context_server(server_port: int) -> Generator[None, None, None]:
|
||||
"""Fixture that provides a server with request context capture"""
|
||||
proc = multiprocessing.Process(target=run_context_server, kwargs={"server_port": server_port}, daemon=True)
|
||||
print("starting context server process")
|
||||
proc.start()
|
||||
|
||||
# Wait for server to be running
|
||||
print("waiting for context server to start")
|
||||
wait_for_server(server_port)
|
||||
|
||||
yield
|
||||
|
||||
print("killing context server")
|
||||
proc.kill()
|
||||
proc.join(timeout=2)
|
||||
if proc.is_alive(): # pragma: no cover
|
||||
print("context server process failed to terminate")
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_request_context_propagation(context_server: None, server_url: str) -> None:
|
||||
"""Test that request context is properly propagated through SSE transport."""
|
||||
# Test with custom headers
|
||||
custom_headers = {
|
||||
"Authorization": "Bearer test-token",
|
||||
"X-Custom-Header": "test-value",
|
||||
"X-Trace-Id": "trace-123",
|
||||
}
|
||||
|
||||
async with sse_client(server_url + "/sse", headers=custom_headers) as (
|
||||
read_stream,
|
||||
write_stream,
|
||||
):
|
||||
async with ClientSession(read_stream, write_stream) as session:
|
||||
# Initialize the session
|
||||
result = await session.initialize()
|
||||
assert isinstance(result, InitializeResult)
|
||||
|
||||
# Call the tool that echoes headers back
|
||||
tool_result = await session.call_tool("echo_headers", {})
|
||||
|
||||
# Parse the JSON response
|
||||
|
||||
assert len(tool_result.content) == 1
|
||||
headers_data = json.loads(tool_result.content[0].text if tool_result.content[0].type == "text" else "{}")
|
||||
|
||||
# Verify headers were propagated
|
||||
assert headers_data.get("authorization") == "Bearer test-token"
|
||||
assert headers_data.get("x-custom-header") == "test-value"
|
||||
assert headers_data.get("x-trace-id") == "trace-123"
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_request_context_isolation(context_server: None, server_url: str) -> None:
|
||||
"""Test that request contexts are isolated between different SSE clients."""
|
||||
contexts: list[dict[str, Any]] = []
|
||||
|
||||
# Create multiple clients with different headers
|
||||
for i in range(3):
|
||||
headers = {"X-Request-Id": f"request-{i}", "X-Custom-Value": f"value-{i}"}
|
||||
|
||||
async with sse_client(server_url + "/sse", headers=headers) as (
|
||||
read_stream,
|
||||
write_stream,
|
||||
):
|
||||
async with ClientSession(read_stream, write_stream) as session:
|
||||
await session.initialize()
|
||||
|
||||
# Call the tool that echoes context
|
||||
tool_result = await session.call_tool("echo_context", {"request_id": f"request-{i}"})
|
||||
|
||||
assert len(tool_result.content) == 1
|
||||
context_data = json.loads(
|
||||
tool_result.content[0].text if tool_result.content[0].type == "text" else "{}"
|
||||
)
|
||||
contexts.append(context_data)
|
||||
|
||||
# Verify each request had its own context
|
||||
assert len(contexts) == 3
|
||||
for i, ctx in enumerate(contexts):
|
||||
assert ctx["request_id"] == f"request-{i}"
|
||||
assert ctx["headers"].get("x-request-id") == f"request-{i}"
|
||||
assert ctx["headers"].get("x-custom-value") == f"value-{i}"
|
||||
|
||||
|
||||
def test_sse_message_id_coercion():
|
||||
"""Previously, the `RequestId` would coerce a string that looked like an integer into an integer.
|
||||
|
||||
See <https://github.com/modelcontextprotocol/python-sdk/pull/851> for more details.
|
||||
|
||||
As per the JSON-RPC 2.0 specification, the id in the response object needs to be the same type as the id in the
|
||||
request object. In other words, we can't perform the coercion.
|
||||
|
||||
See <https://www.jsonrpc.org/specification#response_object> for more details.
|
||||
"""
|
||||
json_message = '{"jsonrpc": "2.0", "id": "123", "method": "ping", "params": null}'
|
||||
msg = types.JSONRPCRequest.model_validate_json(json_message)
|
||||
assert msg == snapshot(types.JSONRPCRequest(method="ping", jsonrpc="2.0", id="123"))
|
||||
|
||||
json_message = '{"jsonrpc": "2.0", "id": 123, "method": "ping", "params": null}'
|
||||
msg = types.JSONRPCRequest.model_validate_json(json_message)
|
||||
assert msg == snapshot(types.JSONRPCRequest(method="ping", jsonrpc="2.0", id=123))
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"endpoint, expected_result",
|
||||
[
|
||||
# Valid endpoints - should normalize and work
|
||||
("/messages/", "/messages/"),
|
||||
("messages/", "/messages/"),
|
||||
("/", "/"),
|
||||
# Invalid endpoints - should raise ValueError
|
||||
("http://example.com/messages/", ValueError),
|
||||
("//example.com/messages/", ValueError),
|
||||
("ftp://example.com/messages/", ValueError),
|
||||
("/messages/?param=value", ValueError),
|
||||
("/messages/#fragment", ValueError),
|
||||
],
|
||||
)
|
||||
def test_sse_server_transport_endpoint_validation(endpoint: str, expected_result: str | type[Exception]):
|
||||
"""Test that SseServerTransport properly validates and normalizes endpoints."""
|
||||
if isinstance(expected_result, type):
|
||||
# Test invalid endpoints that should raise an exception
|
||||
with pytest.raises(expected_result, match="is not a relative path.*expecting a relative path"):
|
||||
SseServerTransport(endpoint)
|
||||
else:
|
||||
# Test valid endpoints that should normalize correctly
|
||||
sse = SseServerTransport(endpoint)
|
||||
assert sse._endpoint == expected_result
|
||||
assert sse._endpoint.startswith("/")
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_client_handles_empty_keepalive_pings() -> None:
|
||||
"""Test that SSE client properly handles empty data lines (keep-alive pings).
|
||||
|
||||
Per the MCP spec (Streamable HTTP transport): "The server SHOULD immediately
|
||||
send an SSE event consisting of an event ID and an empty data field in order
|
||||
to prime the client to reconnect."
|
||||
|
||||
This test mocks the SSE event stream to include empty "message" events and
|
||||
verifies the client skips them without crashing.
|
||||
"""
|
||||
# Build a proper JSON-RPC response using types (not hardcoded strings)
|
||||
init_result = InitializeResult(
|
||||
protocol_version="2024-11-05",
|
||||
capabilities=ServerCapabilities(),
|
||||
server_info=Implementation(name="test", version="1.0"),
|
||||
)
|
||||
response = JSONRPCResponse(
|
||||
jsonrpc="2.0",
|
||||
id=1,
|
||||
result=init_result.model_dump(by_alias=True, exclude_none=True),
|
||||
)
|
||||
response_json = response.model_dump_json(by_alias=True, exclude_none=True)
|
||||
|
||||
# Create mock SSE events using httpx_sse's ServerSentEvent
|
||||
async def mock_aiter_sse() -> AsyncGenerator[ServerSentEvent, None]:
|
||||
# First: endpoint event
|
||||
yield ServerSentEvent(event="endpoint", data="/messages/?session_id=abc123")
|
||||
# Empty data keep-alive ping - this is what we're testing
|
||||
yield ServerSentEvent(event="message", data="")
|
||||
# Real JSON-RPC response
|
||||
yield ServerSentEvent(event="message", data=response_json)
|
||||
|
||||
mock_event_source = MagicMock()
|
||||
mock_event_source.aiter_sse.return_value = mock_aiter_sse()
|
||||
mock_event_source.response = MagicMock()
|
||||
mock_event_source.response.raise_for_status = MagicMock()
|
||||
|
||||
mock_aconnect_sse = MagicMock()
|
||||
mock_aconnect_sse.__aenter__ = AsyncMock(return_value=mock_event_source)
|
||||
mock_aconnect_sse.__aexit__ = AsyncMock(return_value=None)
|
||||
|
||||
mock_client = MagicMock()
|
||||
mock_client.__aenter__ = AsyncMock(return_value=mock_client)
|
||||
mock_client.__aexit__ = AsyncMock(return_value=None)
|
||||
mock_client.post = AsyncMock(return_value=MagicMock(status_code=200, raise_for_status=MagicMock()))
|
||||
|
||||
with (
|
||||
patch("mcp.client.sse.create_mcp_http_client", return_value=mock_client),
|
||||
patch("mcp.client.sse.aconnect_sse", return_value=mock_aconnect_sse),
|
||||
):
|
||||
async with sse_client("http://test/sse") as (read_stream, _):
|
||||
# Read the message - should skip the empty one and get the real response
|
||||
msg = await read_stream.receive()
|
||||
# If we get here without error, the empty message was skipped successfully
|
||||
assert not isinstance(msg, Exception)
|
||||
assert isinstance(msg.message, types.JSONRPCResponse)
|
||||
assert msg.message.id == 1
|
||||
|
||||
|
||||
@pytest.mark.anyio
|
||||
async def test_sse_session_cleanup_on_disconnect(server: None, server_url: str) -> None:
|
||||
"""Regression test for https://github.com/modelcontextprotocol/python-sdk/issues/1227
|
||||
|
||||
When a client disconnects, the server should remove the session from
|
||||
_read_stream_writers. Without this cleanup, stale sessions accumulate and
|
||||
POST requests to disconnected sessions return 202 Accepted followed by a
|
||||
ClosedResourceError when the server tries to write to the dead stream.
|
||||
"""
|
||||
captured: list[str] = []
|
||||
|
||||
# Connect a client session, then disconnect
|
||||
async with sse_client(server_url + "/sse", on_session_created=captured.append) as streams:
|
||||
async with ClientSession(*streams) as session:
|
||||
await session.initialize()
|
||||
|
||||
# After disconnect, POST to the stale session should return 404
|
||||
# (not 202 as it did before the fix)
|
||||
async with httpx.AsyncClient() as client:
|
||||
response = await client.post(
|
||||
f"{server_url}/messages/?session_id={captured[0]}",
|
||||
json={"jsonrpc": "2.0", "method": "ping", "id": 99},
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
assert response.status_code == 404
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,208 @@
|
||||
"""Tests for tool name validation utilities (SEP-986)."""
|
||||
|
||||
import logging
|
||||
|
||||
import pytest
|
||||
|
||||
from mcp.shared.tool_name_validation import (
|
||||
issue_tool_name_warning,
|
||||
validate_and_warn_tool_name,
|
||||
validate_tool_name,
|
||||
)
|
||||
|
||||
# Tests for validate_tool_name function - valid names
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"tool_name",
|
||||
[
|
||||
"getUser",
|
||||
"get_user_profile",
|
||||
"user-profile-update",
|
||||
"admin.tools.list",
|
||||
"DATA_EXPORT_v2.1",
|
||||
"a",
|
||||
"a" * 128,
|
||||
],
|
||||
ids=[
|
||||
"simple_alphanumeric",
|
||||
"with_underscores",
|
||||
"with_dashes",
|
||||
"with_dots",
|
||||
"mixed_characters",
|
||||
"single_character",
|
||||
"max_length_128",
|
||||
],
|
||||
)
|
||||
def test_validate_tool_name_accepts_valid_names(tool_name: str) -> None:
|
||||
"""Valid tool names should pass validation with no warnings."""
|
||||
result = validate_tool_name(tool_name)
|
||||
assert result.is_valid is True
|
||||
assert result.warnings == []
|
||||
|
||||
|
||||
# Tests for validate_tool_name function - invalid names
|
||||
|
||||
|
||||
def test_validate_tool_name_rejects_empty_name() -> None:
|
||||
"""Empty names should be rejected."""
|
||||
result = validate_tool_name("")
|
||||
assert result.is_valid is False
|
||||
assert "Tool name cannot be empty" in result.warnings
|
||||
|
||||
|
||||
def test_validate_tool_name_rejects_name_exceeding_max_length() -> None:
|
||||
"""Names exceeding 128 characters should be rejected."""
|
||||
result = validate_tool_name("a" * 129)
|
||||
assert result.is_valid is False
|
||||
assert any("exceeds maximum length of 128 characters (current: 129)" in w for w in result.warnings)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"tool_name,expected_char",
|
||||
[
|
||||
("get user profile", "' '"),
|
||||
("get,user,profile", "','"),
|
||||
("user/profile/update", "'/'"),
|
||||
("user@domain.com", "'@'"),
|
||||
],
|
||||
ids=[
|
||||
"with_spaces",
|
||||
"with_commas",
|
||||
"with_slashes",
|
||||
"with_at_symbol",
|
||||
],
|
||||
)
|
||||
def test_validate_tool_name_rejects_invalid_characters(tool_name: str, expected_char: str) -> None:
|
||||
"""Names with invalid characters should be rejected."""
|
||||
result = validate_tool_name(tool_name)
|
||||
assert result.is_valid is False
|
||||
assert any("invalid characters" in w and expected_char in w for w in result.warnings)
|
||||
|
||||
|
||||
def test_validate_tool_name_rejects_multiple_invalid_chars() -> None:
|
||||
"""Names with multiple invalid chars should list all of them."""
|
||||
result = validate_tool_name("user name@domain,com")
|
||||
assert result.is_valid is False
|
||||
warning = next(w for w in result.warnings if "invalid characters" in w)
|
||||
assert "' '" in warning
|
||||
assert "'@'" in warning
|
||||
assert "','" in warning
|
||||
|
||||
|
||||
def test_validate_tool_name_rejects_unicode_characters() -> None:
|
||||
"""Names with unicode characters should be rejected."""
|
||||
result = validate_tool_name("user-\u00f1ame") # n with tilde
|
||||
assert result.is_valid is False
|
||||
|
||||
|
||||
# Tests for validate_tool_name function - warnings for problematic patterns
|
||||
|
||||
|
||||
def test_validate_tool_name_warns_on_leading_dash() -> None:
|
||||
"""Names starting with dash should generate warning but be valid."""
|
||||
result = validate_tool_name("-get-user")
|
||||
assert result.is_valid is True
|
||||
assert any("starts or ends with a dash" in w for w in result.warnings)
|
||||
|
||||
|
||||
def test_validate_tool_name_warns_on_trailing_dash() -> None:
|
||||
"""Names ending with dash should generate warning but be valid."""
|
||||
result = validate_tool_name("get-user-")
|
||||
assert result.is_valid is True
|
||||
assert any("starts or ends with a dash" in w for w in result.warnings)
|
||||
|
||||
|
||||
def test_validate_tool_name_warns_on_leading_dot() -> None:
|
||||
"""Names starting with dot should generate warning but be valid."""
|
||||
result = validate_tool_name(".get.user")
|
||||
assert result.is_valid is True
|
||||
assert any("starts or ends with a dot" in w for w in result.warnings)
|
||||
|
||||
|
||||
def test_validate_tool_name_warns_on_trailing_dot() -> None:
|
||||
"""Names ending with dot should generate warning but be valid."""
|
||||
result = validate_tool_name("get.user.")
|
||||
assert result.is_valid is True
|
||||
assert any("starts or ends with a dot" in w for w in result.warnings)
|
||||
|
||||
|
||||
# Tests for issue_tool_name_warning function
|
||||
|
||||
|
||||
def test_issue_tool_name_warning_logs_warnings(caplog: pytest.LogCaptureFixture) -> None:
|
||||
"""Warnings should be logged at WARNING level."""
|
||||
warnings = ["Warning 1", "Warning 2"]
|
||||
with caplog.at_level(logging.WARNING):
|
||||
issue_tool_name_warning("test-tool", warnings)
|
||||
|
||||
assert 'Tool name validation warning for "test-tool"' in caplog.text
|
||||
assert "- Warning 1" in caplog.text
|
||||
assert "- Warning 2" in caplog.text
|
||||
assert "Tool registration will proceed" in caplog.text
|
||||
assert "SEP-986" in caplog.text
|
||||
|
||||
|
||||
def test_issue_tool_name_warning_no_logging_for_empty_warnings(caplog: pytest.LogCaptureFixture) -> None:
|
||||
"""Empty warnings list should not produce any log output."""
|
||||
with caplog.at_level(logging.WARNING):
|
||||
issue_tool_name_warning("test-tool", [])
|
||||
|
||||
assert caplog.text == ""
|
||||
|
||||
|
||||
# Tests for validate_and_warn_tool_name function
|
||||
|
||||
|
||||
def test_validate_and_warn_tool_name_returns_true_for_valid_name() -> None:
|
||||
"""Valid names should return True."""
|
||||
assert validate_and_warn_tool_name("valid-tool-name") is True
|
||||
|
||||
|
||||
def test_validate_and_warn_tool_name_returns_false_for_invalid_name() -> None:
|
||||
"""Invalid names should return False."""
|
||||
assert validate_and_warn_tool_name("") is False
|
||||
assert validate_and_warn_tool_name("a" * 129) is False
|
||||
assert validate_and_warn_tool_name("invalid name") is False
|
||||
|
||||
|
||||
def test_validate_and_warn_tool_name_logs_warnings_for_invalid_name(caplog: pytest.LogCaptureFixture) -> None:
|
||||
"""Invalid names should trigger warning logs."""
|
||||
with caplog.at_level(logging.WARNING):
|
||||
validate_and_warn_tool_name("invalid name")
|
||||
|
||||
assert "Tool name validation warning" in caplog.text
|
||||
|
||||
|
||||
def test_validate_and_warn_tool_name_no_warnings_for_clean_valid_name(caplog: pytest.LogCaptureFixture) -> None:
|
||||
"""Clean valid names should not produce any log output."""
|
||||
with caplog.at_level(logging.WARNING):
|
||||
result = validate_and_warn_tool_name("clean-tool-name")
|
||||
|
||||
assert result is True
|
||||
assert caplog.text == ""
|
||||
|
||||
|
||||
# Tests for edge cases
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"tool_name,is_valid,expected_warning_fragment",
|
||||
[
|
||||
("...", True, "starts or ends with a dot"),
|
||||
("---", True, "starts or ends with a dash"),
|
||||
("///", False, "invalid characters"),
|
||||
("user@name123", False, "invalid characters"),
|
||||
],
|
||||
ids=[
|
||||
"only_dots",
|
||||
"only_dashes",
|
||||
"only_slashes",
|
||||
"mixed_valid_invalid",
|
||||
],
|
||||
)
|
||||
def test_edge_cases(tool_name: str, is_valid: bool, expected_warning_fragment: str) -> None:
|
||||
"""Various edge cases should be handled correctly."""
|
||||
result = validate_tool_name(tool_name)
|
||||
assert result.is_valid is is_valid
|
||||
assert any(expected_warning_fragment in w for w in result.warnings)
|
||||
@@ -0,0 +1,10 @@
|
||||
"""Windows-specific test utilities."""
|
||||
|
||||
|
||||
def escape_path_for_python(path: str) -> str:
|
||||
"""Escape a file path for use in Python code strings.
|
||||
|
||||
Converts backslashes to forward slashes which work on all platforms
|
||||
and don't need escaping in Python strings.
|
||||
"""
|
||||
return repr(path.replace("\\", "/"))
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Smoke test for the WebSocket transport.
|
||||
|
||||
Runs the full WS stack end-to-end over a real TCP connection, covering both
|
||||
``src/mcp/client/websocket.py`` and ``src/mcp/server/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
|
||||
|
||||
import pytest
|
||||
from starlette.applications import Starlette
|
||||
from starlette.routing import WebSocketRoute
|
||||
from starlette.websockets import WebSocket
|
||||
|
||||
from mcp.client.session import ClientSession
|
||||
from mcp.client.websocket import websocket_client
|
||||
from mcp.server import Server
|
||||
from mcp.server.websocket import websocket_server
|
||||
from mcp.types import EmptyResult, InitializeResult
|
||||
from tests.test_helpers import run_uvicorn_in_thread
|
||||
|
||||
SERVER_NAME = "test_server_for_WS"
|
||||
|
||||
|
||||
def make_server_app() -> Starlette:
|
||||
srv = Server(SERVER_NAME)
|
||||
|
||||
async def handle_ws(websocket: WebSocket) -> None:
|
||||
async with websocket_server(websocket.scope, websocket.receive, websocket.send) as streams:
|
||||
await srv.run(streams[0], streams[1], srv.create_initialization_options())
|
||||
|
||||
return Starlette(routes=[WebSocketRoute("/ws", endpoint=handle_ws)])
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def ws_server_url() -> Generator[str, None, None]:
|
||||
with run_uvicorn_in_thread(make_server_app()) as base_url:
|
||||
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:
|
||||
result = await session.initialize()
|
||||
assert isinstance(result, InitializeResult)
|
||||
assert result.server_info.name == SERVER_NAME
|
||||
|
||||
ping_result = await session.send_ping()
|
||||
assert isinstance(ping_result, EmptyResult)
|
||||
Reference in New Issue
Block a user