@cccsaurora/howler-ui 3.1.0-dev.1655 → 3.1.0-dev.1657

package/components/logins/hooks/useLogin.test.js

@@ -0,0 +1,142 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { renderHook } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockSetUser = vi.hoisted(() => vi.fn());
+const mockShowErrorMessage = vi.hoisted(() => vi.fn());
+const mockShowModal = vi.hoisted(() => vi.fn());
+const mockNavigate = vi.hoisted(() => vi.fn());
+const mockGet = vi.hoisted(() => vi.fn());
+const mockRemove = vi.hoisted(() => vi.fn());
+const mockSaveLoginCredential = vi.hoisted(() => vi.fn());
+const mockWhoamiGet = vi.hoisted(() => vi.fn(() => ({ url: 'whoami' })));
+const mockLoginPost = vi.hoisted(() => vi.fn((body) => ({ type: 'login-post', body })));
+const mockLoginGet = vi.hoisted(() => vi.fn((params) => ({ type: 'login-get', params })));
+let locationValue = { pathname: '/login', search: '' };
+let searchParamsValue = new URLSearchParams('code=abc');
+const modalContextToken = vi.hoisted(() => ({ name: 'modal-context' }));
+vi.mock('@tui/core', () => ({
+    useAppUser: () => ({ setUser: mockSetUser })
+}));
+vi.mock('api', () => ({
+    default: {
+        user: { whoami: { get: mockWhoamiGet } },
+        auth: { login: { post: mockLoginPost, get: mockLoginGet } }
+    }
+}));
+vi.mock('components/app/providers/ModalProvider', () => ({
+    ModalContext: modalContextToken
+}));
+vi.mock('components/elements/display/modals/LoginErrorModal', () => ({
+    default: ({ error }) => _jsx("div", { children: error.message })
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/hooks/useMyLocalStorage', () => ({
+    default: () => ({ get: mockGet, remove: mockRemove })
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({ showErrorMessage: mockShowErrorMessage })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react-router', () => ({
+    useLocation: () => locationValue,
+    useNavigate: () => mockNavigate,
+    useSearchParams: () => [searchParamsValue]
+}));
+vi.mock('utils/localStorage', () => ({
+    saveLoginCredential: mockSaveLoginCredential
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === modalContextToken) {
+                return { showModal: mockShowModal };
+            }
+            return actual.useContext(context);
+        }
+    };
+});
+import useLogin from './useLogin';
+describe('useLogin', () => {
+    beforeEach(() => {
+        locationValue = { pathname: '/login', search: '' };
+        searchParamsValue = new URLSearchParams('code=abc');
+        mockDispatchApi.mockReset();
+        mockSetUser.mockReset();
+        mockShowErrorMessage.mockReset();
+        mockShowModal.mockReset();
+        mockNavigate.mockReset();
+        mockGet.mockReset();
+        mockRemove.mockReset();
+        mockSaveLoginCredential.mockReset();
+    });
+    it('hydrates the user and navigates to stored next location', async () => {
+        mockDispatchApi.mockResolvedValueOnce({
+            username: 'demo',
+            favourite_analytics: undefined
+        });
+        mockGet.mockImplementation((key) => {
+            if (key === StorageKey.NEXT_LOCATION)
+                return '/hits/1';
+            if (key === StorageKey.NEXT_SEARCH)
+                return '?tab=details';
+            return undefined;
+        });
+        const { result } = renderHook(() => useLogin());
+        await result.current.getUser();
+        expect(mockDispatchApi).toHaveBeenCalledWith({ url: 'whoami' }, { showError: false, throwError: true });
+        expect(mockSetUser).toHaveBeenCalledWith({ username: 'demo', favourite_analytics: [] });
+        expect(mockNavigate).toHaveBeenCalledWith('/hits/1?tab=details');
+        expect(mockRemove).toHaveBeenCalledWith(StorageKey.NEXT_LOCATION);
+        expect(mockRemove).toHaveBeenCalledWith(StorageKey.NEXT_SEARCH);
+    });
+    it('navigates home on the login route, handles null users, and routes 403 errors to logout', async () => {
+        const { result } = renderHook(() => useLogin());
+        mockDispatchApi.mockResolvedValueOnce({ username: 'demo', favourite_analytics: ['a'] });
+        mockGet.mockReturnValue(undefined);
+        await result.current.getUser();
+        expect(mockNavigate).toHaveBeenCalledWith('/');
+        mockDispatchApi.mockResolvedValueOnce(null);
+        await result.current.getUser();
+        expect(mockSetUser).toHaveBeenCalledWith(null);
+        expect(mockShowErrorMessage).toHaveBeenCalledWith('user.error.failed');
+        mockDispatchApi.mockRejectedValueOnce(Object.assign(new Error('forbidden'), { cause: { api_status_code: 403 } }));
+        await result.current.getUser();
+        expect(mockNavigate).toHaveBeenCalledWith('/logout');
+    });
+    it('shows the login error modal for non-403 failures', async () => {
+        const { result } = renderHook(() => useLogin());
+        mockDispatchApi.mockRejectedValueOnce(new Error('network down'));
+        await result.current.getUser();
+        expect(mockShowModal).toHaveBeenCalled();
+        expect(mockShowModal.mock.calls[0][1]).toEqual({ disableClose: true });
+    });
+    it('performs password and oauth login flows', async () => {
+        const { result } = renderHook(() => useLogin());
+        mockDispatchApi.mockResolvedValueOnce(null);
+        await result.current.doLogin({ user: 'demo', password: 'bad' });
+        expect(mockShowErrorMessage).toHaveBeenCalledWith('user.login.failed');
+        mockDispatchApi.mockResolvedValueOnce({ access_token: 'token' });
+        mockSaveLoginCredential.mockReturnValueOnce(true);
+        mockDispatchApi.mockResolvedValueOnce({ username: 'demo', favourite_analytics: [] });
+        await result.current.doLogin({ user: 'demo', password: 'good' });
+        expect(mockLoginPost).toHaveBeenCalledWith({ user: 'demo', password: 'good' });
+        expect(mockSaveLoginCredential).toHaveBeenCalledWith({ access_token: 'token' });
+        mockDispatchApi.mockResolvedValueOnce({ access_token: 'oauth' });
+        mockSaveLoginCredential.mockReturnValueOnce(true);
+        mockDispatchApi.mockResolvedValueOnce({ username: 'oauth-user', favourite_analytics: [] });
+        await result.current.doOAuth();
+        expect(mockLoginGet).toHaveBeenCalledWith(searchParamsValue);
+        mockDispatchApi.mockResolvedValueOnce(null);
+        await result.current.doOAuth();
+        expect(mockShowErrorMessage).toHaveBeenCalledWith('user.login.failed');
+    });
+});

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 {};