merge and simplify assertions

Author: alexander-alderman-webb

tests/conftest.py

@@ -673,7 +673,10 @@ def stdio(
     get_initialized_notification_payload,
     get_mcp_command_payload,
 ):
-    async def inner(server, method: str, params, request_id: str):
+    async def inner(server, method: str, params, request_id: str | None = None):
+        if request_id is None:
+            request_id = "1"
+
         read_stream_writer, read_stream = create_memory_object_stream(0)  # type: ignore
         write_stream, write_stream_reader = create_memory_object_stream(0)  # type: ignore
 
@@ -714,9 +717,6 @@ async def simulate_client(tg, result):
 @pytest.fixture()
 def json_rpc():
     def inner(app, method: str, params, request_id: str):
-        if request_id is None:
-            request_id = "1"  # arbitrary
-
         with TestClient(app) as client:  # type: ignore
             init_response = client.post(
                 "/mcp/",

tests/integrations/fastmcp/test_fastmcp.py

@@ -76,11 +76,6 @@ async def __call__(self, *args, **kwargs):
     GetPromptRequest = None
     ReadResourceRequest = None
 
-try:
-    from fastmcp import __version__ as FASTMCP_VERSION
-except ImportError:
-    FASTMCP_VERSION = None
-
 
 # Collect available FastMCP implementations for parametrization
 fastmcp_implementations = []
@@ -324,24 +319,10 @@ def add_numbers(a: int, b: int) -> dict:
             request_id="req-123",
         )
 
-    if (
-        isinstance(mcp, StandaloneFastMCP)
-        and FASTMCP_VERSION is not None
-        and FASTMCP_VERSION.startswith("2")
-    ):
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {"result": 15, "operation": "addition"}, separators=(",", ":")
-        )
-    elif (
-        isinstance(mcp, StandaloneFastMCP) and FASTMCP_VERSION is not None
-    ):  # Checking for None is not precise.
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {"result": 15, "operation": "addition"}
-        )
-    else:
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {"result": 15, "operation": "addition"}, indent=2
-        )
+    assert json.loads(result.message.root.result["content"][0]["text"]) == {
+        "result": 15,
+        "operation": "addition",
+    }
 
     (tx,) = events
     assert tx["type"] == "transaction"
@@ -416,26 +397,10 @@ async def multiply_numbers(x: int, y: int) -> dict:
         request_id="req-456",
     )
 
-    if (
-        isinstance(mcp, StandaloneFastMCP)
-        and FASTMCP_VERSION is not None
-        and FASTMCP_VERSION.startswith("2")
-    ):
-        assert result.json()["result"]["structuredContent"] == {
-            "result": 42,
-            "operation": "multiplication",
-        }
-    elif (
-        isinstance(mcp, StandaloneFastMCP) and FASTMCP_VERSION is not None
-    ):  # Checking for None is not precise.
-        assert result.json()["result"]["content"][0]["text"] == json.dumps(
-            {"result": 42, "operation": "multiplication"},
-        )
-    else:
-        assert result.json()["result"]["content"][0]["text"] == json.dumps(
-            {"result": 42, "operation": "multiplication"},
-            indent=2,
-        )
+    assert json.loads(result.json()["result"]["content"][0]["text"]) == {
+        "result": 42,
+        "operation": "multiplication",
+    }
 
     transactions = select_mcp_transactions(events)
     assert len(transactions) == 1
@@ -618,41 +583,12 @@ def get_user_data(user_id: int) -> dict:
             request_id="req-complex",
         )
 
-    if (
-        isinstance(mcp, StandaloneFastMCP)
-        and FASTMCP_VERSION is not None
-        and FASTMCP_VERSION.startswith("2")
-    ):
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {
-                "id": 123,
-                "name": "Alice",
-                "nested": {"preferences": {"theme": "dark", "notifications": True}},
-                "tags": ["admin", "verified"],
-            },
-            separators=(",", ":"),
-        )
-    elif (
-        isinstance(mcp, StandaloneFastMCP) and FASTMCP_VERSION is not None
-    ):  # Checking for None is not precise.
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {
-                "id": 123,
-                "name": "Alice",
-                "nested": {"preferences": {"theme": "dark", "notifications": True}},
-                "tags": ["admin", "verified"],
-            }
-        )
-    else:
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {
-                "id": 123,
-                "name": "Alice",
-                "nested": {"preferences": {"theme": "dark", "notifications": True}},
-                "tags": ["admin", "verified"],
-            },
-            indent=2,
-        )
+    assert json.loads(result.message.root.result["content"][0]["text"]) == {
+        "id": 123,
+        "name": "Alice",
+        "nested": {"preferences": {"theme": "dark", "notifications": True}},
+        "tags": ["admin", "verified"],
+    }
 
     (tx,) = events
     assert tx["type"] == "transaction"
@@ -1098,23 +1034,9 @@ def http_tool(data: str) -> dict:
         request_id="req-http",
     )
 
