@gadmin2n/schematics 0.0.139 → 0.0.141

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/components/NodePropertyPanel.test.tsx

@@ -0,0 +1,335 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { customRequest } from 'helpers/http';
+import { act } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import i18n from '../../../i18n';
+import type { WorkflowNode, WorkflowNodeType } from '../types';
+import { NodePropertyPanel } from './NodePropertyPanel';
+
+vi.mock('helpers/http', () => ({ customRequest: vi.fn() }));
+
+const nodeType = {
+  id: '7',
+  type: 'approval',
+  label: 'Human Approval',
+  category: 'APPROVAL',
+  instancePolicy: 'REQUIRED',
+  configSchema: {
+    type: 'object',
+    properties: {
+      subjects: { type: 'array', title: 'Approvers' },
+    },
+  },
+  uiSchema: { widget: 'human-approval-config' },
+} as unknown as WorkflowNodeType;
+
+const node: WorkflowNode = {
+  id: 'node-1',
+  type: 'approval',
+  label: 'Finance approval',
+  position: { x: 0, y: 0 },
+  config: { subjects: [{ provider: 'USER', refs: ['alice'] }] },
+  instanceRef: {
+    instanceId: '12',
+    instanceCode: 'FINANCE_APPROVAL',
+  },
+};
+
+describe('NodePropertyPanel instance references', () => {
+  beforeEach(async () => {
+    await i18n.changeLanguage('en');
+    vi.mocked(customRequest).mockReset();
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: vi.fn().mockImplementation((query: string) => ({
+        matches: false,
+        media: query,
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+      })),
+    });
+  });
+
+  it('renders a referenced node with the editable template config form', async () => {
+    vi.mocked(customRequest).mockImplementation((path) => {
+      if (path === 'subject-providers') return Promise.resolve([]) as never;
+      return Promise.resolve({
+        data: [
+          {
+            id: '12',
+            code: 'FINANCE_APPROVAL',
+            name: 'Finance approval',
+            nodeTypeId: '7',
+            isEnabled: true,
+            config: {
+              subjects: [{ provider: 'USER', refs: ['bob'] }],
+            },
+          },
+        ],
+      }) as never;
+    });
+
+    render(
+      <NodePropertyPanel
+        node={node}
+        nodeTypes={[nodeType]}
+        onSave={vi.fn()}
+        onLabelChange={vi.fn()}
+        onAiEdit={vi.fn()}
+        aiLoading={false}
+      />,
+    );
+
+    await waitFor(() => expect(customRequest).toHaveBeenCalled());
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    expect(screen.getByText('Who can approve')).toBeInTheDocument();
+    expect(
+      screen.getByText('修改只会保存在当前 Workflow，不会修改 Node Template。'),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: 'Save changes' }),
+    ).toBeInTheDocument();
+  });
+
+  it('uses the simple return editor even when stored node metadata has no widget', () => {
+    const returnNodeType = {
+      id: '9',
+      type: 'return_result',
+      label: 'Return result',
+      category: 'ACTION',
+      instancePolicy: 'INLINE_ONLY',
+      configSchema: {
+        type: 'object',
+        properties: {
+          resultType: { type: 'string' },
+          path: { type: 'string' },
+        },
+      },
+      uiSchema: {},
+    } as unknown as WorkflowNodeType;
+    const returnNode: WorkflowNode = {
+      id: 'return-1',
+      type: 'return_result',
+      label: 'Return result',
+      position: { x: 0, y: 0 },
+      config: {},
+    };
+
+    render(
+      <NodePropertyPanel
+        node={returnNode}
+        nodeTypes={[returnNodeType]}
+        onSave={vi.fn()}
+        onLabelChange={vi.fn()}
+        onAiEdit={vi.fn()}
+        aiLoading={false}
+      />,
+    );
+
+    expect(
+      screen.getByText('Return the previous node result'),
+    ).toBeInTheDocument();
+    expect(screen.queryByLabelText('Workflow data field')).toBeNull();
+  });
+
+  it('uses nested UI Schema widgets for Callable Trigger parameters', async () => {
+    const user = userEvent.setup();
+    const onSave = vi.fn();
+    const callableNodeType = {
+      id: '9',
+      type: 'callable_trigger',
+      label: '接收调用参数',
+      category: 'TRIGGER',
+      instancePolicy: 'INLINE_ONLY',
+      configSchema: {
+        type: 'object',
+        properties: {
+          inputParameters: {
+            type: 'array',
+            title: '调用参数',
+            items: {
+              type: 'object',
+              properties: {
+                key: { type: 'string' },
+                label: { type: 'string' },
+                required: { type: 'boolean' },
+              },
+              required: ['key'],
+            },
+          },
+        },
+      },
+      uiSchema: {},
+    } as unknown as WorkflowNodeType;
+    const callableNode: WorkflowNode = {
+      id: 'callable-1',
+      type: 'callable_trigger',
+      label: '接收调用参数',
+      position: { x: 100, y: 100 },
+      config: { inputParameters: [] },
+    };
+
+    render(
+      <NodePropertyPanel
+        node={callableNode}
+        nodeTypes={[callableNodeType]}
+        onSave={onSave}
+        onLabelChange={vi.fn()}
+        onAiEdit={vi.fn()}
+        aiLoading={false}
+      />,
+    );
+
+    expect(
+      screen.getByRole('button', { name: 'Add parameter' }),
+    ).toBeInTheDocument();
+    expect(screen.getByText(/No business parameters/)).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: 'Add parameter' }));
+    await user.type(
+      screen.getByRole('textbox', { name: 'Parameter name' }),
+      'departmentId',
+    );
+    await user.click(screen.getByRole('button', { name: 'Save changes' }));
+
+    expect(onSave).toHaveBeenCalledWith(
+      'callable-1',
+      expect.objectContaining({
+        config: {
+          inputParameters: [{ key: 'departmentId', label: '', required: true }],
+        },
+      }),
+    );
+  });
+
+  it('does not carry Code configuration into Submit External Result when switching nodes', async () => {
+    const user = userEvent.setup();
+    const onSave = vi.fn();
+    const codeNodeType = {
+      id: 'code',
+      type: 'code',
+      label: 'Code',
+      category: 'ACTION',
+      instancePolicy: 'INLINE_ONLY',
+      configSchema: {
+        type: 'object',
+        properties: {
+          mode: { type: 'string' },
+          script: { type: 'string' },
+          timeout: { type: 'integer' },
+        },
+      },
+      uiSchema: { widget: 'code-config' },
+    } as unknown as WorkflowNodeType;
+    const submitNodeType = {
+      id: 'submit-external-result',
+      type: 'submit_external_result',
+      label: 'Submit external result',
+      category: 'ACTION',
+      instancePolicy: 'INLINE_ONLY',
+      configSchema: {
+        type: 'object',
+        properties: {
+          inputBindings: { type: 'object' },
+        },
+      },
+      uiSchema: { widget: 'submit-external-result-config' },
+    } as unknown as WorkflowNodeType;
+    const codeNode: WorkflowNode = {
+      id: 'code-1',
+      type: 'code',
+      label: 'Transform callback',
+      position: { x: 0, y: 0 },
+      config: {
+        mode: 'runOnceForAll',
+        script: 'return input;',
+        timeout: 1000,
+      },
+    };
+    const inputBindings = {
+      callbackToken: { source: 'INPUT' as const, path: 'callbackToken' },
+      eventId: { source: 'INPUT' as const, path: 'eventId' },
+      outcome: { source: 'INPUT' as const, path: 'outcome' },
+    };
+    const submitNode: WorkflowNode = {
+      id: 'submit-1',
+      type: 'submit_external_result',
+      label: 'Submit external result',
+      position: { x: 100, y: 0 },
+      config: { inputBindings },
+    };
+    const nodeTypes = [codeNodeType, submitNodeType];
+    const commonProps = {
+      nodeTypes,
+      onSave,
+      onLabelChange: vi.fn(),
+      onAiEdit: vi.fn(),
+      aiLoading: false,
+    };
+
+    const { rerender } = render(
+      <NodePropertyPanel {...commonProps} node={codeNode} />,
+    );
+
+    rerender(<NodePropertyPanel {...commonProps} node={submitNode} />);
+    await user.click(screen.getByRole('button', { name: 'Save changes' }));
+
+    expect(onSave).toHaveBeenLastCalledWith('submit-1', {
+      label: 'Submit external result',
+      config: { inputBindings },
+    });
+  });
+
+  it('hides legacy trigger and approval callback nodes from the palette', () => {
+    render(
+      <NodePropertyPanel
+        node={null}
+        nodeTypes={
+          [
+            {
+              id: 'callable',
+              type: 'callable_trigger',
+              label: '接收调用',
+              category: 'TRIGGER',
+            },
+            {
+              id: 'legacy-approval',
+              type: 'approval_request_trigger',
+              label: '接收审批请求',
+              category: 'TRIGGER',
+            },
+            {
+              id: 'webhook',
+              type: 'webhook_trigger',
+              label: 'Webhook Trigger',
+              category: 'TRIGGER',
+            },
+            {
+              id: 'submit-result',
+              type: 'submit_approval_result',
+              label: 'Submit approval result',
+              category: 'ACTION',
+            },
+          ] as WorkflowNodeType[]
+        }
+        onSave={vi.fn()}
+        onLabelChange={vi.fn()}
+        onAiEdit={vi.fn()}
+        aiLoading={false}
+      />,
+    );
+
+    expect(screen.getByText('Receive call')).toBeInTheDocument();
+    expect(
+      screen.queryByText('Receive approval request'),
+    ).not.toBeInTheDocument();
+    expect(screen.getByText('Receive external request')).toBeInTheDocument();
+    expect(
+      screen.queryByText('Submit approval result'),
+    ).not.toBeInTheDocument();
+  });
+});