@gadmin2n/schematics 0.0.144 → 0.0.146

package/dist/lib/application/files/gadmin2-game-angle-demo/web/src/routes/workflow/node-instances/widgets/HumanApprovalConfigEditor.test.tsx

@@ -1,16 +1,11 @@
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { fireEvent, render, screen } from '@testing-library/react';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { customRequest } from 'helpers/http';
 import i18n from '../../../../i18n';
 import { HumanApprovalConfigEditor } from './HumanApprovalConfigEditor';
 
-vi.mock('helpers/http', () => ({ customRequest: vi.fn() }));
 vi.mock('./SubjectPicker', () => ({
   SubjectPicker: () => <div data-testid="subject-picker" />,
 }));
-vi.mock('./ApproverSourceEditor', () => ({
-  ApproverSourceEditor: () => <div data-testid="approver-source-editor" />,
-}));
 
 Object.defineProperty(window, 'matchMedia', {
   writable: true,
@@ -24,64 +19,204 @@ Object.defineProperty(window, 'matchMedia', {
   }),
 });
 
+const config = {
+  task: {
+    title: { source: 'WORKFLOW' as const, path: 'request.title' },
+    description: {
+      source: 'FIXED' as const,
+      valueType: 'STRING' as const,
+      value: '',
+    },
+    details: [],
+  },
+  subjects: [],
+  approvalRule: { mode: 'ANY' as const },
+  rejectionRule: { mode: 'ANY' as const },
+  blockCancellationOnResolved: false,
+  timeout: { durationSeconds: 0, action: 'REJECTED' as const },
+};
+
 describe('HumanApprovalConfigEditor', () => {
   beforeEach(async () => {
     await i18n.changeLanguage('zh_CN');
-    vi.mocked(customRequest).mockResolvedValue([
-      {
-        id: '11',
-        name: 'MyOA',
-        isEnabled: true,
-        inputParameters: [
-          { key: 'title', label: '单据标题', required: true },
-          { key: 'content', label: '审批内容', required: true },
-        ],
-      },
-    ] as never);
   });
 
-  it('shows the selected Workflow contract and stores input bindings', async () => {
+  it('edits the built-in approval task without loading a child Workflow', () => {
+    const onChange = vi.fn();
+
+    render(
+      <HumanApprovalConfigEditor
+        value={config}
+        onChange={onChange}
+        schema={{ type: 'object' }}
+      />,
+    );
+
+    expect(screen.getByText('GAdmin 审批任务')).toBeInTheDocument();
+    expect(screen.getByText('审批人设置')).toBeInTheDocument();
+    expect(screen.getByText('审批规则')).toBeInTheDocument();
+    expect(screen.getByText('取消规则')).toBeInTheDocument();
+    expect(screen.getByText('超时设置')).toBeInTheDocument();
+
+    fireEvent.change(screen.getByLabelText('任务标题的字段路径'), {
+      target: { value: 'request.subject' },
+    });
+
+    expect(onChange).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        task: expect.objectContaining({
+          title: { source: 'WORKFLOW', path: 'request.subject' },
+        }),
+      }),
+    );
+  });
+
+  it('configures whether a resolved approval blocks cancellation', () => {
+    const onChange = vi.fn();
+    render(
+      <HumanApprovalConfigEditor
+        value={config}
+        onChange={onChange}
+        schema={{ type: 'object' }}
+      />,
+    );
+
+    fireEvent.click(
+      screen.getByRole('switch', {
+        name: '审批通过或拒绝后禁止取消 Workflow',
+      }),
+    );
+
+    expect(onChange).toHaveBeenLastCalledWith(
+      expect.objectContaining({ blockCancellationOnResolved: true }),
+    );
+  });
+
+  it('updates the saved duration when the timeout unit changes', async () => {
     const onChange = vi.fn();
 
     render(
       <HumanApprovalConfigEditor
         value={{
-          approvalWorkflowId: '11',
-          approvalWorkflowInputBindings: {
-            title: { source: 'WORKFLOW', path: 'requestTitle' },
-            content: { source: 'INPUT', path: 'description' },
-          },
-          approverSources: [],
-          subjects: [],
-          approvalRule: { mode: 'ANY' },
-          rejectionRule: { mode: 'ANY' },
-          timeout: { durationSeconds: 0, action: 'REJECTED' },
+          ...config,
+          timeout: { durationSeconds: 7200, action: 'REJECTED' },
         }}
         onChange={onChange}
         schema={{ type: 'object' }}
       />,
     );
 
-    await waitFor(() =>
-      expect(screen.getByText('传给审批 Workflow 的数据')).toBeInTheDocument(),
+    fireEvent.mouseDown(screen.getByRole('combobox', { name: '时间单位' }));
+    fireEvent.click(await screen.findByText('天'));
+
+    expect(onChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        timeout: { durationSeconds: 172800, action: 'REJECTED' },
+      }),
     );
-    expect(screen.getByText('单据标题')).toBeInTheDocument();
-    expect(screen.getByText('审批内容')).toBeInTheDocument();
-    expect(screen.getByLabelText('单据标题的字段路径')).toHaveValue(
-      'requestTitle',
+  });
+
+  it('adds an HTTP and Code lookup inside the approval node', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <HumanApprovalConfigEditor
+        value={config}
+        onChange={onChange}
+        schema={{ type: 'object' }}
+      />,
     );
 
-    fireEvent.change(screen.getByLabelText('单据标题的字段路径'), {
-      target: { value: 'approval.title' },
-    });
+    fireEvent.click(screen.getByRole('button', { name: '添加动态用户' }));
+
+    expect(onChange).toHaveBeenLastCalledWith(
+      expect.objectContaining({
+        subjects: [
+          {
+            source: 'DYNAMIC',
+            provider: 'USER',
+            inputKey: 'dynamic_users',
+            label: '查询审批人',
+            lookup: {
+              request: expect.objectContaining({ method: 'GET', path: '/' }),
+              result: expect.objectContaining({
+                mode: 'runOnceForAll',
+                script: expect.stringContaining("provider: 'USER'"),
+              }),
+            },
+          },
+        ],
+      }),
+    );
+    expect(container.querySelector('.human-approval-config__rail')).toBeNull();
+  });
+
+  it('uses the collapsible sections without repeating a lookup flow summary', () => {
+    const { container } = render(
+      <HumanApprovalConfigEditor
+        value={{
+          ...config,
+          subjects: [
+            {
+              source: 'DYNAMIC',
+              provider: 'USER',
+              inputKey: 'direct_manager',
+              label: '查询直属主管',
+              lookup: {
+                request: {
+                  method: 'GET',
+                  path: '/',
+                  queryBindings: {},
+                  headerBindings: {},
+                  bodyMode: 'FIELDS',
+                  bodyBindings: {},
+                  timeoutSeconds: 30,
+                },
+                result: {
+                  mode: 'runOnceForAll',
+                  timeout: 5000,
+                  script: 'return { subjects: [] };',
+                },
+              },
+            },
+          ],
+        }}
+        onChange={vi.fn()}
+        schema={{ type: 'object' }}
+      />,
+    );
+
+    expect(
+      container.querySelector('.human-approval-config__external-flow'),
+    ).toBeNull();
+    expect(screen.getAllByText('查询审批人')).toHaveLength(1);
+    expect(screen.getAllByText('提取审批人')).toHaveLength(1);
+  });
+
+  it('adds an external approval entry without disabling the GAdmin inbox', () => {
+    const onChange = vi.fn();
+    render(
+      <HumanApprovalConfigEditor
+        value={config}
+        onChange={onChange}
+        schema={{ type: 'object' }}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole('switch', { name: '同时发送到外部系统' }));
 
     expect(onChange).toHaveBeenLastCalledWith(
       expect.objectContaining({
-        approvalWorkflowInputBindings: expect.objectContaining({
-          title: { source: 'WORKFLOW', path: 'approval.title' },
+        external: expect.objectContaining({
+          request: expect.objectContaining({ method: 'POST' }),
+          creationResult: expect.objectContaining({
+            mode: 'runOnceForAll',
+          }),
+          callbackResult: expect.objectContaining({
+            mode: 'runOnceForAll',
+          }),
         }),
       }),
     );
-    expect(customRequest).toHaveBeenCalledWith('workflow/callable', 'GET');
+    expect(onChange.mock.lastCall?.[0]).not.toHaveProperty('handlingMode');
   });
 });