dify

dify/api/tests/unit_tests/services/tools/test_mcp_tools_transform.py

@@ -0,0 +1,253 @@
+"""Test cases for MCP tool transformation functionality."""
+
+from unittest.mock import Mock
+
+import pytest
+
+from core.mcp.types import Tool as MCPTool
+from core.tools.entities.api_entities import ToolApiEntity, ToolProviderApiEntity
+from core.tools.entities.common_entities import I18nObject
+from core.tools.entities.tool_entities import ToolProviderType
+from models.tools import MCPToolProvider
+from services.tools.tools_transform_service import ToolTransformService
+
+
+@pytest.fixture
+def mock_user():
+    """Provides a mock user object."""
+    user = Mock()
+    user.name = "Test User"
+    return user
+
+
+@pytest.fixture
+def mock_provider(mock_user):
+    """Provides a mock MCPToolProvider with a loaded user."""
+    provider = Mock(spec=MCPToolProvider)
+    provider.load_user.return_value = mock_user
+    return provider
+
+
+@pytest.fixture
+def mock_provider_no_user():
+    """Provides a mock MCPToolProvider with no user."""
+    provider = Mock(spec=MCPToolProvider)
+    provider.load_user.return_value = None
+    return provider
+
+
+@pytest.fixture
+def mock_provider_full(mock_user):
+    """Provides a fully configured mock MCPToolProvider for detailed tests."""
+    provider = Mock(spec=MCPToolProvider)
+    provider.id = "provider-id-123"
+    provider.server_identifier = "server-identifier-456"
+    provider.name = "Test MCP Provider"
+    provider.provider_icon = "icon.png"
+    provider.authed = True
+    provider.masked_server_url = "https://*****.com/mcp"
+    provider.timeout = 30
+    provider.sse_read_timeout = 300
+    provider.masked_headers = {"Authorization": "Bearer *****"}
+    provider.decrypted_headers = {"Authorization": "Bearer secret-token"}
+
+    # Mock timestamp
+    mock_updated_at = Mock()
+    mock_updated_at.timestamp.return_value = 1234567890
+    provider.updated_at = mock_updated_at
+
+    provider.load_user.return_value = mock_user
+    return provider
+
+
+@pytest.fixture
+def sample_mcp_tools():
+    """Provides sample MCP tools for testing."""
+    return {
+        "simple": MCPTool(
+            name="simple_tool", description="A simple test tool", inputSchema={"type": "object", "properties": {}}
+        ),
+        "none_desc": MCPTool(name="tool_none_desc", description=None, inputSchema={"type": "object", "properties": {}}),
+        "complex": MCPTool(
+            name="complex_tool",
+            description="A tool with complex parameters",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string", "description": "Input text"},
+                    "count": {"type": "integer", "description": "Number of items", "minimum": 1, "maximum": 100},
+                    "options": {"type": "array", "items": {"type": "string"}, "description": "List of options"},
+                },
+                "required": ["text"],
+            },
+        ),
+    }
+
+
+class TestMCPToolTransform:
+    """Test cases for MCP tool transformation methods."""
+
+    def test_mcp_tool_to_user_tool_with_none_description(self, mock_provider):
+        """Test that mcp_tool_to_user_tool handles None description correctly."""
+        # Create MCP tools with None description
+        tools = [
+            MCPTool(
+                name="tool1",
+                description=None,  # This is the case that caused the error
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            MCPTool(
+                name="tool2",
+                description=None,
+                inputSchema={
+                    "type": "object",
+                    "properties": {"param1": {"type": "string", "description": "A parameter"}},
+                },
+            ),
+        ]
+
+        # Call the method
+        result = ToolTransformService.mcp_tool_to_user_tool(mock_provider, tools)
+
+        # Verify the result
+        assert len(result) == 2
+        assert all(isinstance(tool, ToolApiEntity) for tool in result)
+
+        # Check first tool
+        assert result[0].name == "tool1"
+        assert result[0].author == "Test User"
+        assert isinstance(result[0].label, I18nObject)
+        assert result[0].label.en_US == "tool1"
+        assert isinstance(result[0].description, I18nObject)
+        assert result[0].description.en_US == ""  # Should be empty string, not None
+        assert result[0].description.zh_Hans == ""
+
+        # Check second tool
+        assert result[1].name == "tool2"
+        assert result[1].description.en_US == ""
+        assert result[1].description.zh_Hans == ""
+
+    def test_mcp_tool_to_user_tool_with_description(self, mock_provider):
+        """Test that mcp_tool_to_user_tool handles normal description correctly."""
+        # Create MCP tools with description
+        tools = [
+            MCPTool(
+                name="tool_with_desc",
+                description="This is a test tool that does something useful",
+                inputSchema={"type": "object", "properties": {}},
+            )
+        ]
+
+        # Call the method
+        result = ToolTransformService.mcp_tool_to_user_tool(mock_provider, tools)
+
+        # Verify the result
+        assert len(result) == 1
+        assert isinstance(result[0], ToolApiEntity)
+        assert result[0].name == "tool_with_desc"
+        assert result[0].description.en_US == "This is a test tool that does something useful"
+        assert result[0].description.zh_Hans == "This is a test tool that does something useful"
+
+    def test_mcp_tool_to_user_tool_with_no_user(self, mock_provider_no_user):
+        """Test that mcp_tool_to_user_tool handles None user correctly."""
+        # Create MCP tool
+        tools = [MCPTool(name="tool1", description="Test tool", inputSchema={"type": "object", "properties": {}})]
+
+        # Call the method
+        result = ToolTransformService.mcp_tool_to_user_tool(mock_provider_no_user, tools)
+
+        # Verify the result
+        assert len(result) == 1
+        assert result[0].author == "Anonymous"
+
+    def test_mcp_tool_to_user_tool_with_complex_schema(self, mock_provider, sample_mcp_tools):
+        """Test that mcp_tool_to_user_tool correctly converts complex input schemas."""
+        # Use complex tool from fixtures
+        tools = [sample_mcp_tools["complex"]]
+
+        # Call the method
+        result = ToolTransformService.mcp_tool_to_user_tool(mock_provider, tools)
+
+        # Verify the result
+        assert len(result) == 1
+        assert result[0].name == "complex_tool"
+        assert result[0].parameters is not None
+        # The actual parameter conversion is handled by convert_mcp_schema_to_parameter
+        # which should be tested separately
+
+    def test_mcp_provider_to_user_provider_for_list(self, mock_provider_full):
+        """Test mcp_provider_to_user_provider with for_list=True."""
+        # Set tools data with null description
+        mock_provider_full.tools = '[{"name": "tool1", "description": null, "inputSchema": {}}]'
+
+        # Mock the to_entity and to_api_response methods
+        mock_entity = Mock()
+        mock_entity.to_api_response.return_value = {
+            "name": "Test MCP Provider",
+            "type": ToolProviderType.MCP,
+            "is_team_authorization": True,
+            "server_url": "https://*****.com/mcp",
+            "provider_icon": "icon.png",
+            "masked_headers": {"Authorization": "Bearer *****"},
+            "updated_at": 1234567890,
+            "labels": [],
+            "author": "Test User",
+            "description": I18nObject(en_US="Test MCP Provider Description", zh_Hans="Test MCP Provider Description"),
+            "icon": "icon.png",
+            "label": I18nObject(en_US="Test MCP Provider", zh_Hans="Test MCP Provider"),
+            "masked_credentials": {},
+        }
+        mock_provider_full.to_entity.return_value = mock_entity
+
+        # Call the method with for_list=True
+        result = ToolTransformService.mcp_provider_to_user_provider(mock_provider_full, for_list=True)
+
+        # Verify the result
+        assert isinstance(result, ToolProviderApiEntity)
+        assert result.id == "provider-id-123"  # Should use provider.id when for_list=True
+        assert result.name == "Test MCP Provider"
+        assert result.type == ToolProviderType.MCP
+        assert result.is_team_authorization is True
+        assert result.server_url == "https://*****.com/mcp"
+        assert len(result.tools) == 1
+        assert result.tools[0].description.en_US == ""  # Should handle None description
+
+    def test_mcp_provider_to_user_provider_not_for_list(self, mock_provider_full):
+        """Test mcp_provider_to_user_provider with for_list=False."""
+        # Set tools data with description
+        mock_provider_full.tools = '[{"name": "tool1", "description": "Tool description", "inputSchema": {}}]'
+
+        # Mock the to_entity and to_api_response methods
+        mock_entity = Mock()
+        mock_entity.to_api_response.return_value = {
+            "name": "Test MCP Provider",
+            "type": ToolProviderType.MCP,
+            "is_team_authorization": True,
+            "server_url": "https://*****.com/mcp",
+            "provider_icon": "icon.png",
+            "masked_headers": {"Authorization": "Bearer *****"},
+            "updated_at": 1234567890,
+            "labels": [],
+            "configuration": {"timeout": "30", "sse_read_timeout": "300"},
+            "original_headers": {"Authorization": "Bearer secret-token"},
+            "author": "Test User",
+            "description": I18nObject(en_US="Test MCP Provider Description", zh_Hans="Test MCP Provider Description"),
+            "icon": "icon.png",
+            "label": I18nObject(en_US="Test MCP Provider", zh_Hans="Test MCP Provider"),
+            "masked_credentials": {},
+        }
+        mock_provider_full.to_entity.return_value = mock_entity
+
+        # Call the method with for_list=False
+        result = ToolTransformService.mcp_provider_to_user_provider(mock_provider_full, for_list=False)
+
+        # Verify the result
+        assert isinstance(result, ToolProviderApiEntity)
+        assert result.id == "server-identifier-456"  # Should use server_identifier when for_list=False
+        assert result.server_identifier == "server-identifier-456"
+        assert result.configuration is not None
+        assert result.configuration.timeout == 30
+        assert result.configuration.sse_read_timeout == 300
+        assert result.original_headers == {"Authorization": "Bearer secret-token"}
+        assert len(result.tools) == 1
+        assert result.tools[0].description.en_US == "Tool description"

dify/api/tests/unit_tests/services/tools/test_tools_transform_service.py

@@ -0,0 +1,301 @@
+from unittest.mock import Mock
+
+from core.tools.__base.tool import Tool
+from core.tools.entities.api_entities import ToolApiEntity
+from core.tools.entities.common_entities import I18nObject
+from core.tools.entities.tool_entities import ToolParameter
+from services.tools.tools_transform_service import ToolTransformService
+
+
+class TestToolTransformService:
+    """Test cases for ToolTransformService.convert_tool_entity_to_api_entity method"""
+
+    def test_convert_tool_with_parameter_override(self):
+        """Test that runtime parameters correctly override base parameters"""
+        # Create mock base parameters
+        base_param1 = Mock(spec=ToolParameter)
+        base_param1.name = "param1"
+        base_param1.form = ToolParameter.ToolParameterForm.FORM
+        base_param1.type = "string"
+        base_param1.label = "Base Param 1"
+
+        base_param2 = Mock(spec=ToolParameter)
+        base_param2.name = "param2"
+        base_param2.form = ToolParameter.ToolParameterForm.FORM
+        base_param2.type = "string"
+        base_param2.label = "Base Param 2"
+
+        # Create mock runtime parameters that override base parameters
+        runtime_param1 = Mock(spec=ToolParameter)
+        runtime_param1.name = "param1"
+        runtime_param1.form = ToolParameter.ToolParameterForm.FORM
+        runtime_param1.type = "string"
+        runtime_param1.label = "Runtime Param 1"  # Different label to verify override
+
+        # Create mock tool
+        mock_tool = Mock(spec=Tool)
+        mock_tool.entity = Mock()
+        mock_tool.entity.parameters = [base_param1, base_param2]
+        mock_tool.entity.identity = Mock()
+        mock_tool.entity.identity.author = "test_author"
+        mock_tool.entity.identity.name = "test_tool"
+        mock_tool.entity.identity.label = I18nObject(en_US="Test Tool")
+        mock_tool.entity.description = Mock()
+        mock_tool.entity.description.human = I18nObject(en_US="Test description")
+        mock_tool.entity.output_schema = {}
+        mock_tool.get_runtime_parameters.return_value = [runtime_param1]
+
+        # Mock fork_tool_runtime to return the same tool
+        mock_tool.fork_tool_runtime.return_value = mock_tool
+
+        # Call the method
+        result = ToolTransformService.convert_tool_entity_to_api_entity(mock_tool, "test_tenant", None)
+
+        # Verify the result
+        assert isinstance(result, ToolApiEntity)
+        assert result.author == "test_author"
+        assert result.name == "test_tool"
+        assert result.parameters is not None
+        assert len(result.parameters) == 2
+
+        # Find the overridden parameter
+        overridden_param = next((p for p in result.parameters if p.name == "param1"), None)
+        assert overridden_param is not None
+        assert overridden_param.label == "Runtime Param 1"  # Should be runtime version
+
+        # Find the non-overridden parameter
+        original_param = next((p for p in result.parameters if p.name == "param2"), None)
+        assert original_param is not None
+        assert original_param.label == "Base Param 2"  # Should be base version
+
+    def test_convert_tool_with_additional_runtime_parameters(self):
+        """Test that additional runtime parameters are added to the final list"""
+        # Create mock base parameters
+        base_param1 = Mock(spec=ToolParameter)
+        base_param1.name = "param1"
+        base_param1.form = ToolParameter.ToolParameterForm.FORM
+        base_param1.type = "string"
+        base_param1.label = "Base Param 1"
+
+        # Create mock runtime parameters - one that overrides and one that's new
+        runtime_param1 = Mock(spec=ToolParameter)
+        runtime_param1.name = "param1"
+        runtime_param1.form = ToolParameter.ToolParameterForm.FORM
+        runtime_param1.type = "string"
+        runtime_param1.label = "Runtime Param 1"
+
+        runtime_param2 = Mock(spec=ToolParameter)
+        runtime_param2.name = "runtime_only"
+        runtime_param2.form = ToolParameter.ToolParameterForm.FORM
+        runtime_param2.type = "string"
+        runtime_param2.label = "Runtime Only Param"
+
+        # Create mock tool
+        mock_tool = Mock(spec=Tool)
+        mock_tool.entity = Mock()
+        mock_tool.entity.parameters = [base_param1]
+        mock_tool.entity.identity = Mock()
+        mock_tool.entity.identity.author = "test_author"
+        mock_tool.entity.identity.name = "test_tool"
+        mock_tool.entity.identity.label = I18nObject(en_US="Test Tool")
+        mock_tool.entity.description = Mock()
+        mock_tool.entity.description.human = I18nObject(en_US="Test description")
+        mock_tool.entity.output_schema = {}
+        mock_tool.get_runtime_parameters.return_value = [runtime_param1, runtime_param2]
+
+        # Mock fork_tool_runtime to return the same tool
+        mock_tool.fork_tool_runtime.return_value = mock_tool
+
+        # Call the method
+        result = ToolTransformService.convert_tool_entity_to_api_entity(mock_tool, "test_tenant", None)
+
+        # Verify the result
+        assert isinstance(result, ToolApiEntity)
+        assert result.parameters is not None
+        assert len(result.parameters) == 2
+
+        # Check that both parameters are present
+        param_names = [p.name for p in result.parameters]
+        assert "param1" in param_names
+        assert "runtime_only" in param_names
+
+        # Verify the overridden parameter has runtime version
+        overridden_param = next((p for p in result.parameters if p.name == "param1"), None)
+        assert overridden_param is not None
+        assert overridden_param.label == "Runtime Param 1"
+
+        # Verify the new runtime parameter is included
+        new_param = next((p for p in result.parameters if p.name == "runtime_only"), None)
+        assert new_param is not None
+        assert new_param.label == "Runtime Only Param"
+
+    def test_convert_tool_with_non_form_runtime_parameters(self):
+        """Test that non-FORM runtime parameters are not added as new parameters"""
+        # Create mock base parameters
+        base_param1 = Mock(spec=ToolParameter)
+        base_param1.name = "param1"
+        base_param1.form = ToolParameter.ToolParameterForm.FORM
+        base_param1.type = "string"
+        base_param1.label = "Base Param 1"
+
+        # Create mock runtime parameters with different forms
+        runtime_param1 = Mock(spec=ToolParameter)
+        runtime_param1.name = "param1"
+        runtime_param1.form = ToolParameter.ToolParameterForm.FORM
+        runtime_param1.type = "string"
+        runtime_param1.label = "Runtime Param 1"
+
+        runtime_param2 = Mock(spec=ToolParameter)
+        runtime_param2.name = "llm_param"
+        runtime_param2.form = ToolParameter.ToolParameterForm.LLM
+        runtime_param2.type = "string"
+        runtime_param2.label = "LLM Param"
+
+        # Create mock tool
+        mock_tool = Mock(spec=Tool)
+        mock_tool.entity = Mock()
+        mock_tool.entity.parameters = [base_param1]
+        mock_tool.entity.identity = Mock()
+        mock_tool.entity.identity.author = "test_author"
+        mock_tool.entity.identity.name = "test_tool"
+        mock_tool.entity.identity.label = I18nObject(en_US="Test Tool")
+        mock_tool.entity.description = Mock()
+        mock_tool.entity.description.human = I18nObject(en_US="Test description")
+        mock_tool.entity.output_schema = {}
+        mock_tool.get_runtime_parameters.return_value = [runtime_param1, runtime_param2]
+
+        # Mock fork_tool_runtime to return the same tool
+        mock_tool.fork_tool_runtime.return_value = mock_tool
+
+        # Call the method
+        result = ToolTransformService.convert_tool_entity_to_api_entity(mock_tool, "test_tenant", None)
+
+        # Verify the result
+        assert isinstance(result, ToolApiEntity)
+        assert result.parameters is not None
+        assert len(result.parameters) == 1  # Only the FORM parameter should be present
+
+        # Check that only the FORM parameter is present
+        param_names = [p.name for p in result.parameters]
+        assert "param1" in param_names
+        assert "llm_param" not in param_names
+
+    def test_convert_tool_with_empty_parameters(self):
+        """Test conversion with empty base and runtime parameters"""
+        # Create mock tool with no parameters
+        mock_tool = Mock(spec=Tool)
+        mock_tool.entity = Mock()
+        mock_tool.entity.parameters = []
+        mock_tool.entity.identity = Mock()
+        mock_tool.entity.identity.author = "test_author"
+        mock_tool.entity.identity.name = "test_tool"
+        mock_tool.entity.identity.label = I18nObject(en_US="Test Tool")
+        mock_tool.entity.description = Mock()
+        mock_tool.entity.description.human = I18nObject(en_US="Test description")
+        mock_tool.entity.output_schema = {}
+        mock_tool.get_runtime_parameters.return_value = []
+
+        # Mock fork_tool_runtime to return the same tool
+        mock_tool.fork_tool_runtime.return_value = mock_tool
+
+        # Call the method
+        result = ToolTransformService.convert_tool_entity_to_api_entity(mock_tool, "test_tenant", None)
+
+        # Verify the result
+        assert isinstance(result, ToolApiEntity)
+        assert result.parameters is not None
+        assert len(result.parameters) == 0
+
+    def test_convert_tool_with_none_parameters(self):
+        """Test conversion when base parameters is None"""
+        # Create mock tool with None parameters
+        mock_tool = Mock(spec=Tool)
+        mock_tool.entity = Mock()
+        mock_tool.entity.parameters = None
+        mock_tool.entity.identity = Mock()
+        mock_tool.entity.identity.author = "test_author"
+        mock_tool.entity.identity.name = "test_tool"
+        mock_tool.entity.identity.label = I18nObject(en_US="Test Tool")
+        mock_tool.entity.description = Mock()
+        mock_tool.entity.description.human = I18nObject(en_US="Test description")
+        mock_tool.entity.output_schema = {}
+        mock_tool.get_runtime_parameters.return_value = []
+
+        # Mock fork_tool_runtime to return the same tool
+        mock_tool.fork_tool_runtime.return_value = mock_tool
+
+        # Call the method
+        result = ToolTransformService.convert_tool_entity_to_api_entity(mock_tool, "test_tenant", None)
+
+        # Verify the result
+        assert isinstance(result, ToolApiEntity)
+        assert result.parameters is not None
+        assert len(result.parameters) == 0
+
+    def test_convert_tool_parameter_order_preserved(self):
+        """Test that parameter order is preserved correctly"""
+        # Create mock base parameters in specific order
+        base_param1 = Mock(spec=ToolParameter)
+        base_param1.name = "param1"
+        base_param1.form = ToolParameter.ToolParameterForm.FORM
+        base_param1.type = "string"
+        base_param1.label = "Base Param 1"
+
+        base_param2 = Mock(spec=ToolParameter)
+        base_param2.name = "param2"
+        base_param2.form = ToolParameter.ToolParameterForm.FORM
+        base_param2.type = "string"
+        base_param2.label = "Base Param 2"
+
+        base_param3 = Mock(spec=ToolParameter)
+        base_param3.name = "param3"
+        base_param3.form = ToolParameter.ToolParameterForm.FORM
+        base_param3.type = "string"
+        base_param3.label = "Base Param 3"
+
+        # Create runtime parameter that overrides middle parameter
+        runtime_param2 = Mock(spec=ToolParameter)
+        runtime_param2.name = "param2"
+        runtime_param2.form = ToolParameter.ToolParameterForm.FORM
+        runtime_param2.type = "string"
+        runtime_param2.label = "Runtime Param 2"
+
+        # Create new runtime parameter
+        runtime_param4 = Mock(spec=ToolParameter)
+        runtime_param4.name = "param4"
+        runtime_param4.form = ToolParameter.ToolParameterForm.FORM
+        runtime_param4.type = "string"
+        runtime_param4.label = "Runtime Param 4"
+
+        # Create mock tool
+        mock_tool = Mock(spec=Tool)
+        mock_tool.entity = Mock()
+        mock_tool.entity.parameters = [base_param1, base_param2, base_param3]
+        mock_tool.entity.identity = Mock()
+        mock_tool.entity.identity.author = "test_author"
+        mock_tool.entity.identity.name = "test_tool"
+        mock_tool.entity.identity.label = I18nObject(en_US="Test Tool")
+        mock_tool.entity.description = Mock()
+        mock_tool.entity.description.human = I18nObject(en_US="Test description")
+        mock_tool.entity.output_schema = {}
+        mock_tool.get_runtime_parameters.return_value = [runtime_param2, runtime_param4]
+
+        # Mock fork_tool_runtime to return the same tool
+        mock_tool.fork_tool_runtime.return_value = mock_tool
+
+        # Call the method
+        result = ToolTransformService.convert_tool_entity_to_api_entity(mock_tool, "test_tenant", None)
+
+        # Verify the result
+        assert isinstance(result, ToolApiEntity)
+        assert result.parameters is not None
+        assert len(result.parameters) == 4
+
+        # Check that order is maintained: base parameters first, then new runtime parameters
+        param_names = [p.name for p in result.parameters]
+        assert param_names == ["param1", "param2", "param3", "param4"]
+
+        # Verify that param2 was overridden with runtime version
+        param2 = result.parameters[1]
+        assert param2.name == "param2"
+        assert param2.label == "Runtime Param 2"