@gadmin2n/schematics 0.0.144 → 0.0.146

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

@@ -0,0 +1,494 @@
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { customRequest } from 'helpers/http';
+import React, { forwardRef, useImperativeHandle, useRef } from 'react';
+import { MemoryRouter, Route, Routes } from 'react-router-dom';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import i18n from '../../i18n';
+import type { Workflow } from './types';
+import WorkflowEditorPage from './editor';
+
+vi.mock('helpers/http', () => ({ customRequest: vi.fn() }));
+vi.mock('config/agentAllowed', () => ({ useIsAgentAllowed: () => false }));
+vi.mock('./hooks/useWorkflowAgent', () => ({
+  useWorkflowAgent: () => ({
+    generate: vi.fn(),
+    abort: vi.fn(),
+    loading: false,
+    error: null,
+  }),
+}));
+vi.mock('./hooks/useReferencedNodeInstanceConfigs', () => ({
+  useReferencedNodeInstanceConfigs: () => ({
+    configs: {},
+    status: 'ready',
+    retry: vi.fn(),
+  }),
+}));
+vi.mock('./components/FlowRenderer', () => ({
+  FlowRenderer: ({
+    dsl,
+    readonly,
+  }: {
+    dsl: { nodes?: Array<{ label?: string }> };
+    readonly?: boolean;
+  }) => (
+    <div data-readonly={String(readonly)} data-testid="workflow-dsl">
+      {dsl?.nodes?.[0]?.label}
+    </div>
+  ),
+}));
+vi.mock('./components/WorkflowWorkspaceHeader', () => ({
+  WorkflowWorkspaceHeader: ({
+    title,
+    actions,
+  }: {
+    title: React.ReactNode;
+    actions: React.ReactNode;
+  }) => (
+    <>
+      {title}
+      {actions}
+    </>
+  ),
+}));
+const getPendingNodeUpdate = vi.fn();
+vi.mock('./components/NodePropertyPanel', () => ({
+  NodePropertyPanel: forwardRef((_props, ref) => {
+    useImperativeHandle(ref, () => ({
+      getPendingUpdate: getPendingNodeUpdate,
+      markSaved: vi.fn(),
+    }));
+    return null;
+  }),
+}));
+vi.mock('./components/ReadonlyNodePanel', () => ({
+  ReadonlyNodePanel: () => null,
+}));
+vi.mock('./components/DslView', () => ({
+  DslView: forwardRef(({ dsl, onApply, onDirtyChange }: any, ref) => {
+    const dirtyRef = useRef(false);
+    useImperativeHandle(ref, () => ({
+      apply: () => {
+        if (dirtyRef.current) {
+          onApply?.({
+            ...dsl,
+            nodes: dsl.nodes.map((node: any) =>
+              node.id === 'rejected'
+                ? {
+                    ...node,
+                    config: {
+                      bodyBindings: {
+                        result: {
+                          source: 'FIXED',
+                          valueType: 'STRING',
+                          value: 'REJECTED',
+                        },
+                      },
+                    },
+                  }
+                : node,
+            ),
+          });
+          dirtyRef.current = false;
+          onDirtyChange?.(false);
+        }
+        return true;
+      },
+      copy: vi.fn(),
+      isDirty: () => dirtyRef.current,
+      clear: vi.fn(),
+    }));
+    return (
+      <button
+        type="button"
+        onClick={() => {
+          dirtyRef.current = true;
+          onDirtyChange?.(true);
+        }}
+      >
+        Edit DSL text
+      </button>
+    );
+  }),
+}));
+
+describe('WorkflowEditorPage', () => {
+  beforeEach(async () => {
+    await i18n.changeLanguage('en');
+    vi.mocked(customRequest).mockReset();
+    getPendingNodeUpdate.mockReset();
+    getPendingNodeUpdate.mockReturnValue(null);
+    localStorage.clear();
+    Object.defineProperty(window, 'matchMedia', {
+      writable: true,
+      value: vi.fn().mockReturnValue({
+        matches: false,
+        addEventListener: vi.fn(),
+        removeEventListener: vi.fn(),
+      }),
+    });
+  });
+
+  it('opens an existing Workflow from the latest database draft', async () => {
+    localStorage.setItem(
+      'workflow_draft_42',
+      JSON.stringify({
+        nodes: [{ id: 'stale', type: 'code', label: 'Local stale draft' }],
+        edges: [],
+      }),
+    );
+    const workflow = {
+      id: '42',
+      name: 'Database workflow',
+      status: 'DRAFT',
+      dsl: {
+        nodes: [
+          {
+            id: 'database',
+            type: 'code',
+            label: 'Database latest draft',
+            position: { x: 0, y: 0 },
+            config: {},
+          },
+        ],
+        edges: [],
+      },
+      versions: [],
+    } as unknown as Workflow;
+    vi.mocked(customRequest).mockImplementation((path) => {
+      if (path === 'workflow-node-types') return Promise.resolve([]) as never;
+      if (path === 'workflow/callable') return Promise.resolve([]) as never;
+      if (path === 'workflow/42') return Promise.resolve(workflow) as never;
+      if (path === 'workflow/42/versions') return Promise.resolve([]) as never;
+      throw new Error(`Unexpected request: ${path}`);
+    });
+
+    render(
+      <MemoryRouter initialEntries={['/admin/workflow/edit/42']}>
+        <Routes>
+          <Route
+            path="/admin/workflow/edit/:id"
+            element={<WorkflowEditorPage />}
+          />
+        </Routes>
+      </MemoryRouter>,
+    );
+
+    expect(await screen.findByTestId('workflow-dsl')).toHaveTextContent(
+      'Database latest draft',
+    );
+    expect(screen.queryByText('Local stale draft')).not.toBeInTheDocument();
+  });
+
+  it('opens the latest published database version as editable content when the stored draft is empty', async () => {
+    const publishedDsl = {
+      nodes: [
+        {
+          id: 'published',
+          type: 'code',
+          label: 'Latest published database workflow',
+          position: { x: 0, y: 0 },
+          config: {},
+        },
+      ],
+      edges: [],
+    };
+    const workflow = {
+      id: '42',
+      name: 'Published workflow',
+      status: 'PUBLISHED',
+      hasUnpublishedChanges: false,
+      dsl: { nodes: [], edges: [] },
+      versions: [{ version: 3, dsl: publishedDsl }],
+    } as unknown as Workflow;
+    vi.mocked(customRequest).mockImplementation((path) => {
+      if (path === 'workflow-node-types') return Promise.resolve([]) as never;
+      if (path === 'workflow/callable') return Promise.resolve([]) as never;
+      if (path === 'workflow/42') return Promise.resolve(workflow) as never;
+      if (path === 'workflow/42/versions') {
+        return Promise.resolve([{ id: '3', version: 3 }]) as never;
+      }
+      throw new Error(`Unexpected request: ${path}`);
+    });
+
+    render(
+      <MemoryRouter initialEntries={['/admin/workflow/edit/42']}>
+        <Routes>
+          <Route
+            path="/admin/workflow/edit/:id"
+            element={<WorkflowEditorPage />}
+          />
+        </Routes>
+      </MemoryRouter>,
+    );
+
+    const canvas = await screen.findByTestId('workflow-dsl');
+    expect(canvas).toHaveTextContent('Latest published database workflow');
+    expect(canvas).toHaveAttribute('data-readonly', 'false');
+  });
+
+  it('opens the exact database version selected on the detail page as editable content', async () => {
+    const selectedVersionDsl = {
+      nodes: [
+        {
+          id: 'selected-version',
+          type: 'http_request',
+          label: 'HTTP request with saved configuration',
+          position: { x: 0, y: 0 },
+          config: { connectionRef: 'SERVICE_NOW' },
+        },
+      ],
+      edges: [],
+    };
+    const workflow = {
+      id: '42',
+      name: 'Published workflow',
+      status: 'PUBLISHED',
+      hasUnpublishedChanges: true,
+      dsl: {
+        nodes: [
+          {
+            id: 'draft',
+            type: 'http_request',
+            label: 'Incomplete saved draft',
+            position: { x: 0, y: 0 },
+            config: {},
+          },
+        ],
+        edges: [],
+      },
+      versions: [],
+    } as unknown as Workflow;
+    vi.mocked(customRequest).mockImplementation((path) => {
+      if (path === 'workflow-node-types') return Promise.resolve([]) as never;
+      if (path === 'workflow/callable') return Promise.resolve([]) as never;
+      if (path === 'workflow/42') return Promise.resolve(workflow) as never;
+      if (path === 'workflow/42/versions') return Promise.resolve([]) as never;
+      if (path === 'workflow/42/versions/3') {
+        return Promise.resolve({
+          id: '3',
+          version: 3,
+          dsl: selectedVersionDsl,
+        }) as never;
+      }
+      if (path === 'workflow/42/save') {
+        return Promise.resolve({
+          ...workflow,
+          dsl: selectedVersionDsl,
+        }) as never;
+      }
+      throw new Error(`Unexpected request: ${path}`);
+    });
+
+    render(
+      <MemoryRouter initialEntries={['/admin/workflow/edit/42?version=3']}>
+        <Routes>
+          <Route
+            path="/admin/workflow/edit/:id"
+            element={<WorkflowEditorPage />}
+          />
+        </Routes>
+      </MemoryRouter>,
+    );
+
+    expect(await screen.findByTestId('workflow-dsl')).toHaveTextContent(
+      'HTTP request with saved configuration',
+    );
+    expect(
+      screen.queryByText('Incomplete saved draft'),
+    ).not.toBeInTheDocument();
+    const saveButton = screen.getByRole('button', { name: /Save$/ });
+    expect(saveButton).toBeEnabled();
+    expect(screen.getByTestId('workflow-dsl')).toHaveAttribute(
+      'data-readonly',
+      'false',
+    );
+
+    fireEvent.click(saveButton);
+
+    expect(
+      (await screen.findAllByText('Replace the saved draft?')).length,
+    ).toBeGreaterThan(0);
+    expect(customRequest).not.toHaveBeenCalledWith(
+      'workflow/42/save',
+      'PATCH',
+      expect.anything(),
+    );
+
+    fireEvent.click(screen.getByRole('button', { name: 'Replace draft' }));
+
+    await waitFor(() =>
+      expect(customRequest).toHaveBeenCalledWith('workflow/42/save', 'PATCH', {
+        dsl: selectedVersionDsl,
+      }),
+    );
+  });
+
+  it('loads a published version from the editor selector as editable draft content', async () => {
+    const workflow = {
+      id: '42',
+      name: 'Workflow with draft',
+      status: 'PUBLISHED',
+      hasUnpublishedChanges: true,
+      dsl: {
+        nodes: [
+          {
+            id: 'draft',
+            type: 'code',
+            label: 'Current draft',
+            position: { x: 0, y: 0 },
+            config: {},
+          },
+        ],
+        edges: [],
+      },
+      versions: [{ version: 2 }],
+    } as unknown as Workflow;
+    vi.mocked(customRequest).mockImplementation((path) => {
+      if (path === 'workflow-node-types') return Promise.resolve([]) as never;
+      if (path === 'workflow/callable') return Promise.resolve([]) as never;
+      if (path === 'workflow/42') return Promise.resolve(workflow) as never;
+      if (path === 'workflow/42/versions') {
+        return Promise.resolve([
+          { id: '2', version: 2, changeSummary: null },
+        ]) as never;
+      }
+      if (path === 'workflow/42/versions/2') {
+        return Promise.resolve({
+          id: '2',
+          version: 2,
+          dsl: {
+            nodes: [
+              {
+                id: 'published',
+                type: 'code',
+                label: 'Published version 2',
+                position: { x: 0, y: 0 },
+                config: {},
+              },
+            ],
+            edges: [],
+          },
+        }) as never;
+      }
+      throw new Error(`Unexpected request: ${path}`);
+    });
+
+    render(
+      <MemoryRouter initialEntries={['/admin/workflow/edit/42']}>
+        <Routes>
+          <Route
+            path="/admin/workflow/edit/:id"
+            element={<WorkflowEditorPage />}
+          />
+        </Routes>
+      </MemoryRouter>,
+    );
+
+    expect(await screen.findByTestId('workflow-dsl')).toHaveTextContent(
+      'Current draft',
+    );
+    fireEvent.mouseDown(screen.getByRole('combobox'));
+    fireEvent.click(await screen.findByText('v2 - Saved'));
+
+    expect(await screen.findByTestId('workflow-dsl')).toHaveTextContent(
+      'Published version 2',
+    );
+    expect(screen.getByTestId('workflow-dsl')).toHaveAttribute(
+      'data-readonly',
+      'false',
+    );
+    expect(screen.getByRole('button', { name: /Save$/ })).toBeEnabled();
+  });
+
+  it('keeps applied DSL as the source of truth when saving the draft', async () => {
+    const workflow = {
+      id: '42',
+      name: 'Disposal workflow',
+      status: 'DRAFT',
+      hasUnpublishedChanges: false,
+      dsl: {
+        nodes: [
+          {
+            id: 'rejected',
+            type: 'http_request',
+            label: 'Reject disposal',
+            position: { x: 0, y: 0 },
+            config: {},
+          },
+        ],
+        edges: [],
+      },
+      versions: [],
+    } as unknown as Workflow;
+    vi.mocked(customRequest).mockImplementation((path) => {
+      if (path === 'workflow-node-types') return Promise.resolve([]) as never;
+      if (path === 'workflow/callable') return Promise.resolve([]) as never;
+      if (path === 'workflow/42') return Promise.resolve(workflow) as never;
+      if (path === 'workflow/42/versions') return Promise.resolve([]) as never;
+      if (path === 'workflow/42/save') {
+        return Promise.resolve(workflow) as never;
+      }
+      throw new Error(`Unexpected request: ${path}`);
+    });
+    getPendingNodeUpdate.mockReturnValue({
+      nodeId: 'rejected',
+      updates: {
+        config: {
+          method: 'GET',
+          path: '/',
+          timeoutSeconds: 30,
+          queryBindings: {},
+          headerBindings: {},
+          bodyMode: 'FIELDS',
+          bodyBindings: {},
+        },
+      },
+    });
+
+    render(
+      <MemoryRouter initialEntries={['/admin/workflow/edit/42']}>
+        <Routes>
+          <Route
+            path="/admin/workflow/edit/:id"
+            element={<WorkflowEditorPage />}
+          />
+        </Routes>
+      </MemoryRouter>,
+    );
+
+    expect(await screen.findByTestId('workflow-dsl')).toHaveTextContent(
+      'Reject disposal',
+    );
+    fireEvent.click(screen.getByText('DSL'));
+    fireEvent.click(
+      await screen.findByRole('button', { name: 'Edit DSL text' }),
+    );
+    fireEvent.click(screen.getByText('Canvas'));
+    const saveButton = screen.getByRole('button', { name: /Save$/ });
+    expect(saveButton).toBeEnabled();
+    fireEvent.click(saveButton);
+
+    await waitFor(() =>
+      expect(customRequest).toHaveBeenCalledWith('workflow/42/save', 'PATCH', {
+        dsl: expect.objectContaining({
+          nodes: [
+            expect.objectContaining({
+              id: 'rejected',
+              config: {
+                bodyBindings: {
+                  result: {
+                    source: 'FIXED',
+                    valueType: 'STRING',
+                    value: 'REJECTED',
+                  },
+                },
+              },
+            }),
+          ],
+        }),
+      }),
+    );
+    expect(getPendingNodeUpdate).not.toHaveBeenCalled();
+  });
+});