Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test: use real MCP request and transport fixtures (#43155)

Asuka Minato5bae0bb01063
diff --git a/api/tests/unit_tests/core/mcp/client/test_streamable_http.py b/api/tests/unit_tests/core/mcp/client/test_streamable_http.py
index 398740c0cbe..74f1f562301 100644
--- a/api/tests/unit_tests/core/mcp/client/test_streamable_http.py
+++ b/api/tests/unit_tests/core/mcp/client/test_streamable_http.py
@@ -554,7 +554,7 @@ class TestUpdateHeadersWithSession:
class TestResponseRegistry:
def test_register_and_unregister(self):
t = _new_transport()
- resp = MagicMock(spec=httpx.Response)
+ resp = httpx.Response(200, stream=httpx.ByteStream(b""))
t._register_response(resp)
assert resp in t._active_responses
t._unregister_response(resp)
@@ -562,26 +562,29 @@ class TestResponseRegistry:
def test_unregister_not_registered_does_not_raise(self):
t = _new_transport()
- resp = MagicMock(spec=httpx.Response)
+ resp = httpx.Response(200, stream=httpx.ByteStream(b""))
t._unregister_response(resp) # Should swallow ValueError silently
def test_close_active_responses_calls_close(self):
t = _new_transport()
- resp1 = MagicMock(spec=httpx.Response)
- resp2 = MagicMock(spec=httpx.Response)
+ resp1 = httpx.Response(200, stream=httpx.ByteStream(b""))
+ resp2 = httpx.Response(200, stream=httpx.ByteStream(b""))
t._register_response(resp1)
t._register_response(resp2)
+ assert not resp1.is_closed
+ assert not resp2.is_closed
t.close_active_responses()
- resp1.close.assert_called_once()
- resp2.close.assert_called_once()
+ assert resp1.is_closed
+ assert resp2.is_closed
assert t._active_responses == []
def test_close_active_responses_swallows_runtime_error(self):
t = _new_transport()
- resp = MagicMock(spec=httpx.Response)
- resp.close.side_effect = RuntimeError("already closed")
+ resp = httpx.Response(200, stream=httpx.ByteStream(b""))
t._register_response(resp)
- t.close_active_responses() # Should not raise
+ with patch.object(resp, "close", side_effect=RuntimeError("already closed")):
+ t.close_active_responses() # Should not raise
+ resp.close()
# ── _is_initialization_request / _is_initialized_notification ────────────────
@@ -798,7 +801,7 @@ class TestHandleResumptionRequestNew:
session_msg = SessionMessage(message)
metadata = None
if resumption_token:
- metadata = MagicMock(spec=ClientMessageMetadata)
+ metadata = ClientMessageMetadata()
metadata.resumption_token = resumption_token
metadata.on_resumption_token_update = MagicMock()
return RequestContext(
@@ -814,7 +817,7 @@ class TestHandleResumptionRequestNew:
def test_raises_resumption_error_without_token(self):
t = _new_transport()
q: queue.Queue = queue.Queue()
- metadata = MagicMock(spec=ClientMessageMetadata)
+ metadata = ClientMessageMetadata()
metadata.resumption_token = None
ctx = RequestContext(
client=MagicMock(),
@@ -1226,7 +1229,7 @@ class TestHandleSseResponseNew:
def test_with_metadata_resumption_callback(self):
t = _new_transport()
q: queue.Queue = queue.Queue()
- metadata = MagicMock(spec=ClientMessageMetadata)
+ metadata = ClientMessageMetadata()
callback = MagicMock()
metadata.on_resumption_token_update = callback
@@ -1322,7 +1325,7 @@ class TestPostWriterNew:
start_get_stream = MagicMock()
msg = SessionMessage(_make_request_msg("tools/list", 10))
- metadata = MagicMock(spec=ClientMessageMetadata)
+ metadata = ClientMessageMetadata()
metadata.resumption_token = "resume-abc"
msg.metadata = metadata
c2s.put(msg)
diff --git a/api/tests/unit_tests/core/mcp/server/test_streamable_http.py b/api/tests/unit_tests/core/mcp/server/test_streamable_http.py
index 1878fe08413..32df2a8a9b0 100644
--- a/api/tests/unit_tests/core/mcp/server/test_streamable_http.py
+++ b/api/tests/unit_tests/core/mcp/server/test_streamable_http.py
@@ -4,7 +4,7 @@ from unittest.mock import Mock, patch
import jsonschema
import pytest
-from core.app.features.rate_limiting.rate_limit import RateLimitGenerator
+from core.app.features.rate_limiting.rate_limit import RateLimit, RateLimitGenerator
from core.mcp import types
from core.mcp.server.streamable_http import (
build_parameter_schema,
@@ -48,22 +48,16 @@ class TestHandleMCPRequest:
self.end_user = EndUser()
self.user_input_form = []
- # Create mock request
- self.mock_request = Mock()
- self.mock_request.root = Mock()
- self.mock_request.root.id = 123
+ self.request = types.ClientRequest(root=types.PingRequest())
def test_handle_ping_request(self):
"""Test handling ping request"""
# Setup ping request
- self.mock_request.root = Mock(spec=types.PingRequest)
- self.mock_request.root.id = 123
- request_type = Mock(return_value=types.PingRequest)
+ self.request.root = types.PingRequest()
- with patch("core.mcp.server.streamable_http.type", request_type):
- result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123
- )
+ result = handle_mcp_request(
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123
+ )
assert isinstance(result, types.JSONRPCResponse)
assert result.jsonrpc == "2.0"
@@ -72,16 +66,17 @@ class TestHandleMCPRequest:
def test_handle_initialize_request(self):
"""Test handling initialize request"""
# Setup initialize request
- self.mock_request.root = Mock(spec=types.InitializeRequest)
- self.mock_request.root.id = 123
- self.mock_request.root.params = Mock()
- self.mock_request.root.params.protocolVersion = "2025-06-18"
- request_type = Mock(return_value=types.InitializeRequest)
-
- with patch("core.mcp.server.streamable_http.type", request_type):
- result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123
+ self.request.root = types.InitializeRequest(
+ params=types.InitializeRequestParams(
+ protocolVersion="2025-06-18",
+ capabilities=types.ClientCapabilities(),
+ clientInfo=types.Implementation(name="test-client", version="1.0"),
)
+ )
+
+ result = handle_mcp_request(
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123
+ )
assert isinstance(result, types.JSONRPCResponse)
assert result.jsonrpc == "2.0"
@@ -90,14 +85,11 @@ class TestHandleMCPRequest:
def test_handle_list_tools_request(self):
"""Test handling list tools request"""
# Setup list tools request
- self.mock_request.root = Mock(spec=types.ListToolsRequest)
- self.mock_request.root.id = 123
- request_type = Mock(return_value=types.ListToolsRequest)
+ self.request.root = types.ListToolsRequest()
- with patch("core.mcp.server.streamable_http.type", request_type):
- result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123
- )
+ result = handle_mcp_request(
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123
+ )
assert isinstance(result, types.JSONRPCResponse)
assert result.jsonrpc == "2.0"
@@ -105,11 +97,10 @@ class TestHandleMCPRequest:
def test_handle_list_tools_request_threads_protocol_version(self):
"""The negotiated version reaches handle_list_tools through the dispatcher."""
- self.mock_request.root = Mock(spec=types.ListToolsRequest)
- self.mock_request.root.id = 123
+ self.request.root = types.ListToolsRequest()
result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123, "2025-06-18"
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123, "2025-06-18"
)
assert isinstance(result, types.JSONRPCResponse)
@@ -119,11 +110,10 @@ class TestHandleMCPRequest:
def test_handle_list_tools_request_legacy_serialization_unchanged(self):
"""A 2024-11-05 tools/list response serializes without any 2025-06-18 fields."""
- self.mock_request.root = Mock(spec=types.ListToolsRequest)
- self.mock_request.root.id = 123
+ self.request.root = types.ListToolsRequest()
result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123, "2024-11-05"
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123, "2024-11-05"
)
assert isinstance(result, types.JSONRPCResponse)
@@ -134,22 +124,19 @@ class TestHandleMCPRequest:
def test_handle_call_tool_request(self, mock_app_generate):
"""Test handling call tool request"""
# Setup call tool request
- mock_call_request = Mock(spec=types.CallToolRequest)
- mock_call_request.params = Mock()
- mock_call_request.params.arguments = {"query": "test question"}
- mock_call_request.id = 123
+ call_request = types.CallToolRequest(
+ params=types.CallToolRequestParams(name="test_app", arguments={"query": "test question"})
+ )
- self.mock_request.root = mock_call_request
- request_type = Mock(return_value=types.CallToolRequest)
+ self.request.root = call_request
# Mock app generate service response
mock_response = {"answer": "test answer"}
mock_app_generate.generate.return_value = mock_response
- with patch("core.mcp.server.streamable_http.type", request_type):
- result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123
- )
+ result = handle_mcp_request(
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123
+ )
assert isinstance(result, types.JSONRPCResponse)
assert result.jsonrpc == "2.0"
@@ -160,17 +147,16 @@ class TestHandleMCPRequest:
@patch("core.mcp.server.streamable_http.AppGenerateService")
def test_handle_call_tool_returns_trigger_workflow_business_error(self, mock_app_generate):
- mock_call_request = Mock(spec=types.CallToolRequest)
- mock_call_request.params = Mock()
- mock_call_request.params.arguments = {"query": "test question"}
- mock_call_request.id = 123
- self.mock_request.root = mock_call_request
+ call_request = types.CallToolRequest(
+ params=types.CallToolRequestParams(name="test_app", arguments={"query": "test question"})
+ )
+ self.request.root = call_request
mock_app_generate.generate.side_effect = TriggerWorkflowServiceModeUnavailableError()
result = handle_mcp_request(
Mock(),
self.app,
- self.mock_request,
+ self.request,
self.user_input_form,
self.mcp_server,
self.end_user,
@@ -184,16 +170,15 @@ class TestHandleMCPRequest:
@patch("core.mcp.server.streamable_http.AppGenerateService")
def test_handle_call_tool_request_threads_protocol_version(self, mock_app_generate):
"""The negotiated version reaches handle_call_tool through the dispatcher."""
- mock_call_request = Mock(spec=types.CallToolRequest)
- mock_call_request.params = Mock()
- mock_call_request.params.arguments = {"query": "test question"}
- mock_call_request.id = 123
- self.mock_request.root = mock_call_request
+ call_request = types.CallToolRequest(
+ params=types.CallToolRequestParams(name="test_app", arguments={"query": "test question"})
+ )
+ self.request.root = call_request
mock_app_generate.generate.return_value = {"answer": "test answer"}
result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123, "2025-06-18"
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123, "2025-06-18"
)
assert isinstance(result, types.JSONRPCResponse)
@@ -202,16 +187,15 @@ class TestHandleMCPRequest:
@patch("core.mcp.server.streamable_http.AppGenerateService")
def test_handle_call_tool_request_legacy_serialization_unchanged(self, mock_app_generate):
"""A 2024-11-05 tools/call response serializes without structuredContent."""
- mock_call_request = Mock(spec=types.CallToolRequest)
- mock_call_request.params = Mock()
- mock_call_request.params.arguments = {"query": "test question"}
- mock_call_request.id = 123
- self.mock_request.root = mock_call_request
+ call_request = types.CallToolRequest(
+ params=types.CallToolRequestParams(name="test_app", arguments={"query": "test question"})
+ )
+ self.request.root = call_request
mock_app_generate.generate.return_value = {"answer": "test answer"}
result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123, "2024-11-05"
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123, "2024-11-05"
)
assert isinstance(result, types.JSONRPCResponse)
@@ -221,18 +205,12 @@ class TestHandleMCPRequest:
def test_handle_unknown_request_type(self):
"""Test handling unknown request type"""
- # Setup unknown request
- class UnknownRequest:
- pass
-
- self.mock_request.root = Mock(spec=UnknownRequest)
- self.mock_request.root.id = 123
- request_type = Mock(return_value=UnknownRequest)
+ # A valid request type with no application-side handler.
+ self.request.root = types.ListResourcesRequest()
- with patch("core.mcp.server.streamable_http.type", request_type):
- result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123
- )
+ result = handle_mcp_request(
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123
+ )
assert isinstance(result, types.JSONRPCError)
assert result.jsonrpc == "2.0"
@@ -242,17 +220,10 @@ class TestHandleMCPRequest:
def test_handle_value_error(self):
"""Test handling ValueError"""
# Setup request that will cause ValueError
- self.mock_request.root = Mock(spec=types.CallToolRequest)
- self.mock_request.root.params = Mock()
- self.mock_request.root.params.arguments = {}
-
- request_type = Mock(return_value=types.CallToolRequest)
+ self.request.root = types.CallToolRequest(params=types.CallToolRequestParams(name="test_app", arguments={}))
# Don't provide end_user to cause ValueError
- with patch("core.mcp.server.streamable_http.type", request_type):
- result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, None, 123
- )
+ result = handle_mcp_request(Mock(), self.app, self.request, self.user_input_form, self.mcp_server, None, 123)
assert isinstance(result, types.JSONRPCError)
assert result.error.code == types.INVALID_PARAMS
@@ -260,15 +231,13 @@ class TestHandleMCPRequest:
def test_handle_generic_exception(self):
"""Test handling generic exception"""
# Setup request that will cause generic exception
- self.mock_request.root = Mock(spec=types.PingRequest)
- self.mock_request.root.id = 123
+ self.request.root = types.PingRequest()
- # Patch handle_ping to raise exception instead of type
+ # Inject the handler failure while preserving normal request dispatch.
with patch("core.mcp.server.streamable_http.handle_ping", side_effect=Exception("Test error")):
- with patch("core.mcp.server.streamable_http.type", return_value=types.PingRequest):
- result = handle_mcp_request(
- Mock(), self.app, self.mock_request, self.user_input_form, self.mcp_server, self.end_user, 123
- )
+ result = handle_mcp_request(
+ Mock(), self.app, self.request, self.user_input_form, self.mcp_server, self.end_user, 123
+ )
assert isinstance(result, types.JSONRPCError)
assert result.error.code == types.INTERNAL_ERROR
@@ -361,12 +330,10 @@ class TestIndividualHandlers:
mode=AppMode.CHAT,
)
- # Create mock request
- mock_request = Mock()
- mock_call_request = Mock(spec=types.CallToolRequest)
- mock_call_request.params = Mock()
- mock_call_request.params.arguments = {"query": "test question"}
- mock_request.root = mock_call_request
+ call_request = types.CallToolRequest(
+ params=types.CallToolRequestParams(name="test_app", arguments={"query": "test question"})
+ )
+ request = types.ClientRequest(root=call_request)
user_input_form: list[VariableEntity] = []
end_user = EndUser()
@@ -375,7 +342,7 @@ class TestIndividualHandlers:
mock_response = {"answer": "test answer"}
mock_app_generate.generate.return_value = mock_response
- result = handle_call_tool(Mock(), app, mock_request, user_input_form, end_user)
+ result = handle_call_tool(Mock(), app, request, user_input_form, end_user)
assert isinstance(result, types.CallToolResult)
assert len(result.content) == 1
@@ -391,15 +358,14 @@ class TestIndividualHandlers:
mode=AppMode.CHAT,
)
- mock_request = Mock()
- mock_call_request = Mock(spec=types.CallToolRequest)
- mock_call_request.params = Mock()
- mock_call_request.params.arguments = {"query": "test question"}
- mock_request.root = mock_call_request
+ call_request = types.CallToolRequest(
+ params=types.CallToolRequestParams(name="test_app", arguments={"query": "test question"})
+ )
+ request = types.ClientRequest(root=call_request)
mock_app_generate.generate.return_value = {"answer": "test answer"}
- result = handle_call_tool(Mock(), app, mock_request, [], EndUser(), "2025-06-18")
+ result = handle_call_tool(Mock(), app, request, [], EndUser(), "2025-06-18")
assert result.structuredContent == {"answer": "test answer"}
assert result.content[0].text == "test answer"
@@ -411,15 +377,14 @@ class TestIndividualHandlers:
mode=AppMode.CHAT,
)
- mock_request = Mock()
- mock_call_request = Mock(spec=types.CallToolRequest)
- mock_call_request.params = Mock()
- mock_call_request.params.arguments = {"query": "test question"}
- mock_request.root = mock_call_request
+ call_request = types.CallToolRequest(
+ params=types.CallToolRequestParams(name="test_app", arguments={"query": "test question"})
+ )
+ request = types.ClientRequest(root=call_request)
mock_app_generate.generate.return_value = {"answer": "test answer"}
- result = handle_call_tool(Mock(), app, mock_request, [], EndUser(), "2024-11-05")
+ result = handle_call_tool(Mock(), app, request, [], EndUser(), "2024-11-05")
assert result.structuredContent is None
assert result.content[0].text == "test answer"
@@ -427,11 +392,11 @@ class TestIndividualHandlers:
def test_handle_call_tool_no_end_user(self):
"""Test call tool handler without end user"""
app = App()
- mock_request = Mock()
+ request = types.ClientRequest(root=types.CallToolRequest(params=types.CallToolRequestParams(name="test_app")))
user_input_form: list[VariableEntity] = []
with pytest.raises(ValueError, match="End user not found"):
- handle_call_tool(Mock(), app, mock_request, user_input_form, None)
+ handle_call_tool(Mock(), app, request, user_input_form, None)
class TestUtilityFunctions:
@@ -548,20 +513,26 @@ class TestUtilityFunctions:
expected = json.dumps({"result": "test result"}, ensure_ascii=False)
assert result == expected
- def test_extract_answer_from_streaming_response(self):
+ def test_extract_answer_from_streaming_response(self, monkeypatch: pytest.MonkeyPatch):
"""Test extracting answer from streaming response"""
app = App()
- # Mock RateLimitGenerator
- mock_generator = Mock(spec=RateLimitGenerator)
- mock_generator.generator = [
+ events = [
'data: {"event": "agent_thought", "thought": "thinking..."}',
'data: {"event": "agent_thought", "thought": "more thinking"}',
'data: {"event": "other", "content": "ignore this"}',
"not data format",
]
- result = extract_answer_from_response(app, mock_generator)
+ monkeypatch.setattr(RateLimit, "_instance_dict", {})
+ rate_limit = RateLimit(client_id="mcp-stream-fixture", max_active_requests=0)
+ response = RateLimitGenerator(
+ rate_limit=rate_limit, generator=(item for item in events), request_id=rate_limit.enter()
+ )
+ try:
+ result = extract_answer_from_response(app, response)
+ finally:
+ response.close()
assert result == "thinking...more thinking"
diff --git a/api/tests/unit_tests/core/mcp/test_utils.py b/api/tests/unit_tests/core/mcp/test_utils.py
index 34eb3be0a38..8f5347bf713 100644
--- a/api/tests/unit_tests/core/mcp/test_utils.py
+++ b/api/tests/unit_tests/core/mcp/test_utils.py
@@ -2,7 +2,8 @@
import json
from collections.abc import Generator
-from unittest.mock import MagicMock, Mock, patch
+from contextlib import nullcontext
+from unittest.mock import patch
import httpx
import httpx_sse
@@ -30,6 +31,15 @@ def _mcp_config(config_overrides) -> None:
)
+def http_client() -> Generator[httpx.Client]:
+ def unexpected_request(request: httpx.Request) -> httpx.Response:
+ raise AssertionError(f"Unexpected HTTP request: {request.method} {request.url}")
+
+ with httpx.Client(transport=httpx.MockTransport(unexpected_request)) as client:
+ yield client
+
+
class TestConstants:
"""Test module constants."""
@@ -115,18 +125,16 @@ class TestSSRFProxySSEConnect:
@patch("core.mcp.utils.connect_sse", autospec=True)
@patch("core.mcp.utils.create_ssrf_proxy_mcp_http_client", autospec=True)
- def test_sse_connect_with_provided_client(self, mock_create_client, mock_connect_sse):
+ def test_sse_connect_with_provided_client(self, mock_create_client, mock_connect_sse, http_client):
"""Test SSE connection with pre-configured client."""
- # Setup mocks
- mock_client = Mock(spec=httpx.Client)
- mock_event_source = Mock(spec=httpx_sse.EventSource)
- mock_context = MagicMock()
- mock_context.__enter__.return_value = mock_event_source
- mock_connect_sse.return_value = mock_context
+ # Configure the connection boundary.
+ event_source = httpx_sse.EventSource(httpx.Response(200, headers={"content-type": "text/event-stream"}))
+ context = nullcontext(event_source)
+ mock_connect_sse.return_value = context
# Call with provided client
result = ssrf_proxy_sse_connect(
- "http://example.com/sse", client=mock_client, method="POST", headers={"Authorization": "Bearer token"}
+ "http://example.com/sse", client=http_client, method="POST", headers={"Authorization": "Bearer token"}
)
# Verify client creation was not called
@@ -134,24 +142,22 @@ class TestSSRFProxySSEConnect:
# Verify connect_sse was called correctly
mock_connect_sse.assert_called_once_with(
- mock_client, "POST", "http://example.com/sse", headers={"Authorization": "Bearer token"}
+ http_client, "POST", "http://example.com/sse", headers={"Authorization": "Bearer token"}
)
# Verify result
- assert result == mock_context
+ assert result == context
@patch("core.mcp.utils.connect_sse", autospec=True)
@patch("core.mcp.utils.create_ssrf_proxy_mcp_http_client", autospec=True)
- def test_sse_connect_without_client(self, mock_create_client, mock_connect_sse):
+ def test_sse_connect_without_client(self, mock_create_client, mock_connect_sse, http_client):
"""Test SSE connection without pre-configured client."""
- # Setup mocks
- mock_client = Mock(spec=httpx.Client)
- mock_create_client.return_value = mock_client
+ # Configure the connection boundary.
+ mock_create_client.return_value = http_client
- mock_event_source = Mock(spec=httpx_sse.EventSource)
- mock_context = MagicMock()
- mock_context.__enter__.return_value = mock_event_source
- mock_connect_sse.return_value = mock_context
+ event_source = httpx_sse.EventSource(httpx.Response(200, headers={"content-type": "text/event-stream"}))
+ context = nullcontext(event_source)
+ mock_connect_sse.return_value = context
# Call without client
result = ssrf_proxy_sse_connect("http://example.com/sse", headers={"X-Custom": "value"})
@@ -170,26 +176,24 @@ class TestSSRFProxySSEConnect:
# Verify connect_sse was called
mock_connect_sse.assert_called_once_with(
- mock_client,
+ http_client,
"GET", # Default method
"http://example.com/sse",
)
# Verify result
- assert result == mock_context
+ assert result == context
@patch("core.mcp.utils.connect_sse", autospec=True)
@patch("core.mcp.utils.create_ssrf_proxy_mcp_http_client", autospec=True)
- def test_sse_connect_with_custom_timeout(self, mock_create_client, mock_connect_sse):
+ def test_sse_connect_with_custom_timeout(self, mock_create_client, mock_connect_sse, http_client):
"""Test SSE connection with custom timeout."""
- # Setup mocks
- mock_client = Mock(spec=httpx.Client)
- mock_create_client.return_value = mock_client
+ # Configure the connection boundary.
+ mock_create_client.return_value = http_client
- mock_event_source = Mock(spec=httpx_sse.EventSource)
- mock_context = MagicMock()
- mock_context.__enter__.return_value = mock_event_source
- mock_connect_sse.return_value = mock_context
+ event_source = httpx_sse.EventSource(httpx.Response(200, headers={"content-type": "text/event-stream"}))
+ context = nullcontext(event_source)
+ mock_connect_sse.return_value = context
custom_timeout = httpx.Timeout(timeout=60.0, read=120.0)
@@ -202,15 +206,14 @@ class TestSSRFProxySSEConnect:
assert call_args[1]["timeout"] == custom_timeout
# Verify result
- assert result == mock_context
+ assert result == context
@patch("core.mcp.utils.connect_sse", autospec=True)
@patch("core.mcp.utils.create_ssrf_proxy_mcp_http_client", autospec=True)
- def test_sse_connect_error_cleanup(self, mock_create_client, mock_connect_sse):
+ def test_sse_connect_error_cleanup(self, mock_create_client, mock_connect_sse, http_client):
"""Test SSE connection cleans up client on error."""
- # Setup mocks
- mock_client = Mock(spec=httpx.Client)
- mock_create_client.return_value = mock_client
+ # Configure the connection boundary.
+ mock_create_client.return_value = http_client
# Make connect_sse raise an exception
mock_connect_sse.side_effect = httpx.ConnectError("Connection failed")
@@ -220,23 +223,22 @@ class TestSSRFProxySSEConnect:
ssrf_proxy_sse_connect("http://example.com/sse")
# Verify client was cleaned up
- mock_client.close.assert_called_once()
+ assert http_client.is_closed
@patch("core.mcp.utils.connect_sse", autospec=True)
- def test_sse_connect_error_no_cleanup_with_provided_client(self, mock_connect_sse):
+ def test_sse_connect_error_no_cleanup_with_provided_client(self, mock_connect_sse, http_client):
"""Test SSE connection doesn't clean up provided client on error."""
- # Setup mocks
- mock_client = Mock(spec=httpx.Client)
+ # Configure the connection boundary.
# Make connect_sse raise an exception
mock_connect_sse.side_effect = httpx.ConnectError("Connection failed")
# Call should raise the exception
with pytest.raises(httpx.ConnectError):
- ssrf_proxy_sse_connect("http://example.com/sse", client=mock_client)
+ ssrf_proxy_sse_connect("http://example.com/sse", client=http_client)
# Verify client was NOT cleaned up (because it was provided)
- mock_client.close.assert_not_called()
+ assert not http_client.is_closed
class TestCreateMCPErrorResponse: