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.8 KB
Raw Blame
"""Unit tests for the Agent tool inner invoke service."""

from collections.abc import Generator
from dataclasses import dataclass, field
from unittest.mock import patch

import pytest
from sqlalchemy.orm import Session

from core.app.entities.app_invoke_entities import InvokeFrom, UserFrom
from core.tools.__base.tool_runtime import ToolRuntime
from core.tools.entities.tool_entities import ToolInvokeFrom, ToolInvokeMessage, ToolProviderType
from core.tools.errors import (
    ToolInvokeError,
    ToolParameterValidationError,
    ToolProviderCredentialValidationError,
    ToolProviderNotFoundError,
)
from models.model import App, AppMode
from services.agent_tool_inner_service import AgentToolInnerService
from services.entities.agent_tool_inner import AgentToolInvokeRequest
from services.errors.agent_tool_inner import AgentToolInnerServiceError


def _request() -> AgentToolInvokeRequest:
    return AgentToolInvokeRequest.model_validate(
        {
            "caller": {
                "tenant_id": "tenant-1",
                "user_id": "user-1",
                "user_from": "account",
                "app_id": "app-1",
                "invoke_from": "service-api",
                "conversation_id": "conversation-1",
                "workflow_id": "workflow-1",
                "workflow_run_id": "workflow-run-1",
                "node_id": "node-1",
                "node_execution_id": "node-exec-1",
                "agent_id": "agent-1",
                "agent_config_version_id": "snapshot-1",
                "trace_session_id": "trace-session-1",
            },
            "tool": {
                "provider_type": "plugin",
                "provider_id": "langgenius/search/search",
                "tool_name": "search",
                "credential_id": "credential-1",
                "tool_parameters": {"query": "dify"},
                "runtime_parameters": {"region": "us"},
            },
        }
    )


@dataclass
class _FakeTool:
    """Stands in for the resolved agent tool; only its runtime is mutated by the service."""

    runtime: ToolRuntime = field(default_factory=lambda: ToolRuntime(tenant_id="tenant-1"))


def _persist_app(session: Session, *, tenant_id: str = "tenant-1") -> App:
    app = App(
        id="app-1",
        tenant_id=tenant_id,
        name="Agent tool gateway test app",
        description="",
        mode=AppMode.AGENT_CHAT,
        enable_site=False,
        enable_api=False,
        max_active_requests=None,
    )
    session.add(app)
    session.commit()
    return app


def _messages() -> Generator[ToolInvokeMessage]:
    yield ToolInvokeMessage(
        type=ToolInvokeMessage.MessageType.TEXT,
        message=ToolInvokeMessage.TextMessage(text="ok"),
    )


@pytest.mark.parametrize(
    ("workflow_id", "expected_tool_invoke_from"),
    [
        ("workflow-1", ToolInvokeFrom.WORKFLOW),
        (None, ToolInvokeFrom.AGENT),
    ],
)
def test_invoke_uses_agent_tool_runtime_and_returns_observation(
    sqlite_session: Session,
    workflow_id: str | None,
    expected_tool_invoke_from: ToolInvokeFrom,
) -> None:
    fake_tool = _FakeTool()
    _persist_app(sqlite_session)

    with (
        patch(
            "services.agent_tool_inner_service.ToolManager.get_agent_tool_runtime",
            return_value=fake_tool,
        ) as mock_get_runtime,
        patch("services.agent_tool_inner_service.ToolEngine.generic_invoke", return_value=_messages()) as mock_invoke,
        patch(
            "services.agent_tool_inner_service.ToolFileMessageTransformer.transform_tool_invoke_messages",
            side_effect=lambda messages, **_kwargs: messages,
        ),
    ):
        request = _request()
        request.caller.workflow_id = workflow_id
        response = AgentToolInnerService().invoke(request, session=sqlite_session)

    assert response.observation == "ok"
    assert response.metadata == {
        "provider_type": "plugin",
        "provider_id": "langgenius/search/search",
        "tool_name": "search",
    }
    agent_tool = mock_get_runtime.call_args.kwargs["agent_tool"]
    assert agent_tool.provider_type is ToolProviderType.PLUGIN
    assert agent_tool.tool_parameters == {"region": "us"}
    assert fake_tool.runtime.dify_run_context is not None
    assert fake_tool.runtime.dify_run_context.tenant_id == "tenant-1"
    assert fake_tool.runtime.dify_run_context.app_id == "app-1"
    assert fake_tool.runtime.dify_run_context.user_id == "user-1"
    assert fake_tool.runtime.dify_run_context.user_from is UserFrom.ACCOUNT
    assert fake_tool.runtime.dify_run_context.invoke_from is InvokeFrom.SERVICE_API
    assert fake_tool.runtime.dify_run_context.trace_session_id == "trace-session-1"
    assert fake_tool.runtime.tool_invoke_from is expected_tool_invoke_from
    mock_invoke.assert_called_once()


