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.

12.0 KB
Raw Blame
from collections.abc import Mapping, Sequence
from typing import Literal

import pytest
from sqlalchemy import Engine
from sqlalchemy.orm import Session

from core.workflow.nodes.human_input.entities import HumanInputNodeData
from core.workflow.workflow_entry import WorkflowEntry
from graphon.entities.graph_config import NodeConfigDictAdapter
from graphon.nodes.list_operator.entities import FilterOperator
from graphon.runtime import VariablePool
from graphon.variable_loader import DUMMY_VARIABLE_LOADER
from graphon.variables import StringSegment, VariableBase
from models.workflow import WorkflowDraftVariable
from services.workflow_draft_variable_service import DraftVarLoader
from services.workflow_node_variables import get_human_input_form_variable_mapping, load_additional_node_variables


@pytest.mark.parametrize("container_type", [None, "iteration", "loop"])
@pytest.mark.parametrize("saved_root", [False, True])
def test_human_input_body_and_email_keep_nested_editor_selectors(
    container_type: Literal["iteration", "loop"] | None, saved_root: bool
) -> None:
    human: dict[str, object] = {
        "id": "human",
        "data": {
            "type": "human-input",
            "title": "Human",
            "form_content": "Hello {{#source.object.name#}} {{#$output.comment#}}",
            "inputs": [
                {
                    "type": "paragraph",
                    "output_variable_name": "comment",
                    "default": {"type": "variable", "selector": ["source", "default"]},
                }
            ],
            "delivery_methods": [
                {
                    "type": "email",
                    "enabled": True,
                    "config": {
                        "recipients": {"items": list[object]()},
                        "subject": "Review",
                        "body": "Hello {{#source.object.email_name#}} {{#url#}}",
                    },
                },
                {
                    "type": "email",
                    "enabled": False,
                    "config": {
                        "recipients": {"items": list[object]()},
                        "subject": "Disabled",
                        "body": "{{#missing.object.name#}}",
                    },
                },
            ],
        },
    }
    nodes = [human]
    target: dict[str, object] = human
    if container_type:
        target = {"id": "container", "data": {"type": container_type, "title": "Container"}}
        nodes.insert(0, target)
    prefix = "human." if container_type else ""
    inputs = {
        f"{prefix}#source.object.name#": "Alice",
        f"{prefix}#source.object.email_name#": "Recipient",
        f"{prefix}#source.default#": "Default",
    }
    variable_pool = VariablePool()
    if saved_root:
        variable_pool.add(["source", "object"], {"name": "Old", "email_name": "Old", "keep": "Saved"})

    mapping = load_additional_node_variables(
        node_config=NodeConfigDictAdapter.validate_python(target),
        graph_config={"nodes": nodes},
        variable_mapping={},
        variable_loader=DUMMY_VARIABLE_LOADER,
        variable_pool=variable_pool,
        user_inputs=inputs,
    )
    WorkflowEntry.mapping_user_inputs_to_variable_pool(
        variable_mapping=mapping, user_inputs=inputs, variable_pool=variable_pool, tenant_id="tenant"
    )

    assert mapping == {
        f"{prefix}human.#source.object.name#": ["source", "object", "name"],
        f"{prefix}human.#source.object.email_name#": ["source", "object", "email_name"],
        f"{prefix}human.#source.default#": ["source", "default"],
    }
    variable = variable_pool.get(["source", "object"])
    assert variable is not None
    assert variable.value == {
        "name": "Alice",
        "email_name": "Recipient",
        **({"keep": "Saved"} if saved_root else {}),
    }
    assert get_human_input_form_variable_mapping("human", HumanInputNodeData.model_validate(human["data"])) == {
        "human.#source.object.name#": ["source", "object", "name"],
        "human.#source.default#": ["source", "default"],
    }


@pytest.mark.parametrize("operator", [FilterOperator.EMPTY, FilterOperator.NOT_EMPTY])
def test_value_free_list_filters_do_not_require_stale_operands(
    operator: FilterOperator, monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine
) -> None:
    config = NodeConfigDictAdapter.validate_python(
        {
            "id": "list",
            "data": {
                "type": "list-operator",
                "title": "List",
                "variable": ["source", "items"],
                "filter_by": {
                    "enabled": True,
                    "conditions": [{"comparison_operator": operator, "value": "{{#deleted.old#}}"}],
                },
                "order_by": {"enabled": False},
                "limit": {"enabled": False},
            },
        }
    )
    loader = DraftVarLoader(sqlite_engine, "app", "tenant", "user")
    selectors_loaded: list[list[list[str]]] = []
    original_load = loader.load_variables

    def load_variables(selectors: list[list[str]]) -> list[VariableBase]:
        selectors_loaded.append(selectors)
        return original_load(selectors)

    monkeypatch.setattr(loader, "load_variables", load_variables)

    mapping = load_additional_node_variables(
        node_config=config,
        graph_config={"nodes": [config]},
        variable_mapping={},
        variable_loader=loader,
        variable_pool=VariablePool(),
        user_inputs={"#source.items#": ["", "a"]},
    )

    assert mapping == {"list.#source.items#": ["source", "items"]}
    assert selectors_loaded == [[]]


