refactor(rpa-core): 测试文件迁至 test/ 目录（对面 workspace 规范：产品源码树禁含测试）；修 platform-groups 测试预载顺序耦合

2026-11-06 16:14:23 +08:00
1 parent 62652b4fca
commit 4f1fbc07dc
@@ -0,0 +1,204 @@
+import { describe, expect, it } from "vitest";
+import type { CatalogComponent, FlowDefinition, FlowNode } from "../../src/types";
+import { validateFlowGraph, hasBlockingIssues } from "../../src/engine/graph-validator";
+import { register } from "../../src/engine/registry";
+import { RuntimeError } from "../../src/engine/types";
+import { runFlow } from "../../src/engine/runtime";
+
+type RunFlowOptions = Parameters<typeof runFlow>[1];
+
+function makeFlow(partial: Partial<FlowDefinition> & { nodes: FlowNode[] }): FlowDefinition {
+  return {
+    schemaVersion: 1,
+    id: "flow_test",
+    name: "测试流程",
+    variables: [],
+    nodes: partial.nodes,
+    edges: partial.edges || [],
+    meta: { createdAt: "2026-01-01T00:00:00Z", updatedAt: "2026-01-01T00:00:00Z", appVersion: "test" }
+  };
+}
+
+function node(id: string, componentId: string, overrides: Partial<FlowNode> = {}): FlowNode {
+  return {
+    id,
+    componentId,
+    position: { x: 0, y: 0 },
+    values: {},
+    options: {},
+    ...overrides
+  };
+}
+
+const fakeComponent = (id: string): CatalogComponent =>
+  ({
+    id,
+    name: id,
+    version: "1.0.0",
+    tags: [],
+    platformTag: null,
+    icon: "",
+    risk: "low",
+    fields: [],
+    output: { label: "", key: "", suggestedName: "", valueTypes: [], fields: [] },
+    slots: [],
+    functionCalls: []
+  }) as unknown as CatalogComponent;
+
+const baseOptions = (signal: AbortSignal): RunFlowOptions => ({
+  runId: "run_test",
+  evidenceDir: ".",
+  signal,
+  emit: () => {},
+  log: () => {},
+  componentOf: (n: FlowNode) => fakeComponent(n.componentId),
+  variables: {}
+});
+
+const hangUntilAborted = (ctx: { signal: AbortSignal }): Promise<never> =>
+  new Promise((_, reject) => {
+    const onAbort = () => reject(new RuntimeError("cancelled", "运行已取消"));
+    if (ctx.signal.aborted) return onAbort();
+    ctx.signal.addEventListener("abort", onAbort, { once: true });
+  });
+
+register("Test_HangHandler", (ctx) => hangUntilAborted(ctx));
+
+register("Test_SlowHandler", async (ctx) => {
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(resolve, 5000);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new RuntimeError("cancelled", "运行已取消"));
+    };
+    if (ctx.signal.aborted) return onAbort();
+    ctx.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  return "done";
+});
+
+let nonIdempotentCalls = 0;
+register("Test_NonIdempotent", async () => {
+  nonIdempotentCalls += 1;
+  throw new Error("boom");
+}, { idempotent: false });
+
+let idempotentCalls = 0;
+register("Test_Idempotent", async () => {
+  idempotentCalls += 1;
+  if (idempotentCalls < 3) throw new Error("transient");
+  return "ok";
+}, { idempotent: true });
+
+describe("validateFlowGraph", () => {
+  it("正常图无问题", () => {
+    const flow = makeFlow({
+      nodes: [node("a", "Trigger.Manual"), node("b", "File_Read")],
+      edges: [{ id: "e1", source: "a", target: "b" }]
+    });
+    expect(hasBlockingIssues(validateFlowGraph(flow))).toBe(false);
+  });
+
+  it("重复节点 ID 记为错误", () => {
+    const flow = makeFlow({ nodes: [node("a", "Trigger.Manual"), node("a", "File_Read")] });
+    const issues = validateFlowGraph(flow);
+    expect(issues.some((issue) => issue.code === "duplicate_node_id" && issue.severity === "error")).toBe(true);
+  });
+
+  it("悬空边记为错误", () => {
+    const flow = makeFlow({
+      nodes: [node("a", "Trigger.Manual")],
+      edges: [{ id: "e1", source: "a", target: "ghost" }]
+    });
+    expect(validateFlowGraph(flow).some((issue) => issue.code === "dangling_edge")).toBe(true);
+  });
+
+  it("自环记为错误", () => {
+    const flow = makeFlow({
+      nodes: [node("a", "Trigger.Manual")],
+      edges: [{ id: "e1", source: "a", target: "a" }]
+    });
+    expect(validateFlowGraph(flow).some((issue) => issue.code === "self_loop")).toBe(true);
+  });
+
+  it("顶层环记为错误", () => {
+    const flow = makeFlow({
+      nodes: [node("a", "Trigger.Manual"), node("b", "File_Read"), node("c", "File_Write")],
+      edges: [
+        { id: "e1", source: "a", target: "b" },
+        { id: "e2", source: "b", target: "c" },
+        { id: "e3", source: "c", target: "b" }
+      ]
+    });
+    expect(validateFlowGraph(flow).some((issue) => issue.code === "cycle" && issue.severity === "error")).toBe(true);
+  });
+
+  it("孤儿子节点与不可达节点", () => {
+    const flow = makeFlow({
+      nodes: [node("a", "Trigger.Manual"), { ...node("x", "File_Read"), parentId: "ghost" }, node("y", "Http_Get")]
+    });
+    const issues = validateFlowGraph(flow);
+    expect(issues.some((issue) => issue.code === "orphan_child")).toBe(true);
+    expect(issues.some((issue) => issue.code === "unreachable_node")).toBe(true);
+  });
+});
+
+describe("runtime 取消/超时/重试门控", () => {
+  it("超时会中止监听尝试信号的 handler", async () => {
+    const flow = makeFlow({
+      nodes: [{ ...node("slow", "Test_SlowHandler"), options: { timeoutMs: 120 } }]
+    });
+    const controller = new AbortController();
+    const result = await runFlow(flow, baseOptions(controller.signal));
+    expect(result.status).toBe("failed");
+    expect(result.error?.code).toBe("timeout");
+    expect(result.error?.reason).toContain("执行超时");
+  });
+
+  it("运行取消时节点状态为 cancelled 且不走 error route", async () => {
+    const flow = makeFlow({
+      nodes: [node("n1", "Test_HangHandler"), node("err", "File_Write")],
+      edges: [{ id: "e1", source: "n1", target: "err", sourceHandle: "error" }]
+    });
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), 50);
+    const result = await runFlow(flow, baseOptions(controller.signal));
+    expect(result.status).toBe("cancelled");
+    const nodeState = result.nodes.find((item) => item.nodeId === "n1");
+    expect(nodeState?.status).toBe("cancelled");
+    // error 边存在，但取消不应路由到 err 节点
+    expect(result.nodes.some((item) => item.nodeId === "err")).toBe(false);
+  });
+
+  it("非幂等能力忽略 retryCount", async () => {
+    nonIdempotentCalls = 0;
+    const flow = makeFlow({
+      nodes: [{ ...node("r", "Test_NonIdempotent"), options: { retryCount: 3, retryIntervalMs: 1000 } }]
+    });
+    const controller = new AbortController();
+    const result = await runFlow(flow, baseOptions(controller.signal));
+    expect(result.status).toBe("failed");
+    expect(nonIdempotentCalls).toBe(1);
+  });
+
+  it("幂等能力遵循 retryCount 重试后成功", async () => {
+    idempotentCalls = 0;
+    const flow = makeFlow({
+      nodes: [{ ...node("r", "Test_Idempotent"), options: { retryCount: 3, retryIntervalMs: 1000, timeoutMs: 5000 } }]
+    });
+    const controller = new AbortController();
+    const result = await runFlow(flow, baseOptions(controller.signal));
+    expect(result.status).toBe("succeeded");
+    expect(idempotentCalls).toBe(3);
+  });
+
+  it("流程图校验失败返回 validation_error 且不执行任何节点", async () => {
+    const flow = makeFlow({ nodes: [node("a", "Trigger.Manual"), node("a", "File_Read")] });
+    const controller = new AbortController();
+    const result = await runFlow(flow, baseOptions(controller.signal));
+    expect(result.status).toBe("failed");
+    expect(result.error?.code).toBe("validation_error");
+    expect(result.error?.reason).toContain("流程图校验未通过");
+    expect(result.nodes).toHaveLength(0);
+  });
+});