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.

7.9 KB
Raw Blame
from types import SimpleNamespace
import pytest
from pydantic import ValidationError
import dify_agent.layers.dify_plugin as dify_plugin_exports
from dify_agent.layers.dify_plugin import (
    DifyPluginLLMLayerConfig,
    DifyPluginToolCredentialType,
    DifyPluginToolConfig,
    DifyPluginToolParameter,
    DifyPluginToolParameterForm,
    DifyPluginToolParameterType,
    DifyPluginToolsLayerConfig,
    DifyPluginToolValue,
)


def test_dify_plugin_package_exports_client_safe_config_symbols_only() -> None:
    assert dify_plugin_exports.__all__ == [
        "DifyPluginCredentialValue",
        "DifyPluginLLMLayerConfig",
        "DifyPluginToolCredentialType",
        "DifyPluginToolConfig",
        "DifyPluginToolOption",
        "DifyPluginToolParameter",
        "DifyPluginToolParameterForm",
        "DifyPluginToolParameterType",
        "DifyPluginToolsLayerConfig",
        "DifyPluginToolValue",
    ]
    assert not hasattr(dify_plugin_exports, "DifyPluginLLMLayer")


def test_dify_plugin_llm_config_discards_legacy_credentials() -> None:
    config = DifyPluginLLMLayerConfig.model_validate(
        {
            "plugin_id": "langgenius/openai",
            "model_provider": "openai",
            "model": "gpt-4o-mini",
            "credentials": {"api_key": "secret", "nested": {"legacy": True}},
            "model_settings": {"temperature": 0.2, "max_tokens": 64},
            "context_window_tokens": 128000,
        }
    )
    assert config.plugin_id == "langgenius/openai"
    assert config.model_provider == "openai"
    assert not hasattr(config, "credentials")
    assert "credentials" not in config.model_dump(mode="json")
    assert config.model_settings == {"temperature": 0.2, "max_tokens": 64}
    assert config.context_window_tokens == 128000


def test_dify_plugin_llm_config_rejects_old_provider_field() -> None:
    with pytest.raises(ValidationError):
        _ = DifyPluginLLMLayerConfig.model_validate(
            {"provider": "openai", "plugin_id": "langgenius/openai", "model": "gpt-4o-mini"}
        )


def test_dify_plugin_llm_config_rejects_non_positive_context_window() -> None:
    with pytest.raises(ValidationError):
        _ = DifyPluginLLMLayerConfig(
            plugin_id="langgenius/openai", model_provider="openai", model="gpt-4o-mini", context_window_tokens=0
        )


def test_dify_plugin_tools_layer_config_accepts_prepared_parameters_and_schema() -> None:
    runtime_value: DifyPluginToolValue = {"locale": "en-US", "max_results": 5}
    credential_type: DifyPluginToolCredentialType = "api-key"
    config = DifyPluginToolsLayerConfig(
        tools=[
            DifyPluginToolConfig(
                plugin_id="langgenius/tools",
                provider="search",
                tool_name="web_search",
                credential_type=credential_type,
                name="search_web",
                description="Search the web.",
                credentials={"api_key": "secret"},
                runtime_parameters={"settings": runtime_value},
                parameters=[
                    DifyPluginToolParameter(
                        name="query",
                        type=DifyPluginToolParameterType.STRING,
                        form=DifyPluginToolParameterForm.LLM,
                        required=True,
                        llm_description="Search query",
                    )
                ],
                parameters_json_schema={
                    "type": "object",
                    "properties": {"query": {"type": "string", "description": "Search query"}},
                    "required": ["query"],
                },
                plugin_unique_identifier="langgenius/tools:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            )
        ]
    )
    assert config.tools[0].plugin_id == "langgenius/tools"
    assert config.tools[0].provider == "search"
    assert config.tools[0].tool_name == "web_search"
    assert config.tools[0].credential_type == "api-key"
    assert config.tools[0].name == "search_web"
    assert config.tools[0].runtime_parameters == {"settings": {"locale": "en-US", "max_results": 5}}
    assert config.tools[0].parameters[0].name == "query"
    assert config.tools[0].parameters_json_schema["required"] == ["query"]


def test_dify_plugin_tool_parameter_accepts_api_tool_parameter_dump_shape() -> None:
    parameter = DifyPluginToolParameter.model_validate(
        {
            "name": "query",
            "label": {"en_US": "Query"},
            "placeholder": None,
            "human_description": {"en_US": "Visible in UI"},
            "type": "select",
            "form": "llm",
            "required": True,
            "default": "dify",
            "llm_description": "Search query",
            "input_schema": {"type": "string"},
            "options": [{"value": "dify", "label": {"en_US": "Dify"}}],
        }
    )
    assert parameter.name == "query"
    assert parameter.type is DifyPluginToolParameterType.SELECT
    assert parameter.form is DifyPluginToolParameterForm.LLM
    assert parameter.required is True
    assert parameter.default == "dify"
    assert parameter.input_schema == {"type": "string"}
    assert [option.value for option in parameter.options] == ["dify"]


def test_dify_plugin_tool_parameter_accepts_api_tool_parameter_attributes() -> None:
    parameter = DifyPluginToolParameter.model_validate(
        SimpleNamespace(
            name="language",
            label=SimpleNamespace(en_US="Language"),
            type="string",
            form="form",
            required=False,
            default="en",
            llm_description=None,
            input_schema=None,
            options=[SimpleNamespace(value="en", label=SimpleNamespace(en_US="English"))],
        )
    )
    assert parameter.name == "language"
    assert parameter.type is DifyPluginToolParameterType.STRING
    assert parameter.form is DifyPluginToolParameterForm.FORM
    assert parameter.default == "en"
    assert [option.value for option in parameter.options] == ["en"]


def test_dify_plugin_tool_config_rejects_non_json_runtime_parameters() -> None:
    with pytest.raises(ValidationError):
        _ = DifyPluginToolConfig.model_validate(
            {
                "plugin_id": "langgenius/tools",
                "provider": "search",
                "tool_name": "web_search",
                "credential_type": "api-key",
                "runtime_parameters": {"bad": object()},
                "plugin_unique_identifier": "langgenius/tools:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            }
        )


def test_dify_plugin_tool_config_rejects_non_json_schema_values() -> None:
    with pytest.raises(ValidationError):
        _ = DifyPluginToolConfig.model_validate(
            {
                "plugin_id": "langgenius/tools",
                "provider": "search",
                "tool_name": "web_search",
                "credential_type": "api-key",
                "parameters_json_schema": {"type": object()},
                "plugin_unique_identifier": "langgenius/tools:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            }
        )


def test_dify_plugin_tool_config_rejects_strict_flag() -> None:
    with pytest.raises(ValidationError):
        _ = DifyPluginToolConfig.model_validate(
            {
                "plugin_id": "langgenius/tools",
                "provider": "search",
                "tool_name": "web_search",
                "credential_type": "api-key",
                "strict": True,
                "plugin_unique_identifier": "langgenius/tools:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            }
        )


def test_dify_plugin_tool_config_requires_explicit_credential_type() -> None:
    with pytest.raises(ValidationError):
        _ = DifyPluginToolConfig.model_validate(
            {
                "plugin_id": "langgenius/tools",
                "provider": "search",
                "tool_name": "web_search",
                "plugin_unique_identifier": "langgenius/tools:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            }
        )