@pytest.mark.parametrize(
    ("data", "inputs", "expected"),
    [
        (
            {
                "type": "human-input",
                "form_content": "Review {{#source.content#}} and {{#$output.comment#}}",
                "inputs": [
                    {
                        "type": "paragraph",
                        "output_variable_name": "comment",
                        "default": {"type": "variable", "selector": ["source", "default"]},
                    }
                ],
            },
            {"#source.content#": "review", "#source.default#": "comment"},
            {"node.#source.content#": ["source", "content"], "node.#source.default#": ["source", "default"]},
        ),
        (
            {
                "type": "knowledge-index",
                "chunk_structure": "text_model",
                "index_chunk_variable_selector": ["source", "chunks"],
            },
            {"query": {"general_chunks": ["content"]}},
            {"node.query": ["source", "chunks"]},
        ),
    ],
)
def test_dify_node_input_mappings(
    data: Mapping[str, object], inputs: Mapping[str, object], expected: Mapping[str, Sequence[str]]
) -> None:
    config = NodeConfigDictAdapter.validate_python({"id": "node", "data": {"title": "Node", **data}})

    mapping = load_additional_node_variables(
        node_config=config,
        graph_config={"nodes": [config]},
        variable_mapping={},
        variable_loader=DUMMY_VARIABLE_LOADER,
        variable_pool=VariablePool(),
        user_inputs=inputs,
    )

    assert mapping == expected


def test_missing_end_input_loads_saved_draft_value(
    monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine, sqlite_session: Session
) -> None:
    config = NodeConfigDictAdapter.validate_python(
        {
            "id": "end",
            "data": {
                "type": "end",
                "title": "End",
                "outputs": [{"variable": "result", "value_selector": ["source", "value"]}],
            },
        }
    )
    variable_pool = VariablePool()
    sqlite_session.add(
        WorkflowDraftVariable.new_node_variable(
            app_id="app",
            user_id="user",
            node_id="source",
            name="value",
            value=StringSegment(value="saved"),
            node_execution_id="execution",
        )
    )
    sqlite_session.commit()
    loader = DraftVarLoader(sqlite_engine, "app", "tenant", "user")
    selectors_loaded: list[list[list[str]]] = []
    original_load = loader.load_variables

    def load_variables(selectors: list[list[str]]) -> list[VariableBase]:
        selectors_loaded.append(selectors)
        return original_load(selectors)

    monkeypatch.setattr(loader, "load_variables", load_variables)

    mapping = load_additional_node_variables(
        node_config=config,
        graph_config={"nodes": [config]},
        variable_mapping={},
        variable_loader=loader,
        variable_pool=variable_pool,
        user_inputs={},
    )

    assert mapping == {"end.#source.value#": ["source", "value"]}
    assert selectors_loaded == [[["source", "value"]]]
    variable = variable_pool.get(["source", "value"])
    assert variable is not None
    assert variable.value == "saved"


def test_unavailable_end_output_remains_unset_after_draft_loading(
    monkeypatch: pytest.MonkeyPatch, sqlite_engine: Engine
) -> None:
    config = NodeConfigDictAdapter.validate_python(
        {
            "id": "end",
            "data": {
                "type": "end",
                "title": "End",
                "outputs": [{"variable": "result", "value_selector": ["source", "missing"]}],
            },
        }
    )
    variable_pool = VariablePool()
    loader = DraftVarLoader(sqlite_engine, "app", "tenant", "user")
    selectors_loaded: list[list[list[str]]] = []
    original_load = loader.load_variables

    def load_variables(selectors: list[list[str]]) -> list[VariableBase]:
        selectors_loaded.append(selectors)
        return original_load(selectors)

    monkeypatch.setattr(loader, "load_variables", load_variables)

    mapping = load_additional_node_variables(
        node_config=config,
        graph_config={"nodes": [config]},
        variable_mapping={},
        variable_loader=loader,
        variable_pool=variable_pool,
        user_inputs={},
    )

    assert selectors_loaded == [[["source", "missing"]]]
    assert mapping == {}
    assert variable_pool.get(["source", "missing"]) is None


def test_container_loads_external_inputs_and_skips_internal_outputs_and_disabled_settings() -> None:
    container = {"id": "iteration", "data": {"type": "iteration", "title": "Iteration"}}
    operator = {
        "id": "list",
        "data": {
            "type": "list-operator",
            "title": "List",
            "variable": ["source", "items"],
            "filter_by": {"enabled": True, "conditions": [{"value": "{{#source.filter#}}"}]},
            "extract_by": {"enabled": False, "serial": "{{#source.unused#}}"},
            "order_by": {"enabled": False},
            "limit": {"enabled": False},
        },
    }
    aggregator = {
        "id": "aggregate",
        "data": {
            "type": "variable-aggregator",
            "title": "Aggregate",
            "output_type": "array[string]",
            "variables": [["source", "unused"]],
            "advanced_settings": {
                "group_enabled": True,
                "groups": [
                    {
                        "output_type": "array[string]",
                        "group_name": "group",
                        "variables": [["list", "result"], ["source", "missing"], ["source", "fallback"]],
                    }
                ],
            },
        },
    }
    variable_pool = VariablePool()
    variable_pool.add(["source", "fallback"], ["saved"])

    mapping = load_additional_node_variables(
        node_config=NodeConfigDictAdapter.validate_python(container),
        graph_config={"nodes": [container, operator, aggregator]},
        variable_mapping={"iteration.iterator": ["source", "iterator"]},
        variable_loader=DUMMY_VARIABLE_LOADER,
        variable_pool=variable_pool,
        user_inputs={"list.#source.items#": ["one"], "list.#source.filter#": "one"},
    )

    assert mapping == {
        "iteration.iterator": ["source", "iterator"],
        "list.list.#source.items#": ["source", "items"],
        "list.list.#source.filter#": ["source", "filter"],
        "aggregate.aggregate.#source.fallback#": ["source", "fallback"],
    }