aiagent/backend/tests/test_workflow_engine.py

"""
工作流执行引擎测试

覆盖 workflow_engine.py 核心路径：DAG拓扑/环检测/条件分支/审批/路径安全/eval限制
"""
import asyncio
import pytest
from app.services.workflow_engine import WorkflowEngine
from app.core.exceptions import WorkflowExecutionError


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineDAG:
    """DAG 执行图构建与拓扑排序"""

    def test_build_execution_graph_linear(self):
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "llm-1", "type": "llm"},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "llm-1"},
                {"id": "e2", "source": "llm-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-linear", workflow_data)
        order = engine.build_execution_graph()
        assert order.index("start-1") < order.index("llm-1")
        assert order.index("llm-1") < order.index("end-1")
        assert len(order) == 3

    def test_build_execution_graph_branching(self):
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "condition-1", "type": "condition"},
                {"id": "llm-a", "type": "llm"},
                {"id": "llm-b", "type": "llm"},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "condition-1"},
                {"id": "e2", "source": "condition-1", "target": "llm-a"},
                {"id": "e3", "source": "condition-1", "target": "llm-b"},
                {"id": "e4", "source": "llm-a", "target": "end-1"},
                {"id": "e5", "source": "llm-b", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-branch", workflow_data)
        order = engine.build_execution_graph()
        assert order.index("start-1") == 0
        assert order.index("condition-1") < order.index("llm-a")
        assert order.index("condition-1") < order.index("llm-b")
        assert order.index("llm-a") < order.index("end-1")
        assert order.index("llm-b") < order.index("end-1")

    def test_cycle_detection_raises_error(self):
        workflow_data = {
            "nodes": [
                {"id": "a", "type": "llm"},
                {"id": "b", "type": "llm"},
            ],
            "edges": [
                {"id": "e1", "source": "a", "target": "b"},
                {"id": "e2", "source": "b", "target": "a"},
            ],
        }
        engine = WorkflowEngine("test-cycle", workflow_data)
        with pytest.raises(WorkflowExecutionError):
            engine.build_execution_graph()

    def test_self_loop_detection(self):
        workflow_data = {
            "nodes": [
                {"id": "a", "type": "llm"},
            ],
            "edges": [
                {"id": "e1", "source": "a", "target": "a"},
            ],
        }
        engine = WorkflowEngine("test-self-loop", workflow_data)
        with pytest.raises(WorkflowExecutionError):
            engine.build_execution_graph()

    def test_disconnected_node_ordering(self):
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "orphan", "type": "llm"},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-orphan", workflow_data)
        order = engine.build_execution_graph()
        # orphan has no incoming edges and is a start node
        assert "start-1" in order
        assert "end-1" in order
        assert "orphan" in order

    def test_active_edges_filter(self):
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "llm-1", "type": "llm"},
                {"id": "llm-2", "type": "llm"},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "llm-1"},
                {"id": "e2", "source": "start-1", "target": "llm-2"},
                {"id": "e3", "source": "llm-1", "target": "end-1"},
                {"id": "e4", "source": "llm-2", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-active", workflow_data)
        active = [
            {"id": "e1", "source": "start-1", "target": "llm-1"},
            {"id": "e3", "source": "llm-1", "target": "end-1"},
        ]
        order = engine.build_execution_graph(active_edges=active)
        # llm-2 still appears (no incoming edges in subgraph = start)
        # but start-1 → llm-1 → end-1 order is preserved
        assert "start-1" in order
        assert "llm-1" in order
        assert order.index("start-1") < order.index("llm-1")
        assert order.index("llm-1") < order.index("end-1")
        assert "end-1" in order


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEnginePathSafety:
    """路径安全：_resolve_safe_path"""

    def test_safe_path_within_workspace(self):
        engine = WorkflowEngine("test-safe", {"nodes": [], "edges": []})
        result = engine._resolve_safe_path("data/output.txt")
        assert "data" in result or "output.txt" in result

    def test_safe_path_traversal_blocked(self):
        engine = WorkflowEngine("test-traversal", {"nodes": [], "edges": []})
        with pytest.raises(ValueError, match="路径访问被拒绝"):
            engine._resolve_safe_path("../../../etc/passwd")

    def test_safe_path_absolute_blocked(self):
        engine = WorkflowEngine("test-abs", {"nodes": [], "edges": []})
        with pytest.raises(ValueError, match="路径访问被拒绝"):
            engine._resolve_safe_path("C:/Windows/System32/evil.dll")


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineNodeExecution:
    """节点执行测试"""

    def test_get_node_input_basic(self):
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "llm-1", "type": "llm"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "llm-1"},
            ],
        }
        engine = WorkflowEngine("test-input", workflow_data)
        engine.node_outputs = {"start-1": {"input": "test data"}}
        result = engine.get_node_input("llm-1", engine.node_outputs)
        assert "input" in result

    def test_get_node_input_multiple_sources(self):
        workflow_data = {
            "nodes": [
                {"id": "src-a", "type": "llm"},
                {"id": "src-b", "type": "llm"},
                {"id": "merge-1", "type": "llm"},
            ],
            "edges": [
                {"id": "e1", "source": "src-a", "target": "merge-1"},
                {"id": "e2", "source": "src-b", "target": "merge-1"},
            ],
        }
        engine = WorkflowEngine("test-merge", workflow_data)
        engine.node_outputs = {
            "src-a": {"field_a": "value_a"},
            "src-b": {"field_b": "value_b"},
        }
        result = engine.get_node_input("merge-1", engine.node_outputs)
        assert "field_a" in result or "field_b" in result

    @pytest.mark.asyncio
    async def test_execute_start_node(self):
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start", "data": {"label": "开始"}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-start", workflow_data)
        result = await engine.execute_node(workflow_data["nodes"][0], {"test": "data"})
        assert result["status"] == "success"
        assert result["output"] == {"test": "data"}

    @pytest.mark.asyncio
    async def test_execute_end_node(self):
        workflow_data = {
            "nodes": [
                {"id": "end-1", "type": "end", "data": {"label": "结束"}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-end", workflow_data)
        input_data = {"result": "final output"}
        result = await engine.execute_node(workflow_data["nodes"][0], input_data)
        assert result["status"] == "success"

    @pytest.mark.asyncio
    async def test_execute_condition_node_true(self):
        workflow_data = {
            "nodes": [
                {"id": "condition-1", "type": "condition",
                 "data": {"label": "判断", "condition": "{value} > 10"}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-cond-true", workflow_data)
        result = await engine.execute_node(workflow_data["nodes"][0], {"value": 15})
        assert result["status"] == "success"
        # branch should be "true" when value > 10
        assert result["branch"] == "true"

    @pytest.mark.asyncio
    async def test_execute_condition_node_false(self):
        workflow_data = {
            "nodes": [
                {"id": "condition-1", "type": "condition",
                 "data": {"label": "判断", "condition": "{value} > 10"}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-cond-false", workflow_data)
        result = await engine.execute_node(workflow_data["nodes"][0], {"value": 5})
        assert result["status"] == "success"
        assert result["branch"] == "false"

    @pytest.mark.asyncio
    async def test_execute_transform_node_mapping(self):
        workflow_data = {
            "nodes": [
                {"id": "transform-1", "type": "transform",
                 "data": {"label": "转换", "mode": "mapping",
                          "mapping": {"new_field": "{old_field}"}}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-xform", workflow_data)
        result = await engine.execute_node(workflow_data["nodes"][0], {"old_field": "test value"})
        assert result["status"] == "success"

    @pytest.mark.asyncio
    async def test_execute_transform_data_merge(self):
        """数据转换节点合并输入数据"""
        workflow_data = {
            "nodes": [
                {"id": "transform-1", "type": "transform",
                 "data": {"label": "转换"}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-xform2", workflow_data)
        result = await engine.execute_node(workflow_data["nodes"][0], {"key": "value"})
        assert result["status"] in ("success", "error")
        assert "output" in result


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineEvalSafety:
    """eval() 安全限制测试"""

    @pytest.mark.asyncio
    async def test_eval_length_limit(self):
        """超长表达式被拒绝"""
        workflow_data = {
            "nodes": [
                {"id": "condition-1", "type": "condition",
                 "data": {"label": "检查", "condition": "x" * 20000}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-len", workflow_data)
        # 超长 condition 表达式应触发错误，不会导致崩溃
        result = await engine.execute_node(workflow_data["nodes"][0], {"x": 1})
        # 要么抛异常，要么返回失败状态
        assert result["status"] in ("success", "error")

    @pytest.mark.asyncio
    async def test_condition_with_template_vars(self):
        """条件表达式含模板变量"""
        workflow_data = {
            "nodes": [
                {"id": "condition-1", "type": "condition",
                 "data": {"label": "判断", "condition": "{count} >= 5"}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-cond-var", workflow_data)
        result = await engine.execute_node(workflow_data["nodes"][0], {"count": 10})
        assert result["status"] == "success"
        assert result["branch"] == "true"


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineApproval:
    """审批/HIL 节点测试"""

    def test_approval_node_isolated_keys(self):
        workflow_data = {
            "nodes": [
                {"id": "hil-1", "type": "human_in_loop",
                 "data": {"label": "审批1", "approvers": ["user1"]}},
                {"id": "hil-2", "type": "human_in_loop",
                 "data": {"label": "审批2", "approvers": ["user2"]}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-hil", workflow_data)
        assert engine.nodes["hil-1"]["id"] != engine.nodes["hil-2"]["id"]


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineEdgeCases:
    """边界情况"""

    def test_empty_workflow(self):
        workflow_data = {"nodes": [], "edges": []}
        engine = WorkflowEngine("test-empty", workflow_data)
        order = engine.build_execution_graph()
        assert order == []

    def test_single_node_no_edges(self):
        workflow_data = {
            "nodes": [{"id": "only", "type": "llm"}],
            "edges": [],
        }
        engine = WorkflowEngine("test-single", workflow_data)
        order = engine.build_execution_graph()
        assert order == ["only"]

    def test_missing_node_in_edge(self):
        workflow_data = {
            "nodes": [{"id": "a", "type": "start"}],
            "edges": [{"id": "e1", "source": "a", "target": "nonexistent"}],
        }
        engine = WorkflowEngine("test-missing", workflow_data)
        order = engine.build_execution_graph()
        assert "a" in order


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineRetry:
    """节点级自动重试 & error_handler 重试测试"""

    # ── error_handler 节点独立测试 ──

    @pytest.mark.asyncio
    async def test_error_handler_notify_on_failed_upstream(self):
        """error_handler 检测上游失败 → notify 模式记录错误"""
        workflow_data = {
            "nodes": [
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "notify", "retry_count": 3}},
            ],
            "edges": [
                {"id": "e1", "source": "bad-node", "target": "eh-1"},
            ],
        }
        engine = WorkflowEngine("test-eh-notify", workflow_data)
        # 模拟上游失败输入
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"status": "failed", "error": "模拟失败", "output": {}}
        )
        assert result["status"] == "error_handled"
        assert result["notified"] is True
        assert "模拟失败" in result["error"]

    @pytest.mark.asyncio
    async def test_error_handler_retry_mode(self):
        """error_handler 检测上游失败 → retry 模式请求重试前驱"""
        workflow_data = {
            "nodes": [
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "retry", "retry_count": 3, "retry_delay": 500}},
            ],
            "edges": [
                {"id": "e1", "source": "bad-node", "target": "eh-1"},
            ],
        }
        engine = WorkflowEngine("test-eh-retry", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"status": "failed", "error": "上游错误"}
        )
        assert result["status"] == "retry_predecessor"
        assert result["predecessor_id"] == "bad-node"
        assert result["retry_count"] == 3
        assert result["retry_delay_ms"] == 500

    @pytest.mark.asyncio
    async def test_error_handler_stop_mode(self):
        """error_handler on_error=stop → 停止工作流"""
        workflow_data = {
            "nodes": [
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "stop"}},
            ],
            "edges": [
                {"id": "e1", "source": "bad-node", "target": "eh-1"},
            ],
        }
        engine = WorkflowEngine("test-eh-stop", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"status": "failed", "error": "致命错误"}
        )
        assert result["status"] == "failed"
        assert result["stopped"] is True

    @pytest.mark.asyncio
    async def test_error_handler_passthrough_on_success(self):
        """error_handler 上游正常 → 透传"""
        workflow_data = {
            "nodes": [
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "notify"}},
            ],
            "edges": [
                {"id": "e1", "source": "good-node", "target": "eh-1"},
            ],
        }
        engine = WorkflowEngine("test-eh-pass", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"status": "success", "output": {"result": "ok"}}
        )
        assert result["status"] == "success"

    @pytest.mark.asyncio
    async def test_error_handler_non_dict_input(self):
        """error_handler 接收非 dict 输入 → 当作成功透传"""
        workflow_data = {
            "nodes": [
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "notify"}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eh-nondict", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            "plain string input"
        )
        assert result["status"] == "success"

    # ── 节点级 retry_config 集成测试（使用 code 节点触发可控失败）──

    @pytest.mark.asyncio
    async def test_retry_config_exhausted_raises_error(self):
        """节点 retry_config 重试耗尽 → WorkflowExecutionError"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "code-1", "type": "code",
                 "data": {
                     "language": "python",
                     "code": "raise Exception('code node failure')",
                     "retry_config": {"max_retries": 2, "retry_delay_ms": 10}
                 }},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "code-1"},
                {"id": "e2", "source": "code-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-retry-exhaust", workflow_data)
        with pytest.raises(WorkflowExecutionError) as exc_info:
            await engine.execute({"value": 10})
        assert "执行失败" in str(exc_info.value.detail)

    @pytest.mark.asyncio
    async def test_retry_config_skip_on_exhausted(self):
        """节点 retry_config on_exhausted=skip → 跳过节点继续执行"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "code-1", "type": "code",
                 "data": {
                     "language": "python",
                     "code": "raise Exception('fail')",
                     "retry_config": {
                         "max_retries": 1,
                         "retry_delay_ms": 10,
                         "on_exhausted": "skip"
                     }
                 }},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "code-1"},
                {"id": "e2", "source": "code-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-retry-skip", workflow_data)
        result = await engine.execute({"value": 10})
        assert result["status"] in ("success", "completed")
        assert engine.node_outputs["code-1"]["status"] == "skipped"

    @pytest.mark.asyncio
    async def test_retry_config_notify_on_exhausted(self):
        """节点 retry_config on_exhausted=notify → 标记错误并继续"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "code-1", "type": "code",
                 "data": {
                     "language": "python",
                     "code": "raise Exception('fail')",
                     "retry_config": {
                         "max_retries": 1,
                         "retry_delay_ms": 10,
                         "on_exhausted": "notify"
                     }
                 }},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "code-1"},
                {"id": "e2", "source": "code-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-retry-notify", workflow_data)
        result = await engine.execute({"value": 10})
        assert result["status"] in ("success", "completed")
        assert engine.node_outputs["code-1"]["status"] == "error_notified"

    @pytest.mark.asyncio
    async def test_no_retry_config_fails_immediately(self):
        """节点无 retry_config → 失败立即抛 WorkflowExecutionError"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "code-1", "type": "code",
                 "data": {"language": "python", "code": "raise Exception('fatal')"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "code-1"},
                {"id": "e2", "source": "code-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-noretry", workflow_data)
        with pytest.raises(WorkflowExecutionError) as exc_info:
            await engine.execute({"value": 10})
        assert "执行失败" in str(exc_info.value.detail)

    # ── error_handler + retry_config 协同 ──

    @pytest.mark.asyncio
    async def test_error_handler_retry_workflow(self):
        """error_handler notify 模式在节点失败后兜底 → 工作流继续"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "code-1", "type": "code",
                 "data": {
                     "language": "python",
                     "code": "raise Exception('fail')",
                     "retry_config": {
                         "max_retries": 1,
                         "on_exhausted": "notify"
                     }
                 }},
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "notify"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "code-1"},
                {"id": "e2", "source": "code-1", "target": "eh-1"},
                {"id": "e3", "source": "eh-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-eh-wf", workflow_data)
        # code-1 失败 → retry 1次再失败 → exhausted=notify → 标记 error_notified
        # → eh-1 接收输出并透传 → end-1 完成
        result = await engine.execute({"value": 10})
        assert result["status"] in ("success", "completed")

    @pytest.mark.asyncio
    async def test_retry_config_with_error_handler_chain(self):
        """节点 retry_config 先触发 → 耗尽后 error_handler 兜底 notify"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "code-1", "type": "code",
                 "data": {
                     "language": "python",
                     "code": "raise Exception('fail')",
                     "retry_config": {
                         "max_retries": 1,
                         "retry_delay_ms": 10,
                         "on_exhausted": "notify"
                     }
                 }},
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "notify"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "code-1"},
                {"id": "e2", "source": "code-1", "target": "end-1"},
                {"id": "e3", "source": "code-1", "target": "eh-1"},
                {"id": "e4", "source": "eh-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-retry-eh-chain", workflow_data)
        result = await engine.execute({"value": 10})
        assert result["status"] in ("success", "completed")

    @pytest.mark.asyncio
    async def test_retry_config_zero_retries(self):
        """retry_config max_retries=0 → 无重试立即失败"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "code-1", "type": "code",
                 "data": {
                     "language": "python",
                     "code": "raise Exception('fail')",
                     "retry_config": {"max_retries": 0}
                 }},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "code-1"},
                {"id": "e2", "source": "code-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-retry0", workflow_data)
        with pytest.raises(WorkflowExecutionError) as exc_info:
            await engine.execute({"value": 10})
        assert "执行失败" in str(exc_info.value.detail)


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineEvaluator:
    """输出质量评估节点测试（LLM 调用已 mock）"""

    @staticmethod
    async def _mock_judge_pass(*args, **kwargs):
        """模拟评审通过"""
        return '{"score": 0.85, "passed": true, "issues": [], "suggestions": [], "summary": "good"}'

    @staticmethod
    async def _mock_judge_fail(*args, **kwargs):
        """模拟评审不通过"""
        return '{"score": 0.3, "passed": false, "issues": ["不完整"], "suggestions": ["补充细节"], "summary": "poor"}'

    @pytest.mark.asyncio
    async def test_evaluator_passes_high_quality(self, monkeypatch):
        """evaluator 评审高分 → passed=true, branch=true"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_pass,
        )
        workflow_data = {
            "nodes": [
                {"id": "eval-1", "type": "evaluator",
                 "data": {"criteria": "准确性", "pass_threshold": 0.6}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-pass", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"output": "The answer is 42"}
        )
        assert result["status"] == "success"
        assert result["branch"] == "true"
        assert result["output"]["passed"] is True
        assert result["output"]["score"] == 0.85

    @pytest.mark.asyncio
    async def test_evaluator_fails_low_quality(self, monkeypatch):
        """evaluator 评审低分 → passed=false, branch=false"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_fail,
        )
        workflow_data = {
            "nodes": [
                {"id": "eval-1", "type": "evaluator",
                 "data": {"criteria": "完整性", "pass_threshold": 0.6}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-fail", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"output": "bad"}
        )
        assert result["status"] == "success"
        assert result["branch"] == "false"
        assert result["output"]["passed"] is False
        assert result["output"]["score"] == 0.3

    @pytest.mark.asyncio
    async def test_evaluator_custom_threshold(self, monkeypatch):
        """evaluator 自定义阈值：高分但阈值更高 → 不通过"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_pass,  # score=0.85
        )
        workflow_data = {
            "nodes": [
                {"id": "eval-1", "type": "evaluator",
                 "data": {"criteria": "严格", "pass_threshold": 0.9}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-threshold", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"output": "test"}
        )
        assert result["status"] == "success"
        assert result["branch"] == "false"  # 0.85 < 0.9
        assert result["output"]["threshold"] == 0.9
        assert result["output"]["passed"] is False

    @pytest.mark.asyncio
    async def test_evaluator_output_structure(self, monkeypatch):
        """evaluator 输出包含完整字段"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_pass,
        )
        workflow_data = {
            "nodes": [
                {"id": "eval-1", "type": "evaluator",
                 "data": {"criteria": "完整性", "pass_threshold": 0.5}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-out", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"output": "sample text"}
        )
        output = result.get("output", {})
        assert "score" in output
        assert isinstance(output["score"], float)
        assert "passed" in output
        assert isinstance(output["passed"], bool)
        assert "issues" in output
        assert "suggestions" in output
        assert "summary" in output

    @pytest.mark.asyncio
    async def test_evaluator_default_threshold(self, monkeypatch):
        """evaluator 默认阈值 0.6"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_pass,
        )
        workflow_data = {
            "nodes": [
                {"id": "eval-1", "type": "evaluator",
                 "data": {}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-default", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            {"output": "content"}
        )
        output = result.get("output", {})
        assert output["threshold"] == 0.6

    @pytest.mark.asyncio
    async def test_evaluator_empty_input(self, monkeypatch):
        """evaluator 处理空输入"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_pass,
        )
        workflow_data = {
            "nodes": [
                {"id": "eval-1", "type": "evaluator",
                 "data": {}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-empty", workflow_data)
        result = await engine.execute_node(workflow_data["nodes"][0], {})
        assert result is not None
        assert "output" in result

    @pytest.mark.asyncio
    async def test_evaluator_non_dict_input(self, monkeypatch):
        """evaluator 处理非 dict 输入"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_pass,
        )
        workflow_data = {
            "nodes": [
                {"id": "eval-1", "type": "evaluator",
                 "data": {}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-eval-str", workflow_data)
        result = await engine.execute_node(
            workflow_data["nodes"][0],
            "plain string content"
        )
        assert result is not None

    @pytest.mark.asyncio
    async def test_evaluator_branch_routing_workflow(self, monkeypatch):
        """evaluator 集成工作流 → branch 路由正确"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_pass,  # 通过评审
        )
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "eval-1", "type": "evaluator",
                 "data": {"criteria": "准确性", "pass_threshold": 0.6}},
                {"id": "pass-node", "type": "log",
                 "data": {"label": "通过"}},
                {"id": "fail-node", "type": "log",
                 "data": {"label": "失败"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "eval-1"},
                {"id": "e2", "source": "eval-1", "target": "pass-node",
                 "sourceHandle": "true"},
                {"id": "e3", "source": "eval-1", "target": "fail-node",
                 "sourceHandle": "false"},
                {"id": "e4", "source": "pass-node", "target": "end-1"},
                {"id": "e5", "source": "fail-node", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-eval-branch", workflow_data)
        result = await engine.execute({"output": "test content"})
        assert result["status"] in ("success", "completed")
        assert "eval-1" in engine.node_outputs

    @pytest.mark.asyncio
    async def test_evaluator_with_error_handler(self, monkeypatch):
        """evaluator 失败分支 → error_handler 兜底"""
        monkeypatch.setattr(
            "app.services.llm_service.llm_service.call_openai_with_tools",
            self._mock_judge_fail,  # 不通过
        )
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "eval-1", "type": "evaluator",
                 "data": {"criteria": "严格", "pass_threshold": 0.9}},
                {"id": "eh-1", "type": "error_handler",
                 "data": {"on_error": "notify"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "eval-1"},
                {"id": "e2", "source": "eval-1", "target": "end-1",
                 "sourceHandle": "true"},
                {"id": "e3", "source": "eval-1", "target": "eh-1",
                 "sourceHandle": "false"},
                {"id": "e4", "source": "eh-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-eval-eh", workflow_data)
        result = await engine.execute({"output": "low quality"})
        assert result["status"] in ("success", "completed")


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineParallel:
    """DAG 并行执行验证"""

    def test_parallel_ready_nodes_detection(self):
        """分支工作流中多个独立节点同时就绪"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "branch-a", "type": "log", "data": {"label": "分支A"}},
                {"id": "branch-b", "type": "log", "data": {"label": "分支B"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "branch-a"},
                {"id": "e2", "source": "start-1", "target": "branch-b"},
                {"id": "e3", "source": "branch-a", "target": "end-1"},
                {"id": "e4", "source": "branch-b", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-parallel", workflow_data)
        order = engine.build_execution_graph()
        # start-1 完成后，branch-a 和 branch-b 同时就绪
        assert order.index("start-1") < order.index("branch-a")
        assert order.index("start-1") < order.index("branch-b")

    @pytest.mark.asyncio
    async def test_parallel_execution_completes(self):
        """并行分支工作流正常完成"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "log-a", "type": "log", "data": {"label": "A"}},
                {"id": "log-b", "type": "log", "data": {"label": "B"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "log-a"},
                {"id": "e2", "source": "start-1", "target": "log-b"},
                {"id": "e3", "source": "log-a", "target": "end-1"},
                {"id": "e4", "source": "log-b", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-parallel-run", workflow_data)
        result = await engine.execute({"input": "test"})
        assert result["status"] in ("success", "completed")


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineOrchestrator:
    """Orchestrator 节点集成验证"""

    def test_orchestrator_node_type_registered(self):
        """orchestrator 节点类型在工作流引擎中已注册"""
        workflow_data = {
            "nodes": [
                {"id": "orch-1", "type": "orchestrator",
                 "data": {"mode": "sequential", "agents": ["agent-1", "agent-2"]}},
            ],
            "edges": [],
        }
        engine = WorkflowEngine("test-orch", workflow_data)
        assert "orch-1" in engine.nodes
        assert engine.nodes["orch-1"]["type"] == "orchestrator"

    def test_orchestrator_modes_available(self):
        """orchestrator 支持 5 种编排模式"""
        valid_modes = ["route", "sequential", "debate", "pipeline", "graph"]
        for mode in valid_modes:
            node_data = {"mode": mode, "agents": ["a1", "a2"]}
            # 验证模式字符串合法
            assert mode in valid_modes


@pytest.mark.unit
@pytest.mark.workflow
class TestWorkflowEngineSubworkflow:
    """子工作流/委派节点测试（subworkflow / invoke_agent）"""

    # ─── 辅助：构造一个可被子工作流调用的 mini workflow ───
    @staticmethod
    def _make_mini_workflow():
        return {
            "nodes": [
                {"id": "s-start", "type": "start"},
                {"id": "s-log", "type": "log",
                 "data": {"message": "child executed"}},
                {"id": "s-end", "type": "end"},
            ],
            "edges": [
                {"id": "se1", "source": "s-start", "target": "s-log"},
                {"id": "se2", "source": "s-log", "target": "s-end"},
            ],
        }

    def test_subworkflow_depth_limit_exceeded(self):
        """子工作流深度超限时抛出错误"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "sub-1", "type": "subworkflow",
                 "data": {"workflow_id": "wf-1", "max_subworkflow_depth": 2}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "sub-1"},
                {"id": "e2", "source": "sub-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-depth", workflow_data)
        # 模拟深度已达上限
        with pytest.raises(WorkflowExecutionError) as exc_info:
            asyncio.run(engine.execute({"__subworkflow_depth": 2}))
        assert "深度" in str(exc_info.value.detail) or "超限" in str(exc_info.value.detail)

    def test_subworkflow_build_input_mapping(self):
        """子工作流根据 input_mapping 组装输入"""
        engine = WorkflowEngine("test-map", {"nodes": [], "edges": []})
        input_data = {"x": 1, "y": 2, "z": 3}
        mapping = {"a": "x", "b": "y"}
        result = engine._build_subworkflow_input(input_data, mapping)
        assert result["a"] == 1
        assert result["b"] == 2

    def test_subworkflow_build_input_no_mapping(self):
        """无 input_mapping 时直接透传 input_data"""
        engine = WorkflowEngine("test-nomap", {"nodes": [], "edges": []})
        input_data = {"x": 1}
        result = engine._build_subworkflow_input(input_data, None)
        assert result == input_data
        result2 = engine._build_subworkflow_input(input_data, [])
        assert result2 == input_data

    def test_subworkflow_build_input_raw_value(self):
        """非 dict 输入 + 无 mapping 时包裹为 {'input': ...}"""
        engine = WorkflowEngine("test-raw", {"nodes": [], "edges": []})
        result = engine._build_subworkflow_input("hello", None)
        assert result == {"input": "hello"}

    @pytest.mark.asyncio
    async def test_subworkflow_execution_with_mock_target(self, monkeypatch):
        """子工作流真实执行：mock _resolve_subworkflow_target，验证子流程执行"""
        mini_wf = self._make_mini_workflow()

        def _mock_resolve(*args, **kwargs):
            return ("workflow", "wf-child", mini_wf)

        monkeypatch.setattr(
            "app.services.workflow_engine.WorkflowEngine._resolve_subworkflow_target",
            _mock_resolve,
        )

        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "sub-1", "type": "subworkflow",
                 "data": {"workflow_id": "wf-child", "input_mapping": {"msg": "input"}}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "sub-1"},
                {"id": "e2", "source": "sub-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-sub-exec", workflow_data)
        # 不带 db，子工作流无 Execution 持久化，仍应正常执行
        result = await engine.execute({"input": "hello"})
        assert result["status"] == "completed"
        # 子工作流节点的输出
        node_results = result.get("node_results", {})
        sub_output = node_results.get("sub-1", {}).get("output", {})
        assert sub_output.get("target_type") == "workflow"
        assert sub_output.get("target_id") == "wf-child"
        assert sub_output.get("status") == "completed"

    @pytest.mark.asyncio
    async def test_subworkflow_error_propagation(self, monkeypatch):
        """子工作流失败时错误向上传播为 WorkflowExecutionError"""

        def _mock_resolve_fail(*args, **kwargs):
            raise ValueError("目标工作流不存在: wf-gone")

        monkeypatch.setattr(
            "app.services.workflow_engine.WorkflowEngine._resolve_subworkflow_target",
            _mock_resolve_fail,
        )

        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "sub-1", "type": "subworkflow",
                 "data": {"workflow_id": "wf-gone"}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "sub-1"},
                {"id": "e2", "source": "sub-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-sub-err", workflow_data)
        with pytest.raises(WorkflowExecutionError) as exc_info:
            await engine.execute({"input": "test"})
        assert "不存在" in str(exc_info.value.detail) or "wf-gone" in str(exc_info.value.detail)

    def test_subworkflow_missing_target_error(self):
        """subworkflow 节点缺少 workflow_id 且缺少 agent_id 时抛错"""
        workflow_data = {
            "nodes": [
                {"id": "start-1", "type": "start"},
                {"id": "sub-1", "type": "subworkflow", "data": {}},
                {"id": "end-1", "type": "end"},
            ],
            "edges": [
                {"id": "e1", "source": "start-1", "target": "sub-1"},
                {"id": "e2", "source": "sub-1", "target": "end-1"},
            ],
        }
        engine = WorkflowEngine("test-no-target", workflow_data)
        with pytest.raises(WorkflowExecutionError) as exc_info:
            asyncio.run(engine.execute({"input": "test"}))
        assert "缺少" in str(exc_info.value.detail) or "workflow_id" in str(exc_info.value.detail).lower()