@gadmin2n/schematics 0.0.144 → 0.0.146

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/utils/validateWorkflowDsl.test.ts

@@ -0,0 +1,502 @@
+import { describe, expect, it } from 'vitest';
+import type { WorkflowDSL, WorkflowNodeType } from '../types';
+import { validateWorkflowDsl } from './validateWorkflowDsl';
+
+const nodeTypes: WorkflowNodeType[] = [
+  nodeType('manual_trigger', []),
+  nodeType('code', []),
+  nodeType('http_request', []),
+  nodeType('for_each', []),
+  nodeType('parallel', []),
+  nodeType('if_else', ['true', 'false']),
+  {
+    ...nodeType('approval', ['true', 'false']),
+    runtimeKey: 'human_approval',
+  },
+  nodeType('switch', []),
+  nodeType('sub_workflow', []),
+];
+
+describe('validateWorkflowDsl', () => {
+  it('explains that an approval node needs at least one approver', () => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        node('trigger', 'manual_trigger'),
+        { ...node('approval', 'approval'), config: { subjects: [] } },
+      ],
+      edges: [edge('trigger-approval', 'trigger', 'approval')],
+    };
+
+    expect(validateWorkflowDsl(dsl, { nodeTypes })).toEqual({
+      ok: false,
+      error: '节点“approval”必须至少设置一位固定审批人或动态审批人',
+    });
+    expect(
+      validateWorkflowDsl(dsl, {
+        nodeTypes,
+        validationMode: 'draft',
+      }),
+    ).toEqual({ ok: true, dsl });
+  });
+
+  it('explains an unfinished condition binding without raw schema errors', () => {
+    const condition = {
+      ...node('condition', 'if_else'),
+      config: {
+        conditions: [
+          {
+            id: 'condition-1',
+            left: { source: 'INPUT', path: '' },
+            operator: 'EQ',
+            right: { source: 'FIXED', valueType: 'STRING', value: '' },
+          },
+        ],
+        combineOperation: 'AND',
+      },
+    };
+    const dsl: WorkflowDSL = {
+      nodes: [node('trigger', 'manual_trigger'), condition],
+      edges: [edge('trigger-condition', 'trigger', 'condition')],
+    };
+
+    expect(validateWorkflowDsl(dsl, { nodeTypes })).toEqual({
+      ok: false,
+      error:
+        '节点“condition”的“条件 1 · 要判断的数据”没有填写有效的字段路径或固定值',
+    });
+  });
+
+  it('accepts a complete For Each CALL/FLOW/RETURN contract', () => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        node('trigger', 'manual_trigger'),
+        node('loop', 'for_each'),
+        node('body', 'http_request'),
+        node('after', 'code'),
+      ],
+      edges: [
+        edge('trigger-loop', 'trigger', 'loop'),
+        {
+          ...edge('loop-after', 'loop', 'after'),
+          targetHandle: 'data-in',
+        },
+        {
+          ...edge('loop-body', 'loop', 'body'),
+          kind: 'CALL',
+          pairId: 'loop-pair',
+          sourceHandle: 'start',
+          targetHandle: 'request-in',
+        },
+        {
+          ...edge('body-loop', 'body', 'loop'),
+          kind: 'RETURN',
+          pairId: 'loop-pair',
+          sourceHandle: 'response-out',
+          targetHandle: 'end',
+          valueType: 'JSON',
+        },
+      ],
+    };
+
+    expect(validateWorkflowDsl(dsl, { nodeTypes })).toEqual({ ok: true, dsl });
+  });
+
+  it('accepts one complete START / END pipeline for every Parallel branch', () => {
+    const parallel = {
+      ...node('parallel', 'parallel'),
+      config: {
+        branches: [
+          { id: 'notify', label: '发送通知' },
+          { id: 'sync', label: '同步资产' },
+        ],
+      },
+    };
+    const dsl: WorkflowDSL = {
+      nodes: [
+        node('trigger', 'manual_trigger'),
+        parallel,
+        node('notify-body', 'code'),
+        node('sync-body', 'code'),
+      ],
+      edges: [
+        edge('trigger-parallel', 'trigger', 'parallel'),
+        {
+          ...edge('notify-start', 'parallel', 'notify-body'),
+          kind: 'CALL',
+          pairId: 'notify-pair',
+          sourceHandle: 'notify-start',
+          targetHandle: 'data-in',
+        },
+        {
+          ...edge('notify-end', 'notify-body', 'parallel'),
+          kind: 'RETURN',
+          pairId: 'notify-pair',
+          sourceHandle: 'result-out',
+          targetHandle: 'notify-end',
+          valueType: 'JSON',
+        },
+        {
+          ...edge('sync-start', 'parallel', 'sync-body'),
+          kind: 'CALL',
+          pairId: 'sync-pair',
+          sourceHandle: 'sync-start',
+          targetHandle: 'data-in',
+        },
+        {
+          ...edge('sync-end', 'sync-body', 'parallel'),
+          kind: 'RETURN',
+          pairId: 'sync-pair',
+          sourceHandle: 'result-out',
+          targetHandle: 'sync-end',
+          valueType: 'JSON',
+        },
+      ],
+    };
+
+    expect(validateWorkflowDsl(dsl, { nodeTypes })).toEqual({ ok: true, dsl });
+  });
+
+  it('accepts a Parallel condition when every exit returns to its END', () => {
+    const parallel = {
+      ...node('parallel', 'parallel'),
+      config: {
+        branches: [
+          { id: 'review', label: '审核' },
+          { id: 'sync', label: '同步' },
+        ],
+      },
+    };
+    const condition = {
+      ...node('condition', 'if_else'),
+      config: {
+        conditions: [
+          {
+            id: 'condition-1',
+            left: { source: 'INPUT', path: 'status' },
+            operator: 'EQ',
+            right: { source: 'FIXED', valueType: 'STRING', value: 'READY' },
+          },
+        ],
+        combineOperation: 'AND',
+      },
+    };
+    const dsl: WorkflowDSL = {
+      nodes: [
+        node('trigger', 'manual_trigger'),
+        parallel,
+        condition,
+        node('sync-body', 'code'),
+      ],
+      edges: [
+        edge('trigger-parallel', 'trigger', 'parallel'),
+        {
+          ...edge('review-start', 'parallel', 'condition'),
+          kind: 'CALL',
+          pairId: 'review-pair',
+          sourceHandle: 'review-start',
+        },
+        {
+          ...edge('review-true-end', 'condition', 'parallel'),
+          kind: 'RETURN',
+          pairId: 'review-pair',
+          sourceHandle: 'true',
+          targetHandle: 'review-end',
+          valueType: 'JSON',
+        },
+        {
+          ...edge('review-false-end', 'condition', 'parallel'),
+          kind: 'RETURN',
+          pairId: 'review-pair',
+          sourceHandle: 'false',
+          targetHandle: 'review-end',
+          valueType: 'JSON',
+        },
+        {
+          ...edge('sync-start', 'parallel', 'sync-body'),
+          kind: 'CALL',
+          pairId: 'sync-pair',
+          sourceHandle: 'sync-start',
+          targetHandle: 'data-in',
+        },
+        {
+          ...edge('sync-end', 'sync-body', 'parallel'),
+          kind: 'RETURN',
+          pairId: 'sync-pair',
+          sourceHandle: 'result-out',
+          targetHandle: 'sync-end',
+          valueType: 'JSON',
+        },
+      ],
+    };
+
+    expect(validateWorkflowDsl(dsl, { nodeTypes })).toEqual({ ok: true, dsl });
+    expect(
+      validateWorkflowDsl(
+        {
+          ...dsl,
+          edges: dsl.edges.filter((edge) => edge.id !== 'review-false-end'),
+        },
+        { nodeTypes },
+      ),
+    ).toEqual(
+      expect.objectContaining({
+        ok: false,
+        error: expect.stringContaining('每个出口都必须连接'),
+      }),
+    );
+  });
+
+  it.each([
+    ['duplicate node IDs', duplicateNodeIds(), '节点 id 重复'],
+    ['unknown references', unknownReference(), '终点不存在'],
+    ['invalid runtime handles', invalidHandle(), '必须使用 data-in'],
+    ['unowned paired FLOW', unownedPair(), '必须属于唯一 CALL'],
+    ['incomplete For Each', incompleteForEach(), '完整处理链'],
+    [
+      'missing sub Workflow version',
+      missingSubWorkflowVersion(),
+      'workflowVersionId',
+    ],
+  ])('rejects %s', (_label, dsl, error) => {
+    expect(validateWorkflowDsl(dsl, { nodeTypes })).toEqual(
+      expect.objectContaining({
+        ok: false,
+        error: expect.stringContaining(error),
+      }),
+    );
+  });
+
+  it('validates Switch handles against the loaded template configuration', () => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        node('trigger', 'manual_trigger'),
+        {
+          ...node('switch', 'switch'),
+          config: { cases: [{ id: 'old-case' }] },
+          instanceRef: { instanceId: '7', instanceCode: 'SWITCH_TEMPLATE' },
+        },
+        node('code', 'code'),
+      ],
+      edges: [
+        edge('trigger-switch', 'trigger', 'switch'),
+        {
+          ...edge('switch-code', 'switch', 'code'),
+          sourceHandle: 'old-case',
+          targetHandle: 'data-in',
+        },
+      ],
+    };
+
+    expect(
+      validateWorkflowDsl(dsl, {
+        nodeTypes,
+        referencedConfigs: { '7': { cases: [{ id: 'current-case' }] } },
+      }),
+    ).toEqual(
+      expect.objectContaining({
+        ok: false,
+        error: expect.stringContaining('old-case'),
+      }),
+    );
+  });
+
+  it('rejects a sub Workflow version that does not belong to its target', () => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        node('trigger', 'manual_trigger'),
+        {
+          ...node('sub', 'sub_workflow'),
+          config: { workflowId: '42', workflowVersionId: '999' },
+        },
+      ],
+      edges: [edge('trigger-sub', 'trigger', 'sub')],
+    };
+
+    expect(
+      validateWorkflowDsl(dsl, {
+        nodeTypes,
+        callableWorkflows: [
+          {
+            id: '42',
+            name: '资产处理',
+            latestVersionId: '102',
+            versions: [{ id: '102', version: 2, inputParameters: [] }],
+          },
+        ],
+      }),
+    ).toEqual(
+      expect.objectContaining({
+        ok: false,
+        error: expect.stringContaining('不属于 Workflow 42'),
+      }),
+    );
+  });
+
+  it('validates the effective node config against its config Schema', () => {
+    const strictNodeTypes = nodeTypes.map((item) =>
+      item.type === 'code'
+        ? {
+            ...item,
+            configSchema: {
+              type: 'object' as const,
+              required: ['script'],
+              properties: { script: { type: 'string' as const } },
+            },
+          }
+        : item,
+    );
+
+    expect(
+      validateWorkflowDsl(baseDsl(), { nodeTypes: strictNodeTypes }),
+    ).toEqual(
+      expect.objectContaining({
+        ok: false,
+        error: expect.stringContaining('配置不符合 code 要求'),
+      }),
+    );
+  });
+
+  it.each([
+    ['missing required bindings', {}, '参数来源无效：员工 ID'],
+    [
+      'extra bindings',
+      {
+        employeeId: { source: 'FIXED', valueType: 'STRING', value: 'u-1' },
+        unknown: { source: 'FIXED', valueType: 'STRING', value: 'x' },
+      },
+      '包含未声明的参数：unknown',
+    ],
+    [
+      'invalid binding shapes',
+      { employeeId: { source: 'INPUT', path: '' } },
+      '参数来源无效：员工 ID',
+    ],
+  ])('rejects sub Workflow %s', (_label, inputBindings, error) => {
+    const dsl: WorkflowDSL = {
+      nodes: [
+        node('trigger', 'manual_trigger'),
+        {
+          ...node('sub', 'sub_workflow'),
+          config: {
+            workflowId: '42',
+            workflowVersionId: '102',
+            inputBindings,
+          },
+        },
+      ],
+      edges: [edge('trigger-sub', 'trigger', 'sub')],
+    };
+
+    expect(
+      validateWorkflowDsl(dsl, {
+        nodeTypes,
+        callableWorkflows: [
+          {
+            id: '42',
+            name: '资产处理',
+            latestVersionId: '102',
+            versions: [
+              {
+                id: '102',
+                version: 2,
+                inputParameters: [
+                  { key: 'employeeId', label: '员工 ID', required: true },
+                ],
+              },
+            ],
+          },
+        ],
+      }),
+    ).toEqual(
+      expect.objectContaining({
+        ok: false,
+        error: expect.stringContaining(error),
+      }),
+    );
+  });
+});
+
+function baseDsl(): WorkflowDSL {
+  return {
+    nodes: [node('trigger', 'manual_trigger'), node('code', 'code')],
+    edges: [
+      {
+        ...edge('trigger-code', 'trigger', 'code'),
+        targetHandle: 'data-in',
+      },
+    ],
+  };
+}
+
+function duplicateNodeIds(): WorkflowDSL {
+  const dsl = baseDsl();
+  return { ...dsl, nodes: [...dsl.nodes, node('code', 'code')] };
+}
+
+function unknownReference(): WorkflowDSL {
+  const dsl = baseDsl();
+  return { ...dsl, edges: [edge('missing', 'trigger', 'missing')] };
+}
+
+function invalidHandle(): WorkflowDSL {
+  const dsl = baseDsl();
+  return {
+    ...dsl,
+    edges: [{ ...dsl.edges[0], targetHandle: 'wrong-in' }],
+  };
+}
+
+function unownedPair(): WorkflowDSL {
+  const dsl = baseDsl();
+  return {
+    ...dsl,
+    edges: [{ ...dsl.edges[0], kind: 'FLOW', pairId: 'orphan' }],
+  };
+}
+
+function incompleteForEach(): WorkflowDSL {
+  return {
+    nodes: [node('trigger', 'manual_trigger'), node('loop', 'for_each')],
+    edges: [edge('trigger-loop', 'trigger', 'loop')],
+  };
+}
+
+function missingSubWorkflowVersion(): WorkflowDSL {
+  return {
+    nodes: [
+      node('trigger', 'manual_trigger'),
+      {
+        ...node('sub', 'sub_workflow'),
+        config: { workflowId: '2' },
+      },
+    ],
+    edges: [edge('trigger-sub', 'trigger', 'sub')],
+  };
+}
+
+function node(id: string, type: string) {
+  return { id, type, label: id, position: { x: 0, y: 0 }, config: {} };
+}
+
+function edge(id: string, source: string, target: string) {
+  return { id, source, target, kind: 'FLOW' as const };
+}
+
+function nodeType(type: string, outputs: string[]): WorkflowNodeType {
+  return {
+    id: type,
+    type,
+    category: type.endsWith('_trigger') ? 'TRIGGER' : 'ACTION',
+    label: type,
+    icon: '',
+    description: null,
+    configSchema: {},
+    uiSchema: {},
+    inputSchema: {},
+    outputSchema: {},
+    outputs,
+    runtimeKey: type,
+    schemaVersion: 1,
+    instancePolicy: 'OPTIONAL',
+  };
+}