@cccsaurora/howler-ui 3.1.0-dev.1656 → 3.1.0-dev.1675

package/components/routes/action/shared/OperationEntry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/routes/action/shared/OperationEntry.test.js

@@ -0,0 +1,80 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@mui/icons-material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, Delete: () => _jsx("div", { children: "delete-icon" }) };
+});
+vi.mock('@mui/material', () => ({
+    Box: ({ children }) => _jsx("div", { children: children }),
+    Card: ({ children }) => _jsx("div", { children: children }),
+    CardContent: ({ children }) => _jsx("div", { children: children }),
+    Chip: ({ label }) => _jsx("div", { children: label }),
+    Divider: () => _jsx("div", { children: "divider" }),
+    IconButton: ({ children, onClick }) => _jsx("button", { onClick: onClick, children: children }),
+    ListItemText: ({ primary, secondary }) => _jsx("div", { children: `${primary}:${secondary}` }),
+    MenuItem: ({ children }) => _jsx("div", { children: children }),
+    Select: ({ onChange, children }) => (_jsxs("div", { children: [_jsx("button", { onClick: () => onChange({ target: { value: 'op-2' } }), children: "change-operation" }), children] })),
+    Stack: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('components/elements/display/Markdown', () => ({
+    default: ({ md }) => _jsx("div", { children: md })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('utils/actionUtils', () => ({
+    checkArgsAreFilled: (_step, values) => values !== '{}',
+    operationReady: () => true
+}));
+vi.mock('./OperationStep', () => ({
+    default: ({ step, setValues }) => (_jsxs("div", { children: [_jsx("div", { children: `step:${Object.keys(step.args).join(',')}` }), _jsx("button", { onClick: () => setValues?.('{"foo":"bar"}'), children: "set-step-values" })] }))
+}));
+import OperationEntry from './OperationEntry';
+describe('OperationEntry', () => {
+    const makeOperations = () => [
+        {
+            id: 'op-1',
+            title: 'First',
+            description: { short: 'short-1', long: 'long-1' },
+            triggers: ['manual'],
+            steps: [{ args: { first: true } }, { args: { second: true } }],
+            priority: 1
+        },
+        {
+            id: 'op-2',
+            title: 'Second',
+            description: { short: 'short-2', long: 'long-2' },
+            triggers: ['auto'],
+            steps: [{ args: { only: true } }],
+            priority: 2
+        }
+    ];
+    it('renders editable operations, deletes entries, and forwards step updates', () => {
+        const onChange = vi.fn();
+        const onDelete = vi.fn();
+        const operations = makeOperations();
+        render(_jsx(OperationEntry, { query: "status:open", operation: operations[0], operations: operations, values: '{"first":"ok"}', onChange: onChange, onDelete: onDelete }));
+        expect(screen.getByText('long-1')).toBeInTheDocument();
+        expect(screen.getByText('route.actions.trigger.manual')).toBeInTheDocument();
+        expect(screen.getByText('Second:short-2')).toBeInTheDocument();
+        expect(screen.getByText('step:first')).toBeInTheDocument();
+        expect(screen.getByText('step:second')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('change-operation'));
+        expect(onChange).toHaveBeenCalledWith({ operation_id: 'op-2', data_json: '{}' });
+        fireEvent.click(screen.getAllByText('set-step-values')[0]);
+        expect(onChange).toHaveBeenCalledWith({ operation_id: 'op-1', data_json: '{"foo":"bar"}' });
+        fireEvent.click(screen.getByText('delete-icon'));
+        expect(onDelete).toHaveBeenCalled();
+    });
+    it('returns null without an operation id and hides actions when readonly', () => {
+        const operations = makeOperations();
+        const { rerender, container } = render(_jsx(OperationEntry, { query: "q", operation: { id: undefined }, operations: operations }));
+        expect(container.textContent ?? '').toBe('');
+        rerender(_jsx(OperationEntry, { query: "q", operation: operations[0], operations: operations, readonly: true, values: "{}" }));
+        expect(screen.queryByText('delete-icon')).not.toBeInTheDocument();
+        expect(screen.getByText('step:first')).toBeInTheDocument();
+        expect(screen.queryByText('step:second')).not.toBeInTheDocument();
+    });
+});

package/components/routes/action/shared/OperationStep.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/routes/action/shared/OperationStep.test.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockSearchPost = vi.hoisted(() => vi.fn((body) => body));
+vi.mock('@mui/material', () => ({
+    Alert: ({ children }) => _jsx("div", { children: children }),
+    AlertTitle: ({ children }) => _jsx("div", { children: children }),
+    Autocomplete: ({ value, onChange, renderInput }) => (_jsxs("div", { children: [renderInput({ InputProps: {} }), _jsx("button", { onClick: () => onChange(null, 'chosen'), children: value || 'choose' })] })),
+    CircularProgress: () => _jsx("div", { children: "loading" }),
+    InputAdornment: ({ children }) => _jsx("div", { children: children }),
+    LinearProgress: () => _jsx("div", { children: "validating" }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ label, value, onChange, disabled }) => (_jsxs("label", { children: [label, _jsx("input", { "aria-label": label, value: value, onChange: onChange, disabled: disabled })] }))
+}));
+vi.mock('api', () => ({
+    default: {
+        search: {
+            hit: {
+                post: mockSearchPost
+            }
+        }
+    }
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key, values) => `${key}${values?.count ? `:${values.count}` : ''}` })
+}));
+vi.mock('react-router', () => ({
+    Link: ({ to, children }) => _jsx("a", { href: to, children: children })
+}));
+vi.mock('utils/actionUtils', () => ({
+    checkArgsAreFilled: (step, values) => Object.keys(step.args).every(key => JSON.parse(values)[key]),
+    getArgsByContext: (args) => Object.keys(args),
+    getOptionsByContext: (options, arg) => options[arg]
+}));
+vi.mock('utils/stringUtils', () => ({
+    sanitizeLuceneQuery: (value) => value
+}));
+vi.mock('utils/Throttler', () => ({
+    default: class {
+        debounce(fn) {
+            void fn();
+        }
+    }
+}));
+import OperationStep from './OperationStep';
+describe('OperationStep', () => {
+    beforeEach(() => {
+        mockDispatchApi.mockReset();
+        mockSearchPost.mockClear();
+    });
+    it('updates option and text fields and renders validation warnings', async () => {
+        const setValues = vi.fn();
+        mockDispatchApi.mockResolvedValueOnce({ total: 2 }).mockResolvedValueOnce({ total: 0 });
+        render(_jsx(OperationStep, { query: "status:open", values: '{"option":"initial","text":"value"}', setValues: setValues, step: {
+                args: { option: true, text: true },
+                options: { option: ['chosen'] },
+                validation: {
+                    warn: { query: 'warn-query', message: 'warn.message' },
+                    error: { query: 'error-query', message: 'error.message' }
+                }
+            } }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledTimes(2));
+        expect(screen.getByText('warn.message:2')).toBeInTheDocument();
+        expect(screen.getByRole('link')).toHaveAttribute('href', '/hits?query=warn-query');
+        fireEvent.click(screen.getByText('initial'));
+        expect(setValues).toHaveBeenCalledWith('{"option":"chosen","text":"value"}');
+        fireEvent.change(screen.getByLabelText('Text'), { target: { value: 'next' } });
+        expect(setValues).toHaveBeenCalledWith('{"option":"initial","text":"next"}');
+    });
+    it('shows success when validation passes and disables inputs in readonly mode', async () => {
+        mockDispatchApi.mockResolvedValueOnce({ total: 0 });
+        render(_jsx(OperationStep, { query: "status:open", values: '{"name":"demo"}', readonly: true, step: {
+                args: { name: true },
+                validation: { warn: { query: 'warn-query' } }
+            } }));
+        expect(screen.getByLabelText('Name')).toBeDisabled();
+        expect(mockDispatchApi).not.toHaveBeenCalled();
+    });
+});

package/components/routes/action/useMyActionFunctions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/routes/action/useMyActionFunctions.test.js

@@ -0,0 +1,217 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockShowErrorMessage = vi.hoisted(() => vi.fn());
+const mockShowSuccessMessage = vi.hoisted(() => vi.fn());
+const mockShowInfoMessage = vi.hoisted(() => vi.fn(() => 'snackbar-key'));
+const mockCloseSnackbar = vi.hoisted(() => vi.fn());
+const mockNavigate = vi.hoisted(() => vi.fn());
+const mockSearchActionPost = vi.hoisted(() => vi.fn());
+const mockSearchHitPost = vi.hoisted(() => vi.fn((body) => body));
+const mockActionPut = vi.hoisted(() => vi.fn((id, body) => ({ id, ...body })));
+const mockActionPost = vi.hoisted(() => vi.fn((body) => body));
+const mockActionExecutePost = vi.hoisted(() => vi.fn((body) => body));
+const mockActionDelete = vi.hoisted(() => vi.fn((id, refresh) => ({ id, refresh })));
+const socketContextToken = vi.hoisted(() => ({ name: 'socket-context' }));
+let paramsValue = {};
+let locationValue = { pathname: '/action' };
+let socketHandler;
+const mockAddListener = vi.fn((_, handler) => {
+    socketHandler = handler;
+});
+const mockRemoveListener = vi.fn();
+vi.mock('@mui/icons-material', () => ({
+    Terminal: () => _jsx("div", { children: "terminal" })
+}));
+vi.mock('@mui/material', () => ({
+    LinearProgress: () => _jsx("div", { children: "progress" }),
+    Stack: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('api', () => ({
+    default: {
+        search: {
+            hit: {
+                post: mockSearchHitPost
+            },
+            action: {
+                post: mockSearchActionPost
+            }
+        },
+        action: {
+            put: mockActionPut,
+            post: mockActionPost,
+            del: mockActionDelete,
+            execute: {
+                post: mockActionExecutePost
+            }
+        }
+    }
+}));
+vi.mock('components/app/providers/SocketProvider', () => ({
+    SocketContext: socketContextToken
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({
+        showErrorMessage: mockShowErrorMessage,
+        showSuccessMessage: mockShowSuccessMessage,
+        showInfoMessage: mockShowInfoMessage
+    })
+}));
+vi.mock('notistack', () => ({
+    useSnackbar: () => ({ closeSnackbar: mockCloseSnackbar })
+}));
+vi.mock('react-i18next', () => ({
+    Trans: ({ i18nKey, values }) => (_jsx("span", { children: `${i18nKey}:${values?.action ?? values?.messages ?? values?.message ?? ''}` })),
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react-router', () => ({
+    useLocation: () => locationValue,
+    useNavigate: () => mockNavigate,
+    useParams: () => paramsValue
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === socketContextToken) {
+                return { addListener: mockAddListener, removeListener: mockRemoveListener };
+            }
+            return actual.useContext(context);
+        }
+    };
+});
+vi.mock('uuid', () => ({
+    v4: () => 'req-123'
+}));
+import useMyActionFunctions from './useMyActionFunctions';
+describe('useMyActionFunctions', () => {
+    beforeEach(() => {
+        paramsValue = {};
+        locationValue = { pathname: '/action' };
+        socketHandler = undefined;
+        mockDispatchApi.mockReset();
+        mockShowErrorMessage.mockReset();
+        mockShowSuccessMessage.mockReset();
+        mockShowInfoMessage.mockReset();
+        mockShowInfoMessage.mockReturnValue('snackbar-key');
+        mockCloseSnackbar.mockReset();
+        mockNavigate.mockReset();
+        mockSearchActionPost.mockReset();
+        mockSearchHitPost.mockClear();
+        mockActionPut.mockClear();
+        mockActionPost.mockClear();
+        mockActionExecutePost.mockClear();
+        mockActionDelete.mockClear();
+        mockAddListener.mockClear();
+        mockRemoveListener.mockClear();
+    });
+    it('searches and saves both new and existing actions', async () => {
+        mockDispatchApi.mockImplementation(async (request) => {
+            if (request?.track_total_hits)
+                return { items: [{ howler: { id: 'h1' } }], total: 1 };
+            if (request?.name === 'New Action')
+                return { action_id: 'action-1' };
+            if (request?.id === 'existing-id')
+                return { updated: true };
+            return {};
+        });
+        const { result, unmount } = renderHook(() => useMyActionFunctions());
+        await act(async () => {
+            await result.current.onSearch('howler.id:*');
+        });
+        expect(result.current.responseQuery).toBe('howler.id:*');
+        expect(result.current.response?.total).toBe(1);
+        await act(async () => {
+            await result.current.saveAction('', '', [], []);
+        });
+        expect(mockShowErrorMessage).toHaveBeenCalledWith('route.actions.query.empty');
+        await act(async () => {
+            await result.current.saveAction('New Action', 'status:open', [], ['manual']);
+        });
+        expect(mockActionPost).toHaveBeenCalledWith({
+            name: 'New Action',
+            query: 'status:open',
+            operations: [],
+            triggers: ['manual']
+        });
+        expect(mockNavigate).toHaveBeenCalledWith('/action/action-1');
+        paramsValue = { id: 'existing-id' };
+        unmount();
+        const updatedHook = renderHook(() => useMyActionFunctions());
+        await act(async () => {
+            await updatedHook.result.current.saveAction('Existing', 'status:closed', [], []);
+        });
+        expect(mockActionPut).toHaveBeenCalledWith('existing-id', {
+            name: 'Existing',
+            query: 'status:closed',
+            operations: []
+        });
+        expect(mockNavigate).toHaveBeenCalledWith('/action/existing-id');
+    });
+    it('submits actions, tracks socket progress, and deletes detailed actions', async () => {
+        locationValue = { pathname: '/action/action-9' };
+        mockDispatchApi.mockImplementation(async (request) => {
+            if (request?.request_id && Array.isArray(request?.operations)) {
+                return { phase: [{ outcome: 'success', message: 'done' }] };
+            }
+            if (request?.track_total_hits) {
+                return { items: [{ howler: { id: 'h2' } }], total: 1 };
+            }
+            if (request?.id === 'action-9')
+                return {};
+            return {};
+        });
+        const { result } = renderHook(() => useMyActionFunctions());
+        expect(mockAddListener).toHaveBeenCalledWith('action', expect.any(Function));
+        await act(async () => {
+            socketHandler?.({ type: 'action', request_id: 'req-123', processed: 2, total: 5 });
+        });
+        expect(result.current.progress).toEqual([0, 0]);
+        await act(async () => {
+            await result.current.submitAction('status:open', [{ id: 'op' }]);
+        });
+        expect(mockActionExecutePost).toHaveBeenCalledWith({
+            request_id: 'req-123',
+            query: 'status:open',
+            operations: [{ id: 'op' }]
+        });
+        await waitFor(() => expect(result.current.report).toEqual({ phase: [{ outcome: 'success', message: 'done' }] }));
+        expect(result.current.responseQuery).toBe('status:open');
+        await act(async () => {
+            await result.current.deleteAction('action-9');
+        });
+        expect(mockActionDelete).toHaveBeenCalledWith('action-9', 'wait_for');
+        expect(mockNavigate).toHaveBeenCalledWith('/action');
+    });
+    it('executes an action and reports mixed outcomes', async () => {
+        mockSearchActionPost.mockResolvedValueOnce({ items: [{ name: 'Demo Action' }] });
+        mockDispatchApi.mockResolvedValueOnce({
+            stage: [
+                { outcome: 'error', message: 'broken' },
+                { outcome: 'skipped', message: 'ignored' },
+                { outcome: 'success', message: 'done' }
+            ]
+        });
+        const { result } = renderHook(() => useMyActionFunctions());
+        await act(async () => {
+            await result.current.executeAction('action-1', 'status:open');
+        });
+        expect(mockShowInfoMessage).toHaveBeenCalled();
+        expect(mockShowErrorMessage).toHaveBeenCalled();
+        expect(mockShowSuccessMessage).toHaveBeenCalled();
+        expect(mockCloseSnackbar).toHaveBeenCalledWith('snackbar-key');
+        expect(result.current.report).toEqual({
+            stage: [
+                { outcome: 'error', message: 'broken' },
+                { outcome: 'skipped', message: 'ignored' },
+                { outcome: 'success', message: 'done' }
+            ]
+        });
+    });
+});

package/components/routes/action/view/ActionDetails.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/routes/action/view/ActionDetails.test.js

@@ -0,0 +1,170 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockShowSuccessMessage = vi.hoisted(() => vi.fn());
+const mockExecuteAction = vi.hoisted(() => vi.fn());
+const mockDeleteAction = vi.hoisted(() => vi.fn());
+const mockOnSearch = vi.hoisted(() => vi.fn());
+const mockSetLoading = vi.hoisted(() => vi.fn());
+const mockPluginExecute = vi.hoisted(() => vi.fn(() => _jsx("div", { children: "plugin-operation" }, "plugin-operation")));
+const modalContextToken = vi.hoisted(() => ({ name: 'modal-context' }));
+vi.mock('@mui/icons-material', () => ({
+    Delete: () => _jsx("div", { children: "delete-icon" }),
+    Edit: () => _jsx("div", { children: "edit-icon" }),
+    PlayCircleOutline: () => _jsx("div", { children: "play-icon" }),
+    Search: () => _jsx("div", { children: "search-icon" })
+}));
+vi.mock('@mui/material', () => ({
+    Button: ({ children, onClick, component: Component, to }) => Component ? _jsx("a", { href: to, children: children }) : _jsx("button", { onClick: onClick, children: children }),
+    Checkbox: ({ name, onChange, checked }) => (_jsx("input", { type: "checkbox", "aria-label": name, checked: checked, onChange: e => onChange({ target: { name, checked: e.target.checked } }) })),
+    FormControlLabel: ({ control, label }) => (_jsxs("label", { children: [control, label] })),
+    FormGroup: ({ children }) => _jsx("div", { children: children }),
+    IconButton: ({ children, onClick }) => _jsx("button", { onClick: onClick, children: children }),
+    LinearProgress: ({ value }) => _jsx("div", { children: `progress:${value ?? 'indeterminate'}` }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('@tui/core', () => ({
+    PageCenter: ({ children }) => _jsx("div", { children: children }),
+    useAppUser: () => ({ user: { username: 'alice', roles: ['automation_advanced'] } })
+}));
+vi.mock('api', () => ({
+    default: {
+        action: {
+            patch: (id, body) => ({ op: 'patch', id, body }),
+            operations: { get: () => ({ op: 'get-operations' }) },
+            get: (id) => ({ op: 'get-action', id })
+        }
+    }
+}));
+vi.mock('components/app/providers/ModalProvider', () => ({
+    ModalContext: modalContextToken
+}));
+vi.mock('components/elements/addons/layout/FlexOne', () => ({
+    default: () => _jsx("div", { children: "flex" })
+}));
+vi.mock('components/elements/addons/search/phrase/Phrase', () => ({
+    default: ({ value, startAdornment }) => (_jsxs("div", { children: [startAdornment, _jsx("div", { children: `phrase:${value}` })] }))
+}));
+vi.mock('components/elements/display/HowlerAvatar', () => ({
+    default: ({ userId }) => _jsx("div", { children: `avatar:${userId}` })
+}));
+vi.mock('components/elements/membership/MembershipManagement', () => ({
+    MembershipManagement: () => _jsx("div", { children: "membership-management" })
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({ showSuccessMessage: mockShowSuccessMessage })
+}));
+vi.mock('components/routes/action/shared/OperationEntry', () => ({
+    default: ({ operation, values }) => _jsx("div", { children: `operation:${operation.id}:${values.kind}` })
+}));
+vi.mock('plugins/store', () => ({
+    default: { operations: ['plugin-op'] }
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context?.name === 'modal-context') {
+                return { withConfirmDeleteModal: async (cb) => cb() };
+            }
+            return actual.useContext(context);
+        }
+    };
+});
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react-pluggable', () => ({
+    usePluginStore: () => ({ executeFunction: mockPluginExecute })
+}));
+vi.mock('react-router', () => ({
+    Link: ({ children, to }) => _jsx("a", { href: to, children: children }),
+    useParams: () => ({ id: 'action-1' })
+}));
+vi.mock('../../../elements/display/QueryResultText', () => ({
+    default: ({ count, query }) => _jsx("div", { children: `query-result:${count}:${query}` })
+}));
+vi.mock('../shared/ActionReportDisplay', () => ({
+    default: ({ report }) => _jsx("div", { children: `report:${report.status}` })
+}));
+vi.mock('../useMyActionFunctions', () => ({
+    default: () => ({
+        response: { total: 7 },
+        onSearch: mockOnSearch,
+        loading: true,
+        setLoading: mockSetLoading,
+        executeAction: mockExecuteAction,
+        deleteAction: mockDeleteAction,
+        progress: [2, 4],
+        report: { status: 'done' }
+    })
+}));
+import ActionDetails from './ActionDetails';
+describe('ActionDetails', () => {
+    beforeEach(() => {
+        mockDispatchApi.mockReset();
+        mockShowSuccessMessage.mockReset();
+        mockExecuteAction.mockReset();
+        mockDeleteAction.mockReset();
+        mockOnSearch.mockReset();
+        mockSetLoading.mockReset();
+        mockPluginExecute.mockClear();
+        mockDispatchApi.mockImplementation(async (request) => {
+            if (request.op === 'get-operations') {
+                return [
+                    { id: 'direct-op', triggers: ['manual', 'alert'] },
+                    { id: 'plugin-op', triggers: ['alert'] }
+                ];
+            }
+            if (request.op === 'get-action') {
+                return {
+                    action_id: 'action-1',
+                    owner: 'alice',
+                    name: 'My action',
+                    query: 'status:open',
+                    admins: ['alice'],
+                    members: ['alice'],
+                    triggers: ['manual'],
+                    operations: [
+                        { operation_id: 'direct-op', data_json: { kind: 'direct' } },
+                        { operation_id: 'plugin-op', data_json: { kind: 'plugin' } }
+                    ]
+                };
+            }
+            return request;
+        });
+    });
+    it('loads action details, searches, patches triggers, executes, deletes, and renders operations', async () => {
+        render(_jsx(ActionDetails, {}));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledTimes(2));
+        await waitFor(() => expect(mockOnSearch).toHaveBeenCalledWith('status:open'));
+        expect(screen.getByText('My action')).toBeInTheDocument();
+        expect(screen.getByText('avatar:alice')).toBeInTheDocument();
+        expect(screen.getByText('query-result:7:status:open')).toBeInTheDocument();
+        expect(screen.getByText('report:done')).toBeInTheDocument();
+        expect(screen.getByText('progress:50')).toBeInTheDocument();
+        expect(screen.getByText('operation:direct-op:direct')).toBeInTheDocument();
+        expect(screen.getByText('plugin-operation')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('search-icon').parentElement);
+        expect(mockOnSearch).toHaveBeenCalledWith('status:open');
+        fireEvent.click(screen.getByLabelText('alert'));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({
+            op: 'patch',
+            id: 'action-1',
+            body: { triggers: ['manual', 'alert'] }
+        }));
+        fireEvent.click(screen.getByText('route.actions.execute'));
+        expect(mockExecuteAction).toHaveBeenCalledWith('action-1');
+        fireEvent.click(screen.getByText('button.delete'));
+        await waitFor(() => expect(mockDeleteAction).toHaveBeenCalledWith('action-1'));
+        expect(mockShowSuccessMessage).toHaveBeenCalledWith('route.actions.manager.delete.success');
+        expect(screen.getByRole('link', { name: 'route.actions.edit' })).toHaveAttribute('href', '/action/action-1/edit');
+    });
+});

package/components/routes/action/view/ActionSearch.test.d.ts

@@ -0,0 +1 @@
+export {};