def test_invoke_raises_app_not_found_when_session_has_no_app(sqlite_session: Session) -> None:
    with pytest.raises(AgentToolInnerServiceError) as exc_info:
        AgentToolInnerService().invoke(_request(), session=sqlite_session)

    assert exc_info.value.error_code == "app_not_found"
    assert exc_info.value.status_code == 404
    assert exc_info.value.description == "App not found."


def test_invoke_raises_app_tenant_mismatch_when_app_belongs_to_other_tenant(sqlite_session: Session) -> None:
    _persist_app(sqlite_session, tenant_id="tenant-2")

    with pytest.raises(AgentToolInnerServiceError) as exc_info:
        AgentToolInnerService().invoke(_request(), session=sqlite_session)

    assert exc_info.value.error_code == "app_tenant_mismatch"
    assert exc_info.value.status_code == 403
    assert exc_info.value.description == "App does not belong to the caller tenant."


def test_invoke_maps_tool_runtime_app_not_found_value_error_to_specific_error_code(sqlite_session: Session) -> None:
    fake_tool = _FakeTool()
    _persist_app(sqlite_session)

    with (
        patch("services.agent_tool_inner_service.ToolManager.get_agent_tool_runtime", return_value=fake_tool),
        patch("services.agent_tool_inner_service.ToolEngine.generic_invoke", side_effect=ValueError("app not found")),
    ):
        with pytest.raises(AgentToolInnerServiceError) as exc_info:
            AgentToolInnerService().invoke(_request(), session=sqlite_session)

    assert exc_info.value.error_code == "app_not_found"
    assert exc_info.value.status_code == 404
    assert exc_info.value.description == "App not found."


def test_invoke_maps_tool_invoke_error_without_private_tool_engine_helper(sqlite_session: Session) -> None:
    fake_tool = _FakeTool()
    _persist_app(sqlite_session)

    with (
        patch("services.agent_tool_inner_service.ToolManager.get_agent_tool_runtime", return_value=fake_tool),
        patch(
            "services.agent_tool_inner_service.ToolEngine.generic_invoke",
            side_effect=ToolInvokeError("workflow crashed"),
        ),
    ):
        with pytest.raises(AgentToolInnerServiceError) as exc_info:
            AgentToolInnerService().invoke(_request(), session=sqlite_session)

    assert exc_info.value.error_code == "agent_tool_invoke_failed"


@pytest.mark.parametrize(
    ("error", "expected_code"),
    [
        (ToolProviderNotFoundError("provider gone"), "agent_tool_declaration_not_found"),
        (ToolProviderCredentialValidationError("credential invalid"), "agent_tool_credential_invalid"),
        (ToolParameterValidationError("query is required"), "tool_parameters_invalid"),
    ],
)
def test_invoke_maps_runtime_lookup_errors_to_service_error_codes(
    sqlite_session: Session, error: Exception, expected_code: str
) -> None:
    _persist_app(sqlite_session)

    with patch("services.agent_tool_inner_service.ToolManager.get_agent_tool_runtime", side_effect=error):
        with pytest.raises(AgentToolInnerServiceError) as exc_info:
            AgentToolInnerService().invoke(_request(), session=sqlite_session)

    assert exc_info.value.error_code == expected_code