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

package/components/elements/hit/HitLabels.test.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { render, screen } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
 import { describe, expect, it, vi } from 'vitest';
 import HitLabels from './HitLabels';
 /**
@@ -12,16 +12,18 @@ import HitLabels from './HitLabels';
  * - Conditional display of the edit button based on readOnly mode
  * - Safe rendering when no labels are present
  */
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockUpdateRecord = vi.hoisted(() => vi.fn());
 vi.mock('components/hooks/useMyApi', () => ({
     default: () => ({
-        dispatchApi: vi.fn()
+        dispatchApi: mockDispatchApi
     })
 }));
 vi.mock('components/app/providers/RecordProvider', () => ({
     RecordContext: {}
 }));
 vi.mock('use-context-selector', () => ({
-    useContextSelector: () => vi.fn()
+    useContextSelector: () => mockUpdateRecord
 }));
 vi.mock('react-i18next', () => ({
     useTranslation: () => ({
@@ -31,6 +33,7 @@ vi.mock('react-i18next', () => ({
 }));
 vi.mock('utils/constants', () => ({
     LABEL_TYPES: {
+        generic: { icon: null, color: '#0000ff' },
         security: { icon: null, color: '#ff0000' },
         system: { icon: null, color: '#00ff00' }
     }
@@ -74,4 +77,32 @@ describe('HitLabels', () => {
         const { container } = render(_jsx(HitLabels, { hit: emptyHit, readOnly: true }));
         expect(container).toBeInTheDocument();
     });
+    it('opens the drawer, validates empty input, and adds labels', async () => {
+        mockDispatchApi.mockResolvedValueOnce({
+            howler: { labels: { security: ['critical', 'high'], system: ['info'], generic: ['fresh'] } }
+        });
+        render(_jsx(HitLabels, { hit: baseHit, readOnly: false }));
+        fireEvent.click(screen.getByRole('button'));
+        fireEvent.keyDown(screen.getByLabelText('hit.label.edit.add.label'), { key: 'Enter' });
+        expect(screen.getByText('hit.label.edit.add.error.empty')).toBeInTheDocument();
+        fireEvent.change(screen.getByLabelText('hit.label.edit.add.label'), { target: { value: 'fresh' } });
+        fireEvent.keyDown(screen.getByLabelText('hit.label.edit.add.label'), { key: 'Enter' });
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({
+            op: 'put',
+            id: 'hit-1',
+            category: 'generic',
+            body: { value: ['fresh'] }
+        }));
+        expect(mockUpdateRecord).toHaveBeenCalled();
+    });
 });
+vi.mock('api', () => ({
+    default: {
+        hit: {
+            labels: {
+                put: (id, category, body) => ({ op: 'put', id, category, body }),
+                del: (id, category, body) => ({ op: 'del', id, category, body })
+            }
+        }
+    }
+}));

package/components/elements/hit/HitNotebooks.test.d.ts

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

package/components/elements/hit/HitNotebooks.test.js

@@ -0,0 +1,138 @@
+import { Fragment as _Fragment, 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 mockShowErrorMessage = vi.hoisted(() => vi.fn());
+const mockShowModal = vi.hoisted(() => vi.fn((node) => node.props.onConfirm()));
+const mockNotebookPost = vi.hoisted(() => vi.fn((body) => body));
+const mockEnvironmentsGet = vi.hoisted(() => vi.fn(() => ({ envs: true })));
+const apiConfigContextToken = vi.hoisted(() => ({ name: 'api-config-context' }));
+const modalContextToken = vi.hoisted(() => ({ name: 'modal-context' }));
+let configValue = {
+    configuration: {
+        features: {
+            notebook: true
+        }
+    }
+};
+vi.mock('@mui/material', () => ({
+    Avatar: ({ children }) => _jsx("div", { children: children }),
+    Backdrop: ({ children, open }) => (open ? _jsx("div", { children: children }) : null),
+    Box: ({ children }) => _jsx("div", { children: children }),
+    Button: ({ children, onClick, disabled }) => (_jsx("button", { onClick: onClick, disabled: disabled, children: children })),
+    Chip: ({ label }) => _jsx("span", { children: label }),
+    CircularProgress: () => _jsx("div", { children: "loading" }),
+    ClickAwayListener: ({ children }) => _jsx(_Fragment, { children: children }),
+    Fade: ({ children }) => _jsx(_Fragment, { children: children }),
+    MenuItem: ({ children, value, disabled }) => (_jsx("option", { value: value, disabled: disabled, children: children })),
+    Paper: ({ children }) => _jsx("div", { children: children }),
+    Popper: ({ children, open }) => (open ? children({ TransitionProps: {} }) : null),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ children, label, onChange, defaultValue, disabled, select }) => select ? (_jsxs("label", { children: [label, _jsx("select", { "aria-label": label, defaultValue: defaultValue, onChange: onChange, disabled: disabled, children: children })] })) : (_jsxs("label", { children: [label, _jsx("input", { "aria-label": label, onChange: onChange, disabled: disabled })] })),
+    Tooltip: ({ children }) => _jsx(_Fragment, { children: children })
+}));
+vi.mock('api', () => ({
+    default: {
+        notebook: {
+            environments: {
+                get: mockEnvironmentsGet
+            },
+            post: mockNotebookPost
+        }
+    }
+}));
+vi.mock('components/app/providers/ApiConfigProvider', () => ({
+    ApiConfigContext: apiConfigContextToken
+}));
+vi.mock('components/app/providers/ModalProvider', () => ({
+    ModalContext: modalContextToken
+}));
+vi.mock('components/elements/display/HowlerCard', () => ({
+    default: ({ children, onClick }) => _jsx("button", { onClick: onClick, children: children })
+}));
+vi.mock('components/elements/hit/NotebookTooltip', () => ({
+    default: () => _jsx("div", { children: "tooltip" })
+}));
+vi.mock('components/elements/display/modals/ConfirmNotebookModal', () => ({
+    default: ({ onConfirm }) => _jsx("button", { onClick: onConfirm, children: "confirm notebook" })
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({ showErrorMessage: mockShowErrorMessage })
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === apiConfigContextToken)
+                return { config: configValue };
+            if (context === modalContextToken)
+                return { showModal: mockShowModal };
+            return actual.useContext(context);
+        }
+    };
+});
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('utils/stringUtils', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        safeStringPropertyCompare: (key) => (a, b) => String(a[key] ?? '').localeCompare(String(b[key] ?? ''))
+    };
+});
+import HitNotebooks from './HitNotebooks';
+describe('HitNotebooks', () => {
+    beforeEach(() => {
+        configValue = { configuration: { features: { notebook: true } } };
+        mockDispatchApi.mockReset();
+        mockShowErrorMessage.mockReset();
+        mockShowModal.mockClear();
+        mockNotebookPost.mockClear();
+        mockEnvironmentsGet.mockClear();
+        vi.stubGlobal('fetch', vi.fn());
+        vi.stubGlobal('open', vi.fn());
+    });
+    it('loads notebook content and opens jupyter when the notebook does not already exist', async () => {
+        mockDispatchApi
+            .mockResolvedValueOnce({
+            envs: [{ name: 'env', url: 'https://nb.example', default: true, user_interface: 'lab' }]
+        })
+            .mockResolvedValueOnce({ nb_content: { cells: [] }, name: 'Loaded Notebook' });
+        globalThis.fetch.mockResolvedValueOnce({ status: 404 }).mockResolvedValueOnce({ status: 200 });
+        render(_jsx(HitNotebooks, { analytic: { notebooks: [{ name: 'Notebook A', value: 'link-a', detection: 'det-b' }] }, selectedNotebook: "Notebook A", hit: { howler: { id: 'hit-1' } } }));
+        fireEvent.click(screen.getByRole('button', { name: /hit\.notebook\.tooltip/i }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledTimes(2));
+        expect(mockNotebookPost).toHaveBeenCalledWith(expect.objectContaining({
+            link: 'link-a',
+            hit: { howler: { id: 'hit-1' } }
+        }));
+        fireEvent.click(screen.getByText('hit.notebook.goTo'));
+        await waitFor(() => expect(globalThis.fetch).toHaveBeenCalledWith('https://nb.example/api/contents/Loaded Notebook - hit-1.ipynb', expect.any(Object)));
+        await waitFor(() => expect(globalThis.fetch).toHaveBeenCalledWith('https://nb.example/post/Loaded Notebook - hit-1.ipynb', expect.objectContaining({ method: 'post' })));
+        expect(globalThis.open).toHaveBeenCalledWith('https://nb.example/lab/tree/Loaded Notebook - hit-1.ipynb', '_blank');
+    });
+    it('confirms overwrite for existing notebooks and can hide itself when notebooks are disabled', async () => {
+        configValue = { configuration: { features: { notebook: false } } };
+        const { rerender } = render(_jsx(HitNotebooks, { analytic: { notebooks: [{ name: 'Notebook A', value: 'link-a' }] } }));
+        expect(screen.queryByText('hit.notebook.tooltip')).not.toBeInTheDocument();
+        configValue = { configuration: { features: { notebook: true } } };
+        mockDispatchApi
+            .mockResolvedValueOnce({
+            envs: [{ name: 'env', url: 'https://nb.example/', default: true, user_interface: 'lab' }]
+        })
+            .mockResolvedValueOnce({ nb_content: { cells: [] }, name: 'Notebook A' });
+        globalThis.fetch.mockResolvedValueOnce({ status: 200 }).mockResolvedValueOnce({ status: 200 });
+        rerender(_jsx(HitNotebooks, { analytic: { notebooks: [{ name: 'Notebook A', value: 'link-a' }] }, selectedNotebook: "Notebook A" }));
+        fireEvent.click(screen.getByRole('button', { name: /hit\.notebook\.tooltip/i }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledTimes(2));
+        fireEvent.click(screen.getByText('hit.notebook.goTo'));
+        await waitFor(() => expect(mockShowModal).toHaveBeenCalled());
+        await waitFor(() => expect(globalThis.fetch).toHaveBeenCalledWith('https://nb.example/post/Notebook A.ipynb', expect.objectContaining({ method: 'post' })));
+    });
+});

package/components/elements/hit/HitSummary.test.d.ts

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

package/components/elements/hit/HitSummary.test.js

@@ -0,0 +1,188 @@
+import { Fragment as _Fragment, 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 mockShowErrorMessage = vi.hoisted(() => vi.fn());
+const mockSetQuery = vi.hoisted(() => vi.fn());
+const mockGetFilters = vi.hoisted(() => vi.fn().mockResolvedValue(['status:open']));
+const mockGetMatchingTemplate = vi.hoisted(() => vi.fn());
+const fieldContextToken = vi.hoisted(() => ({ name: 'field-context' }));
+const parameterContextToken = vi.hoisted(() => ({ name: 'parameter-context' }));
+const recordSearchContextToken = vi.hoisted(() => ({ name: 'record-search-context' }));
+let fieldContextValue;
+let parameterContextValue;
+let recordSearchContextValue;
+vi.mock('@mui/icons-material', () => ({
+    Analytics: () => _jsx("div", { children: "analytics-icon" }),
+    InfoOutlined: () => _jsx("div", { children: "info-icon" })
+}));
+vi.mock('@mui/material', () => ({
+    Alert: ({ children }) => _jsx("div", { children: children }),
+    AlertTitle: ({ children }) => _jsx("div", { children: children }),
+    Autocomplete: ({ onChange, renderInput }) => (_jsxs("div", { children: [renderInput({}), _jsx("button", { onClick: () => onChange?.(null, ['custom.field']), children: "add-custom-field" })] })),
+    Box: ({ children }) => _jsx("div", { children: children }),
+    Button: ({ children, onClick, disabled }) => (_jsx("button", { onClick: onClick, disabled: disabled, children: children })),
+    Chip: ({ label, onClick }) => _jsx("button", { onClick: onClick, children: label }),
+    CircularProgress: () => _jsx("div", { children: "loading" }),
+    Divider: () => _jsx("div", { children: "divider" }),
+    Fade: ({ children }) => _jsx("div", { children: children }),
+    Grid: ({ children }) => _jsx("div", { children: children }),
+    LinearProgress: () => _jsx("div", { children: "progress" }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ label }) => _jsx("div", { children: label }),
+    Tooltip: ({ children }) => _jsx(_Fragment, { children: children }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('api', () => ({
+    default: {
+        search: {
+            facet: {
+                hit: {
+                    post: (body) => body
+                }
+            }
+        }
+    }
+}));
+vi.mock('components/app/hooks/useMatchers', () => ({
+    default: () => ({ getMatchingTemplate: mockGetMatchingTemplate })
+}));
+vi.mock('components/app/providers/FieldProvider', () => ({
+    FieldContext: fieldContextToken
+}));
+vi.mock('components/app/providers/ParameterProvider', () => ({
+    ParameterContext: parameterContextToken
+}));
+vi.mock('components/app/providers/RecordSearchProvider', () => ({
+    RecordSearchContext: recordSearchContextToken
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/hooks/useMyLocalStorage', () => ({
+    useMyLocalStorageItem: (key, fallback) => [key === 'SHOW_HIT_SUMMARY_GRAPH' ? true : fallback]
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({ showErrorMessage: mockShowErrorMessage })
+}));
+vi.mock('lodash-es', () => ({
+    isEmpty: (value) => value == null ||
+        (Array.isArray(value) ? value.length === 0 : typeof value === 'object' ? Object.keys(value).length === 0 : !value)
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (context, selector) => {
+        if (context === parameterContextToken)
+            return selector(parameterContextValue);
+        if (context === recordSearchContextToken)
+            return selector(recordSearchContextValue);
+        return undefined;
+    }
+}));
+vi.mock('utils/constants', () => ({
+    StorageKey: {
+        PAGE_COUNT: 'PAGE_COUNT',
+        SHOW_HIT_SUMMARY_GRAPH: 'SHOW_HIT_SUMMARY_GRAPH'
+    }
+}));
+vi.mock('utils/typeUtils', () => ({
+    isHit: (item) => item?.__index === 'hit'
+}));
+vi.mock('utils/utils', () => ({
+    getTimeRange: (values) => [values[0], values[values.length - 1]],
+    notNil: (value) => value != null
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === fieldContextToken)
+                return fieldContextValue;
+            return actual.useContext(context);
+        }
+    };
+});
+vi.mock('../PluginChip', () => ({
+    default: ({ label, onClick }) => _jsx("button", { onClick: onClick, children: label })
+}));
+vi.mock('./aggregate/HitGraph', () => ({
+    default: () => _jsx("div", { children: "hit-graph" })
+}));
+import HitSummary from './HitSummary';
+describe('HitSummary', () => {
+    beforeEach(() => {
+        fieldContextValue = {
+            hitFields: [
+                { key: 'severity', type: 'keyword' },
+                { key: 'event.created', type: 'date' }
+            ]
+        };
+        parameterContextValue = {
+            query: 'status:open',
+            setQuery: mockSetQuery,
+            views: []
+        };
+        recordSearchContextValue = {
+            searching: false,
+            error: '',
+            getFilters: mockGetFilters
+        };
+        mockDispatchApi.mockReset();
+        mockShowErrorMessage.mockReset();
+        mockSetQuery.mockReset();
+        mockGetFilters.mockClear();
+        mockGetMatchingTemplate.mockReset();
+    });
+    it('aggregates template keys, supports ad hoc fields, and updates the search query from results', async () => {
+        mockGetMatchingTemplate
+            .mockResolvedValueOnce({ analytic: 'Analytic A', detection: 'Rule A', keys: ['severity', 'howler.id'] })
+            .mockResolvedValueOnce({ analytic: 'Analytic A', detection: 'Rule B', keys: ['event.created'] });
+        mockDispatchApi
+            .mockResolvedValueOnce({
+            severity: { high: 2, low: 1 },
+            'event.created': { '2026-01-01T00:00:00Z': 1, '2026-01-02T00:00:00Z': 1 }
+        })
+            .mockResolvedValueOnce({
+            severity: { high: 2 },
+            'event.created': { '2026-01-01T00:00:00Z': 1, '2026-01-02T00:00:00Z': 1 },
+            'custom.field': { custom: 3 }
+        });
+        render(_jsx(HitSummary, { response: {
+                items: [
+                    { __index: 'hit', howler: { id: 'hit-1' } },
+                    { __index: 'hit', howler: { id: 'hit-2' } }
+                ]
+            } }));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({
+            fields: ['severity', 'event.created'],
+            query: 'status:open',
+            rows: 25,
+            filters: ['status:open']
+        }, { throwError: false, logError: true, showError: false }));
+        expect(screen.getByText('hit-graph')).toBeInTheDocument();
+        expect(screen.getByText('severity')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('high (2)'));
+        expect(mockSetQuery).toHaveBeenCalledWith('severity:"high"');
+        fireEvent.click(screen.getByText('add-custom-field'));
+        fireEvent.click(screen.getByText('button.aggregate'));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenLastCalledWith({
+            fields: ['custom.field'],
+            query: 'status:open',
+            rows: 25,
+            filters: ['status:open']
+        }, { throwError: false, logError: true, showError: false }));
+        expect(screen.getByText('custom.field')).toBeInTheDocument();
+    });
+    it('shows the empty state and reports aggregation failures', async () => {
+        mockGetMatchingTemplate.mockResolvedValueOnce({ analytic: 'Analytic A', detection: 'Rule A', keys: ['severity'] });
+        mockDispatchApi.mockRejectedValueOnce(new Error('aggregate failed'));
+        render(_jsx(HitSummary, { response: { items: [{ __index: 'hit', howler: { id: 'hit-1' } }] } }));
+        await waitFor(() => expect(mockShowErrorMessage).toHaveBeenCalledWith('aggregate failed'));
+        expect(screen.getByText('hit.summary.aggregate.nokeys.title')).toBeInTheDocument();
+        expect(screen.getByText('hit.summary.aggregate.nokeys.description')).toBeInTheDocument();
+    });
+});

package/components/elements/hit/actions/ButtonActions.test.d.ts

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

package/components/elements/hit/actions/ButtonActions.test.js

@@ -0,0 +1,51 @@
+import { Fragment as _Fragment, 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/material', () => ({
+    Badge: ({ children, badgeContent }) => (_jsxs("div", { children: [badgeContent, children] })),
+    Button: ({ children, onClick, disabled }) => (_jsx("button", { onClick: onClick, disabled: disabled, children: children })),
+    FormControl: ({ children }) => _jsx("div", { children: children }),
+    FormControlLabel: ({ label, onClick }) => _jsx("button", { onClick: onClick, children: label }),
+    FormLabel: ({ children }) => _jsx("div", { children: children }),
+    Radio: () => _jsx("div", { children: "radio" }),
+    RadioGroup: ({ children }) => _jsx("div", { children: children }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    Tooltip: ({ children }) => _jsx(_Fragment, { children: children }),
+    styled: (_component) => (styles) => {
+        void styles;
+        return ({ children, badgeContent }) => (_jsxs("div", { children: [badgeContent, children] }));
+    }
+}));
+vi.mock('@mui/material/colors', () => ({
+    blueGrey: { 400: '#789' }
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+import { HitShortcuts } from '../HitShortcuts';
+import ButtonActions from './ButtonActions';
+describe('ButtonActions', () => {
+    it('renders actions, assessments, and votes with shortcut badges and handles clicks', () => {
+        const actionFn = vi.fn();
+        const assessFn = vi.fn();
+        const voteFn = vi.fn();
+        render(_jsx(ButtonActions, { actions: [
+                { type: 'action', name: 'Transition', actionFunction: actionFn, key: 'T' },
+                { type: 'assessment', name: 'legitimate', actionFunction: assessFn, key: 'A' },
+                { type: 'vote', name: 'Benign', actionFunction: voteFn, key: 'Q' }
+            ], loading: false, orientation: "horizontal", shortcuts: HitShortcuts.SHORTCUTS_HINT, currentVote: "benign" }));
+        expect(screen.getByText('hit.details.actions.action')).toBeInTheDocument();
+        expect(screen.getByText('hit.details.actions.assessment')).toBeInTheDocument();
+        expect(screen.getByText('hit.details.actions.vote')).toBeInTheDocument();
+        expect(screen.getByText('T')).toBeInTheDocument();
+        expect(screen.getByText('A')).toBeInTheDocument();
+        expect(screen.getByText('Q')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('Transition'));
+        fireEvent.click(screen.getByText('legitimate'));
+        fireEvent.click(screen.getByText('Benign'));
+        expect(actionFn).toHaveBeenCalled();
+        expect(assessFn).toHaveBeenCalled();
+        expect(voteFn).toHaveBeenCalled();
+    });
+});

package/components/elements/hit/actions/DropdownActions.test.d.ts

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

package/components/elements/hit/actions/DropdownActions.test.js

@@ -0,0 +1,60 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+const apiConfigContextToken = vi.hoisted(() => ({ name: 'api-config-context' }));
+let configValue = {};
+vi.mock('@mui/material', () => ({
+    FormControl: ({ children, disabled }) => _jsx("fieldset", { disabled: disabled, children: children }),
+    formControlClasses: { root: 'MuiFormControl-root' },
+    Grid: ({ children }) => _jsx("div", { children: children }),
+    InputLabel: ({ children }) => _jsx("label", { children: children }),
+    MenuItem: ({ children, onClick }) => _jsx("button", { onClick: onClick, children: children }),
+    Select: ({ children }) => _jsx("div", { children: children }),
+    Skeleton: () => _jsx("div", { children: "loading" }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('components/app/providers/ApiConfigProvider', () => ({
+    ApiConfigContext: apiConfigContextToken
+}));
+vi.mock('lodash-es', () => ({
+    capitalize: (value) => value.charAt(0).toUpperCase() + value.slice(1)
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === apiConfigContextToken)
+                return { config: configValue };
+            return actual.useContext(context);
+        }
+    };
+});
+import DropdownActions from './DropdownActions';
+describe('DropdownActions', () => {
+    it('renders skeletons without lookups and action menus with lookups', () => {
+        const actionFn = vi.fn();
+        const assessFn = vi.fn();
+        const voteFn = vi.fn();
+        configValue = {};
+        const { rerender } = render(_jsx(DropdownActions, { actions: [], currentAssessment: "", currentStatus: "open", currentVote: "", loading: false, orientation: "horizontal" }));
+        expect(screen.getAllByText('loading')).toHaveLength(3);
+        configValue = { lookups: { any: true } };
+        rerender(_jsx(DropdownActions, { actions: [
+                { type: 'action', name: 'Transition', actionFunction: actionFn },
+                { type: 'assessment', name: 'false-positive', actionFunction: assessFn },
+                { type: 'vote', name: 'Benign', actionFunction: voteFn }
+            ], currentAssessment: "", currentStatus: "open", currentVote: "", loading: false, orientation: "vertical" }));
+        fireEvent.click(screen.getByText('Transition'));
+        fireEvent.click(screen.getByText('False Positive'));
+        fireEvent.click(screen.getByText('Benign'));
+        expect(actionFn).toHaveBeenCalled();
+        expect(assessFn).toHaveBeenCalled();
+        expect(voteFn).toHaveBeenCalled();
+    });
+});

package/components/elements/hit/grid/AddColumnModal.test.d.ts

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

package/components/elements/hit/grid/AddColumnModal.test.js

@@ -0,0 +1,88 @@
+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 mockGetMatchingTemplate = vi.hoisted(() => vi.fn());
+const fieldContextToken = vi.hoisted(() => ({ name: 'field-context' }));
+const recordSearchContextToken = vi.hoisted(() => ({ name: 'record-search-context' }));
+let fieldContextValue;
+let responseValue;
+vi.mock('@mui/icons-material', () => ({
+    Add: () => _jsx("div", { children: "add-icon" }),
+    Check: () => _jsx("div", { children: "check-icon" }),
+    Settings: () => _jsx("div", { children: "settings-icon" }),
+    TableChart: () => _jsx("div", { children: "table-icon" })
+}));
+vi.mock('@mui/material', () => ({
+    Autocomplete: ({ options, value, onChange, renderInput }) => (_jsxs("div", { children: [renderInput({}), _jsx("button", { onClick: () => onChange?.(null, options[0] ?? null), children: value ?? 'pick-field' })] })),
+    Chip: ({ label, onClick, disabled }) => (_jsx("button", { onClick: onClick, disabled: disabled, children: label })),
+    Divider: () => _jsx("div", { children: "divider" }),
+    Grid: ({ children }) => _jsx("div", { children: children }),
+    IconButton: ({ children, onClick, disabled }) => (_jsx("button", { onClick: onClick, disabled: disabled, children: children })),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ placeholder }) => _jsx("div", { children: placeholder })
+}));
+vi.mock('components/app/hooks/useMatchers', () => ({
+    default: () => ({ getMatchingTemplate: mockGetMatchingTemplate })
+}));
+vi.mock('components/app/providers/FieldProvider', () => ({
+    FieldContext: fieldContextToken
+}));
+vi.mock('components/app/providers/RecordSearchProvider', () => ({
+    RecordSearchContext: recordSearchContextToken
+}));
+vi.mock('components/elements/display/ChipPopper', () => ({
+    default: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('lodash-es', () => ({
+    sortBy: (values, key) => [...values].sort((a, b) => Number(a[key]) - Number(b[key])),
+    uniq: (values) => [...new Set(values)]
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (context, selector) => {
+        if (context === recordSearchContextToken)
+            return selector({ response: responseValue });
+        return undefined;
+    }
+}));
+vi.mock('utils/typeUtils', () => ({
+    isHit: (record) => record?.__index === 'hit'
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === fieldContextToken)
+                return fieldContextValue;
+            return actual.useContext(context);
+        }
+    };
+});
+import AddColumnModal from './AddColumnModal';
+describe('AddColumnModal', () => {
+    beforeEach(() => {
+        fieldContextValue = { hitFields: [{ key: 'severity' }, { key: 'event.created' }] };
+        responseValue = {
+            items: [
+                { __index: 'hit', howler: { id: 'hit-1' } },
+                { __index: 'event', howler: { id: 'event-1' } }
+            ]
+        };
+        mockGetMatchingTemplate.mockReset().mockResolvedValue({ keys: ['severity', 'custom.field', 'custom.field'] });
+    });
+    it('adds explicit columns and suggested columns while disabling used suggestions', async () => {
+        const addColumn = vi.fn();
+        render(_jsx(AddColumnModal, { addColumn: addColumn, columns: ['severity'] }));
+        await waitFor(() => expect(mockGetMatchingTemplate).toHaveBeenCalledTimes(1));
+        fireEvent.click(screen.getByText('pick-field'));
+        fireEvent.click(screen.getAllByText('add-icon')[0].parentElement);
+        expect(addColumn).toHaveBeenCalledWith('severity');
+        expect(screen.getByText('severity')).toBeDisabled();
+        fireEvent.click(screen.getByText('custom.field'));
+        expect(addColumn).toHaveBeenCalledWith('custom.field');
+    });
+});

package/components/elements/hit/grid/RecordTable.test.d.ts

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