refactor: address review feedback on docstrings and test structure

- Trim JSONRPCNotification docstring to single-line style matching file convention
- Trim validator docstring to single-line; move spec rationale to inline comment
- Fix issue reference from :issue:`2057` to #2057
- Switch tests from class to module-level functions (matching tests/issues/ convention)
- Reduce to 4 focused tests that verify the fix (drop redundant pre-existing behavior tests)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: BabyChrist666

src/mcp/types/jsonrpc.py

@@ -20,14 +20,7 @@ class JSONRPCRequest(BaseModel):
 
 
 class JSONRPCNotification(BaseModel):
-    """A JSON-RPC notification which does not expect a response.
-
-    Per JSON-RPC 2.0, a notification is a request without an ``id`` member.
-    Messages that include ``id`` (even with a ``null`` value) are requests,
-    not notifications.  The validator below prevents Pydantic's union
-    resolution from silently absorbing an invalid ``"id": null`` request
-    as a notification (see :issue:`2057`).
-    """
+    """A JSON-RPC notification which does not expect a response."""
 
     jsonrpc: Literal["2.0"]
     method: str
@@ -36,12 +29,10 @@ class JSONRPCNotification(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def _reject_id_field(cls, data: dict[str, Any]) -> dict[str, Any]:
-        """Reject messages that contain an ``id`` field.
-
-        JSON-RPC notifications MUST NOT include an ``id`` member.  If the
-        raw payload contains ``"id"`` (regardless of its value), it is a
-        malformed request — not a valid notification.
-        """
+        """Reject payloads containing an 'id' field (notifications must not have one)."""
+        # Per JSON-RPC 2.0, notifications must not include an "id" member.
+        # Without this check, Pydantic's union resolution silently absorbs
+        # invalid "id": null requests as notifications (#2057).
         if "id" in data:
             raise ValueError(
                 "Notifications must not include an 'id' field. "

tests/issues/test_2057_null_id_rejected.py

@@ -14,81 +14,32 @@
 
 from mcp.types import (
     JSONRPCNotification,
-    JSONRPCRequest,
     jsonrpc_message_adapter,
 )
 
 
-class TestNullIdRejection:
-    """Verify that ``"id": null`` is never silently absorbed."""
+def test_notification_rejects_id_field() -> None:
+    """JSONRPCNotification must not accept messages with an 'id' field."""
+    with pytest.raises(ValidationError, match="must not include an 'id' field"):
+        JSONRPCNotification.model_validate({"jsonrpc": "2.0", "method": "initialize", "id": None})
 
-    def test_request_rejects_null_id(self) -> None:
-        """JSONRPCRequest correctly rejects null id."""
-        with pytest.raises(ValidationError):
-            JSONRPCRequest.model_validate({"jsonrpc": "2.0", "method": "initialize", "id": None})
 
-    def test_notification_rejects_id_field(self) -> None:
-        """JSONRPCNotification must not accept messages with an 'id' field."""
-        with pytest.raises(ValidationError, match="must not include an 'id' field"):
-            JSONRPCNotification.model_validate({"jsonrpc": "2.0", "method": "initialize", "id": None})
+@pytest.mark.parametrize("id_value", [None, 0, 1, "", "abc"])
+def test_notification_rejects_any_id_value(id_value: object) -> None:
+    """Notification rejects 'id' regardless of value — null, int, or str."""
+    with pytest.raises(ValidationError):
+        JSONRPCNotification.model_validate({"jsonrpc": "2.0", "method": "test", "id": id_value})
 
-    def test_notification_rejects_any_id_value(self) -> None:
-        """Notification rejects 'id' regardless of value — null, int, or str."""
-        for id_value in [None, 0, 1, "", "abc"]:
-            with pytest.raises(ValidationError):
-                JSONRPCNotification.model_validate({"jsonrpc": "2.0", "method": "test", "id": id_value})
 
-    def test_message_adapter_rejects_null_id(self) -> None:
-        """JSONRPCMessage union must not accept ``"id": null``."""
-        raw = {"jsonrpc": "2.0", "method": "initialize", "id": None}
-        with pytest.raises(ValidationError):
-            jsonrpc_message_adapter.validate_python(raw)
+def test_message_adapter_rejects_null_id() -> None:
+    """JSONRPCMessage union must not accept ``"id": null``."""
+    raw = {"jsonrpc": "2.0", "method": "initialize", "id": None}
+    with pytest.raises(ValidationError):
+        jsonrpc_message_adapter.validate_python(raw)
 
-    def test_message_adapter_rejects_null_id_json(self) -> None:
-        """Same test but via validate_json (the path used by transports)."""
-        raw_json = json.dumps({"jsonrpc": "2.0", "method": "initialize", "id": None})
-        with pytest.raises(ValidationError):
-            jsonrpc_message_adapter.validate_json(raw_json)
 
-    def test_valid_notification_still_works(self) -> None:
-        """A valid notification (no 'id' field at all) must still parse fine."""
-        msg = JSONRPCNotification.model_validate({"jsonrpc": "2.0", "method": "notifications/initialized"})
-        assert msg.method == "notifications/initialized"
-
-    def test_valid_notification_with_params(self) -> None:
-        """Notification with params but no 'id' should work."""
-        msg = JSONRPCNotification.model_validate(
-            {"jsonrpc": "2.0", "method": "notifications/progress", "params": {"progress": 50}}
-        )
-        assert msg.method == "notifications/progress"
-        assert msg.params == {"progress": 50}
-
-    def test_valid_request_with_string_id(self) -> None:
-        """A valid request with a string id still works."""
-        msg = JSONRPCRequest.model_validate({"jsonrpc": "2.0", "method": "initialize", "id": "abc-123"})
-        assert msg.id == "abc-123"
-
-    def test_valid_request_with_int_id(self) -> None:
-        """A valid request with an integer id still works."""
-        msg = JSONRPCRequest.model_validate({"jsonrpc": "2.0", "method": "initialize", "id": 42})
-        assert msg.id == 42
-
-    def test_message_adapter_parses_valid_request(self) -> None:
-        """The union adapter correctly identifies a valid request."""
-        raw = {"jsonrpc": "2.0", "method": "initialize", "id": 1}
-        parsed = jsonrpc_message_adapter.validate_python(raw)
-        assert isinstance(parsed, JSONRPCRequest)
-        assert parsed.id == 1
-
-    def test_message_adapter_parses_valid_notification(self) -> None:
-        """The union adapter correctly identifies a valid notification."""
-        raw = {"jsonrpc": "2.0", "method": "notifications/initialized"}
-        parsed = jsonrpc_message_adapter.validate_python(raw)
-        assert isinstance(parsed, JSONRPCNotification)
-        assert parsed.method == "notifications/initialized"
-
-    def test_message_adapter_parses_notification_json(self) -> None:
-        """The union adapter correctly identifies a valid notification via JSON."""
-        raw_json = json.dumps({"jsonrpc": "2.0", "method": "notifications/initialized"})
-        parsed = jsonrpc_message_adapter.validate_json(raw_json)
-        assert isinstance(parsed, JSONRPCNotification)
+def test_message_adapter_rejects_null_id_json() -> None:
+    """Same test but via validate_json (the path used by transports)."""
+    raw_json = json.dumps({"jsonrpc": "2.0", "method": "initialize", "id": None})
+    with pytest.raises(ValidationError):
+        jsonrpc_message_adapter.validate_json(raw_json)