-    if (
-        isinstance(mcp, StandaloneFastMCP)
-        and FASTMCP_VERSION is not None
-        and FASTMCP_VERSION.startswith("2")
-    ):
-        assert result.json()["result"]["structuredContent"] == {"processed": "TEST"}
-    elif (
-        isinstance(mcp, StandaloneFastMCP) and FASTMCP_VERSION is not None
-    ):  # Checking for None is not precise.
-        assert result.json()["result"]["content"][0]["text"] == json.dumps(
-            {"processed": "TEST"},
-        )
-    else:
-        assert result.json()["result"]["content"][0]["text"] == json.dumps(
-            {"processed": "TEST"},
-            indent=2,
-        )
+    assert json.loads(result.json()["result"]["content"][0]["text"]) == {
+        "processed": "TEST"
+    }
 
     transactions = select_mcp_transactions(events)
     assert len(transactions) == 1
@@ -1152,24 +1074,9 @@ def stdio_tool(n: int) -> dict:
             request_id="req-stdio",
         )
 
-    if (
-        isinstance(mcp, StandaloneFastMCP)
-        and FASTMCP_VERSION is not None
-        and FASTMCP_VERSION.startswith("2")
-    ):
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {"squared": 49}, separators=(",", ":")
-        )
-    elif (
-        isinstance(mcp, StandaloneFastMCP) and FASTMCP_VERSION is not None
-    ):  # Checking for None is not precise.
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {"squared": 49}
-        )
-    else:
-        assert result.message.root.result["content"][0]["text"] == json.dumps(
-            {"squared": 49}, indent=2
-        )
+    assert json.loads(result.message.root.result["content"][0]["text"]) == {
+        "squared": 49
+    }
 
     (tx,) = events
 
@@ -1213,10 +1120,11 @@ def package_specific_tool(x: int) -> int:
     assert tx["type"] == "transaction"
 
 
+@pytest.mark.asyncio
 @pytest.mark.skipif(
     not HAS_STANDALONE_FASTMCP, reason="standalone fastmcp not installed"
 )
-def test_standalone_fastmcp_specific_features(sentry_init, capture_events):
+async def test_standalone_fastmcp_specific_features(sentry_init, capture_events, stdio):
     """Test features specific to standalone fastmcp package"""
     sentry_init(
         integrations=[MCPIntegration()],
@@ -1234,12 +1142,19 @@ def standalone_specific_tool(message: str) -> dict:
         return {"echo": message, "length": len(message)}
 
     with start_transaction(name="standalone fastmcp tx"):
-        result = call_tool_through_mcp(
-            mcp, "standalone_specific_tool", {"message": "Hello FastMCP"}
+        result = await stdio(
+            mcp._mcp_server,
+            method="tools/call",
+            params={
+                "name": "standalone_specific_tool",
+                "arguments": {"message": "Hello FastMCP"},
+            },
         )
 
-    assert result["echo"] == "Hello FastMCP"
-    assert result["length"] == 13
+    assert json.loads(result.message.root.result["content"][0]["text"]) == {
+        "echo": "Hello FastMCP",
+        "length": 13,
+    }
 
     (tx,) = events
     assert tx["type"] == "transaction"
@@ -1250,8 +1165,11 @@ def standalone_specific_tool(message: str) -> dict:
 # =============================================================================
 
 
+@pytest.mark.asyncio
 @pytest.mark.parametrize("FastMCP", fastmcp_implementations, ids=fastmcp_ids)
-def test_fastmcp_tool_with_no_arguments(sentry_init, capture_events, FastMCP):
+async def test_fastmcp_tool_with_no_arguments(
+    sentry_init, capture_events, FastMCP, stdio
+):
     """Test FastMCP tool with no arguments"""
     sentry_init(
         integrations=[MCPIntegration()],
@@ -1267,16 +1185,26 @@ def no_args_tool() -> str:
         return "success"
 
     with start_transaction(name="fastmcp tx"):
-        result = call_tool_through_mcp(mcp, "no_args_tool", {})
+        result = await stdio(
+            mcp._mcp_server,
+            method="tools/call",
+            params={
+                "name": "no_args_tool",
+                "arguments": {},
+            },
+        )
 
-    assert result["result"] == "success"
+    assert result.message.root.result["content"][0]["text"] == "success"
 
     (tx,) = events
     assert tx["type"] == "transaction"
 
 
+@pytest.mark.asyncio
 @pytest.mark.parametrize("FastMCP", fastmcp_implementations, ids=fastmcp_ids)
-def test_fastmcp_tool_with_none_return(sentry_init, capture_events, FastMCP):
+async def test_fastmcp_tool_with_none_return(
+    sentry_init, capture_events, FastMCP, stdio
+):
     """Test FastMCP tool that returns None"""
     sentry_init(
         integrations=[MCPIntegration()],
@@ -1292,10 +1220,16 @@ def none_return_tool(action: str) -> None:
         pass
 
     with start_transaction(name="fastmcp tx"):
-        result = call_tool_through_mcp(mcp, "none_return_tool", {"action": "log"})
+        result = await stdio(
+            mcp._mcp_server,
+            method="tools/call",
+            params={
+                "name": "none_return_tool",
+                "arguments": {"action": "log"},
+            },
+        )
 
-    # Helper function normalizes to {"result": value} format
-    assert result["result"] is None
+    assert len(result.message.root.result["content"]) == 0
 
     (tx,) = events
     assert tx["type"] == "transaction"