Fix unit tests related to _meta JSON error parsing, mock misconfiguration, and version negotiation array index checks

Author: anubhav756

packages/toolbox-core/src/toolbox_core/mcp_transport/v20241105/mcp.py

@@ -117,16 +117,23 @@ async def _send_request(
                             )
                     except ValueError:
                         raise RuntimeError(
-                            f"Invalid state: current protocol {self._protocol_version} is not in supported_protocols."
+                            f"Invalid state: current protocol "\
+                            f"{self._protocol_version} is not in "
+                            f"supported_protocols."
                         )
 
                 try:
                     err = types.JSONRPCError.model_validate(json_resp).error
+                except Exception:
+                    err = None
+                
+                if err:
                     raise RuntimeError(
                         f"MCP request failed with code {err.code}: {err.message}"
                     )
-                except Exception:
-                    raise RuntimeError(f"MCP request failed: {json_resp.get('error')}")
+                else:
+                    raw_error = json_resp.get("error", {})
+                    raise RuntimeError(f"MCP request failed: {raw_error}")
 
             if not response.ok:
                 raise RuntimeError(

packages/toolbox-core/src/toolbox_core/mcp_transport/v20250326/mcp.py

@@ -131,16 +131,21 @@ async def _send_request(
                             )
                     except ValueError:
                         raise RuntimeError(
-                            f"Invalid state: current protocol {self._protocol_version} is not in supported_protocols."
+                            f"Invalid state: current protocol "\
+                            f"{self._protocol_version} is not in "
+                            f"supported_protocols."
                         )
 
                 try:
                     err = types.JSONRPCError.model_validate(json_resp).error
+                except Exception:
+                    err = None
+                
+                if err:
                     raise RuntimeError(
                         f"MCP request failed with code {err.code}: {err.message}"
                     )
-                except Exception:
-                    # Fallback if the error doesn't match our schema exactly
+                else:
                     raw_error = json_resp.get("error", {})
                     raise RuntimeError(f"MCP request failed: {raw_error}")
 

packages/toolbox-core/src/toolbox_core/mcp_transport/v20250618/mcp.py

@@ -122,16 +122,21 @@ async def _send_request(
                             )
                     except ValueError:
                         raise RuntimeError(
-                            f"Invalid state: current protocol {self._protocol_version} is not in supported_protocols."
+                            f"Invalid state: current protocol "\
+                            f"{self._protocol_version} is not in "
+                            f"supported_protocols."
                         )
 
                 try:
                     err = types.JSONRPCError.model_validate(json_resp).error
+                except Exception:
+                    err = None
+                
+                if err:
                     raise RuntimeError(
                         f"MCP request failed with code {err.code}: {err.message}"
                     )
-                except Exception:
-                    # Fallback if the error doesn't match our schema exactly
+                else:
                     raw_error = json_resp.get("error", {})
                     raise RuntimeError(f"MCP request failed: {raw_error}")
 

packages/toolbox-core/src/toolbox_core/mcp_transport/v20251125/mcp.py

@@ -122,16 +122,21 @@ async def _send_request(
                             )
                     except ValueError:
                         raise RuntimeError(
-                            f"Invalid state: current protocol {self._protocol_version} is not in supported_protocols."
+                            f"Invalid state: current protocol "\
+                            f"{self._protocol_version} is not in "
+                            f"supported_protocols."
                         )
 
                 try:
                     err = types.JSONRPCError.model_validate(json_resp).error
+                except Exception:
+                    err = None
+                
+                if err:
                     raise RuntimeError(
                         f"MCP request failed with code {err.code}: {err.message}"
                     )
-                except Exception:
-                    # Fallback if the error doesn't match our schema exactly
+                else:
                     raw_error = json_resp.get("error", {})
                     raise RuntimeError(f"MCP request failed: {raw_error}")
 

packages/toolbox-core/src/toolbox_core/mcp_transport/v20260618/mcp.py

@@ -149,16 +149,21 @@ async def _send_request(
                             )
                     except ValueError:
                         raise RuntimeError(
-                            f"Invalid state: current protocol {self._protocol_version} is not in supported_protocols."
+                            f"Invalid state: current protocol "\
+                            f"{self._protocol_version} is not in "
+                            f"supported_protocols."
                         )
 
                 try:
                     err = types.JSONRPCError.model_validate(json_resp).error
+                except Exception:
+                    err = None
+                
+                if err:
                     raise RuntimeError(
                         f"MCP request failed with code {err.code}: {err.message}"
                     )
-                except Exception:
-                    # Fallback if the error doesn't match our schema exactly
+                else:
                     raw_error = json_resp.get("error", {})
                     raise RuntimeError(f"MCP request failed: {raw_error}")
 

packages/toolbox-core/tests/mcp_transport/test_v20241105.py

@@ -507,57 +507,52 @@ async def test_tool_invoke_split_json_object(self, transport, mocker):
         assert result == '{"a": 1}'
 
 
-@pytest.mark.asyncio
-async def test_send_request_400_with_json_rpc_error(
-    mcp_transport,
-):
-    request = types.MCPRequest(method="some/method", params={"key": "val"})
-    mock_response = AsyncMock()
-    mock_response.ok = False
-    mock_response.status = 400
-    mock_response.json.return_value = {
-        "jsonrpc": "2.0",
-        "id": "test-id",
-        "error": {"code": -32602, "message": "Missing _meta"},
-    }
-    mcp_transport._session.post.return_value.__aenter__.return_value = mock_response
-
-    with pytest.raises(
-        RuntimeError, match="MCP request failed with code -32602: Missing _meta"
-    ):
-        await mcp_transport._send_request(request, "http://test.local/messages")
+    async def test_send_request_400_with_json_rpc_error(self, transport):
+        request = types.MCPRequest(method="some/method", params={"key": "val"})
+        mock_response = AsyncMock()
+        mock_response.ok = False
+        mock_response.status = 400
+        mock_response.json.return_value = {
+            "jsonrpc": "2.0",
+            "id": "test-id",
+            "error": {"code": -32602, "message": "Missing _meta"},
+        }
+        transport._session.post.return_value.__aenter__.return_value = mock_response
 
+        with pytest.raises(
+            RuntimeError, match="MCP request failed with code -32602: Missing _meta"
+        ):
+            await transport._send_request("http://test.local/messages", request)
 
-@pytest.mark.asyncio
-async def test_send_request_400_with_raw_text(mcp_transport):
-    request = types.MCPRequest(method="some/method", params={"key": "val"})
-    mock_response = AsyncMock()
-    mock_response.ok = False
-    mock_response.status = 400
-    mock_response.json.side_effect = Exception("Not JSON")
-    mock_response.text.return_value = "<html>Bad Request</html>"
-    mcp_transport._session.post.return_value.__aenter__.return_value = mock_response
 
-    with pytest.raises(RuntimeError, match="API request failed with status 400"):
-        await mcp_transport._send_request(request, "http://test.local/messages")
+    async def test_send_request_400_with_raw_text(self, transport):
+        request = types.MCPRequest(method="some/method", params={"key": "val"})
+        mock_response = AsyncMock()
+        mock_response.ok = False
+        mock_response.status = 400
+        mock_response.json.side_effect = Exception("Not JSON")
+        mock_response.text.return_value = "<html>Bad Request</html>"
+        transport._session.post.return_value.__aenter__.return_value = mock_response
 
+        with pytest.raises(RuntimeError, match="API request failed with status 400"):
+            await transport._send_request("http://test.local/messages", request)
 
-@pytest.mark.asyncio
-async def test_version_negotiation_legacy_string_fallback(
-    mcp_transport,
-):
-    from aioresponses import aioresponses
-
-    request = types.MCPRequest(method="some/method", params={})
-    with aioresponses() as m:
-        m.post(
-            "http://test.local/messages",
-            status=400,
-            payload={
-                "jsonrpc": "2.0",
-                "id": "test-id",
-                "error": "invalid protocol version",
-            },
-        )
-        with pytest.raises(ProtocolNegotiationError):
-            await mcp_transport._send_request(request, "http://test.local/messages")
+
+    async def test_version_negotiation_legacy_string_fallback(self, transport):
+        from toolbox_core.exceptions import ProtocolNegotiationError
+
+        request = types.MCPRequest(method="some/method", params={})
+        mock_response_reject = AsyncMock()
+        mock_response_reject.ok = False
+        mock_response_reject.status = 400
+        mock_response_reject.json.return_value = {
+            "jsonrpc": "2.0",
+            "id": "test-id",
+            "error": "invalid protocol version",
+        }
+
+        mock_post = transport._session.post.return_value
+        mock_post.__aenter__.return_value = mock_response_reject
+
+        with pytest.raises(RuntimeError, match="no fallback versions"):
+            await transport._send_request("http://test.local/messages", request)

packages/toolbox-core/tests/mcp_transport/test_v20250326.py

@@ -505,57 +505,52 @@ async def test_tool_invoke_split_json_object(self, transport, mocker):
         assert result == '{"a": 1}'
 
 
-@pytest.mark.asyncio
-async def test_send_request_400_with_json_rpc_error(
-    mcp_transport,
-):
-    request = types.MCPRequest(method="some/method", params={"key": "val"})
-    mock_response = AsyncMock()
-    mock_response.ok = False
-    mock_response.status = 400
-    mock_response.json.return_value = {
-        "jsonrpc": "2.0",
-        "id": "test-id",
-        "error": {"code": -32602, "message": "Missing _meta"},
-    }
-    mcp_transport._session.post.return_value.__aenter__.return_value = mock_response
-
-    with pytest.raises(
-        RuntimeError, match="MCP request failed with code -32602: Missing _meta"
-    ):
-        await mcp_transport._send_request(request, "http://test.local/messages")
+    async def test_send_request_400_with_json_rpc_error(self, transport):
+        request = types.MCPRequest(method="some/method", params={"key": "val"})
+        mock_response = AsyncMock()
+        mock_response.ok = False
+        mock_response.status = 400
+        mock_response.json.return_value = {
+            "jsonrpc": "2.0",
+            "id": "test-id",
+            "error": {"code": -32602, "message": "Missing _meta"},
+        }
+        transport._session.post.return_value.__aenter__.return_value = mock_response
+
+        with pytest.raises(
+            RuntimeError, match="MCP request failed with code -32602: Missing _meta"
+        ):
+            await transport._send_request("http://test.local/messages", request)
 
 
-@pytest.mark.asyncio
-async def test_send_request_400_with_raw_text(mcp_transport):
-    request = types.MCPRequest(method="some/method", params={"key": "val"})
-    mock_response = AsyncMock()
-    mock_response.ok = False
-    mock_response.status = 400
-    mock_response.json.side_effect = Exception("Not JSON")
-    mock_response.text.return_value = "<html>Bad Request</html>"
-    mcp_transport._session.post.return_value.__aenter__.return_value = mock_response
+    async def test_send_request_400_with_raw_text(self, transport):
+        request = types.MCPRequest(method="some/method", params={"key": "val"})
+        mock_response = AsyncMock()
+        mock_response.ok = False
+        mock_response.status = 400
+        mock_response.json.side_effect = Exception("Not JSON")
+        mock_response.text.return_value = "<html>Bad Request</html>"
+        transport._session.post.return_value.__aenter__.return_value = mock_response
 
-    with pytest.raises(RuntimeError, match="API request failed with status 400"):
-        await mcp_transport._send_request(request, "http://test.local/messages")
+        with pytest.raises(RuntimeError, match="API request failed with status 400"):
+            await transport._send_request("http://test.local/messages", request)
 
 
-@pytest.mark.asyncio
-async def test_version_negotiation_legacy_string_fallback(
-    mcp_transport,
-):
-    from aioresponses import aioresponses
-
-    request = types.MCPRequest(method="some/method", params={})
-    with aioresponses() as m:
-        m.post(
-            "http://test.local/messages",
-            status=400,
-            payload={
-                "jsonrpc": "2.0",
-                "id": "test-id",
-                "error": "invalid protocol version",
-            },
-        )
+    async def test_version_negotiation_legacy_string_fallback(self, transport):
+        from toolbox_core.exceptions import ProtocolNegotiationError
+
+        request = types.MCPRequest(method="some/method", params={})
+        mock_response_reject = AsyncMock()
+        mock_response_reject.ok = False
+        mock_response_reject.status = 400
+        mock_response_reject.json.return_value = {
+            "jsonrpc": "2.0",
+            "id": "test-id",
+            "error": "invalid protocol version",
+        }
+
+        mock_post = transport._session.post.return_value
+        mock_post.__aenter__.return_value = mock_response_reject
+
         with pytest.raises(ProtocolNegotiationError):
-            await mcp_transport._send_request(request, "http://test.local/messages")
+            await transport._send_request("http://test.local/messages", request)