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

package/components/routes/hits/search/grid/RecordGrid.test.js

@@ -0,0 +1,107 @@
+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';
+const parameterContextToken = vi.hoisted(() => ({ name: 'parameter-context' }));
+const recordContextToken = vi.hoisted(() => ({ name: 'record-context' }));
+const recordSearchContextToken = vi.hoisted(() => ({ name: 'record-search-context' }));
+const gridColumnsContextToken = vi.hoisted(() => ({ name: 'grid-columns-context' }));
+vi.mock('@mui/icons-material', () => ({
+    Info: () => _jsx("div", { children: "info-icon" })
+}));
+vi.mock('@mui/material', () => ({
+    LinearProgress: () => _jsx("div", { children: "progress" }),
+    Paper: ({ children, onScroll }) => _jsx("div", { onScroll: onScroll, children: children }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TableBody: ({ children }) => _jsx("div", { children: children }),
+    Typography: ({ children }) => _jsx("div", { children: children }),
+    useTheme: () => ({ spacing: (n) => `${n}px`, shape: { borderRadius: 4 } })
+}));
+vi.mock('components/app/providers/GridColumnsProvider', () => ({
+    GridColumnsContext: gridColumnsContextToken
+}));
+vi.mock('components/app/providers/ParameterProvider', () => ({
+    ParameterContext: parameterContextToken
+}));
+vi.mock('components/app/providers/RecordProvider', () => ({
+    RecordContext: recordContextToken
+}));
+vi.mock('components/app/providers/RecordSearchProvider', () => ({
+    RecordSearchContext: recordSearchContextToken
+}));
+vi.mock('components/elements/addons/search/SearchTotal', () => ({
+    default: ({ total }) => _jsx("div", { children: `total:${total}` })
+}));
+vi.mock('components/elements/display/features/DevelopmentBanner', () => ({
+    default: () => _jsx("div", { children: "banner" })
+}));
+vi.mock('components/elements/hit/grid/AddColumnModal', () => ({
+    default: ({ addColumn }) => _jsx("button", { onClick: () => addColumn('field.two'), children: "add-column" })
+}));
+vi.mock('components/elements/hit/grid/RecordTable', () => ({
+    default: ({ refreshItems, query, items }) => (_jsxs("div", { children: [_jsx("button", { onClick: () => refreshItems?.(query, true), children: "refresh" }), _jsx("div", { children: `table:${items?.length ?? 0}` })] }))
+}));
+vi.mock('components/elements/record/RecordContextMenu', () => ({
+    default: () => _jsx("div", { children: "context-menu" })
+}));
+vi.mock('components/hooks/useRecordSelection', () => ({
+    default: () => ({ onClick: vi.fn() })
+}));
+vi.mock('lodash-es', () => ({
+    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({
+                search: vi.fn(),
+                response: { items: [{ howler: { id: 'hit-1' } }], offset: 0, rows: 25, total: 1 },
+                searching: true
+            });
+        }
+        if (context === recordContextToken)
+            return selector({ selectedRecords: [{ howler: { id: 'hit-2' } }] });
+        if (context === parameterContextToken)
+            return selector({ query: 'status:open', selected: 'hit-1' });
+        if (context === gridColumnsContextToken)
+            return selector({ columns: ['field.one'], setColumns: vi.fn(), isReady: true });
+        return undefined;
+    }
+}));
+vi.mock('../QuerySettings', () => ({
+    default: () => _jsx("div", { children: "query-settings" })
+}));
+vi.mock('../RecordQuery', () => ({
+    default: () => _jsx("div", { children: "record-query" })
+}));
+vi.mock('../shared/SearchActionMenu', () => ({
+    default: () => _jsx("div", { children: "search-actions" })
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === gridColumnsContextToken)
+                return { columns: ['field.one'], setColumns: vi.fn(), isReady: true };
+            return actual.useContext(context);
+        }
+    };
+});
+import RecordGrid from './RecordGrid';
+describe('RecordGrid', () => {
+    it('renders the search grid controls and empty message paths', () => {
+        render(_jsx(RecordGrid, {}));
+        expect(screen.getByText('banner')).toBeInTheDocument();
+        expect(screen.getByText('record-query')).toBeInTheDocument();
+        expect(screen.getByText('progress')).toBeInTheDocument();
+        expect(screen.getByText('query-settings')).toBeInTheDocument();
+        expect(screen.getByText('total:1')).toBeInTheDocument();
+        expect(screen.getByText('table:1')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('add-column'));
+        fireEvent.click(screen.getByText('refresh'));
+    });
+});

package/components/routes/hits/search/shared/CustomSort.test.d.ts

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

package/components/routes/hits/search/shared/CustomSort.test.js

@@ -0,0 +1,77 @@
+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 fieldContextToken = vi.hoisted(() => ({ name: 'field-context' }));
+const parameterContextToken = vi.hoisted(() => ({ name: 'parameter-context' }));
+const mockGetHitFields = vi.hoisted(() => vi.fn());
+const mockSetSavedSort = vi.hoisted(() => vi.fn());
+let fieldContextValue = {
+    hitFields: [{ key: 'event.created' }, { key: 'howler.score' }],
+    getHitFields: mockGetHitFields
+};
+let parameterValue = { sort: 'event.created desc', setSort: mockSetSavedSort };
+vi.mock('@mui/icons-material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        ArrowDownward: () => _jsx("div", { children: "down-icon" }),
+        ArrowUpward: () => _jsx("div", { children: "up-icon" }),
+        Cancel: () => _jsx("div", { children: "cancel-icon" })
+    };
+});
+vi.mock('@mui/material', () => ({
+    Autocomplete: ({ onChange, options }) => _jsx("button", { onClick: () => onChange(null, options[1]), children: "pick-field" }),
+    Chip: ({ label, onClick, onDelete }) => (_jsxs("div", { children: [_jsx("button", { onClick: onClick, children: label }), _jsxs("button", { onClick: onDelete, children: ["delete-", label] })] })),
+    Grid: ({ children }) => _jsx("div", { children: children }),
+    MenuItem: ({ children }) => _jsx("div", { children: children }),
+    Select: ({ value, onChange }) => (_jsx("button", { onClick: () => onChange({ target: { value: value === 'desc' ? 'asc' : 'desc' } }), children: "toggle-direction" })),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ label }) => _jsx("div", { children: label })
+}));
+vi.mock('components/app/providers/FieldProvider', () => ({
+    FieldContext: fieldContextToken
+}));
+vi.mock('components/app/providers/ParameterProvider', () => ({
+    ParameterContext: parameterContextToken
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (_context, selector) => selector({ sort: parameterValue.sort, setSort: mockSetSavedSort })
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === fieldContextToken)
+                return fieldContextValue;
+            return actual.useContext(context);
+        }
+    };
+});
+import CustomSort from './CustomSort';
+describe('CustomSort', () => {
+    beforeEach(() => {
+        fieldContextValue = {
+            hitFields: [{ key: 'event.created' }, { key: 'howler.score' }],
+            getHitFields: mockGetHitFields
+        };
+        parameterValue = { sort: 'event.created desc', setSort: mockSetSavedSort };
+        mockGetHitFields.mockReset();
+        mockSetSavedSort.mockReset();
+    });
+    it('loads hit fields, adds sort entries, toggles direction, and deletes entries', async () => {
+        render(_jsx(CustomSort, {}));
+        await waitFor(() => expect(mockGetHitFields).toHaveBeenCalled());
+        fireEvent.click(screen.getByText('toggle-direction'));
+        fireEvent.click(screen.getByText('pick-field'));
+        await waitFor(() => expect(mockSetSavedSort).toHaveBeenCalledWith('event.created desc,howler.score asc'));
+        fireEvent.click(screen.getByText('event.created'));
+        expect(mockSetSavedSort).toHaveBeenCalledWith('event.created asc');
+        fireEvent.click(screen.getByText('delete-event.created'));
+        expect(mockSetSavedSort).toHaveBeenCalledWith('');
+    });
+});

package/components/routes/hits/search/shared/HitFilter.test.d.ts

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

package/components/routes/hits/search/shared/HitFilter.test.js

@@ -0,0 +1,83 @@
+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 apiConfigContextToken = vi.hoisted(() => ({ name: 'api-config-context' }));
+const parameterContextToken = vi.hoisted(() => ({ name: 'parameter-context' }));
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockSetSavedFilter = vi.hoisted(() => vi.fn());
+const mockRemoveSavedFilter = vi.hoisted(() => vi.fn());
+let configValue = { lookups: { 'howler.assessment': ['malicious'] } };
+vi.mock('@mui/icons-material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, FilterList: () => _jsx("div", { children: "filter-icon" }) };
+});
+vi.mock('@mui/material', () => ({
+    Autocomplete: ({ onChange, options, disabled }) => (_jsx("button", { disabled: disabled, onClick: () => onChange(null, options.includes('event.provider') ? 'event.provider' : options[0]), children: "change-filter" })),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ label }) => _jsx("div", { children: label }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('api', () => ({
+    default: {
+        search: {
+            facet: {
+                hit: {
+                    post: (body) => body
+                }
+            }
+        }
+    }
+}));
+vi.mock('components/app/providers/ApiConfigProvider', () => ({
+    ApiConfigContext: apiConfigContextToken
+}));
+vi.mock('components/app/providers/ParameterProvider', () => ({
+    ParameterContext: parameterContextToken
+}));
+vi.mock('components/elements/display/ChipPopper', () => ({
+    default: ({ children, label, onDelete }) => (_jsxs("div", { children: [_jsx("div", { children: label }), _jsx("button", { onClick: onDelete, children: "delete-filter" }), children] }))
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (_context, selector) => selector({ setFilter: mockSetSavedFilter, removeFilter: mockRemoveSavedFilter })
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === apiConfigContextToken)
+                return { config: configValue };
+            return actual.useContext(context);
+        }
+    };
+});
+import HitFilter from './HitFilter';
+describe('HitFilter', () => {
+    beforeEach(() => {
+        configValue = { lookups: { 'howler.assessment': ['malicious'] } };
+        mockDispatchApi.mockReset().mockImplementation(async (_value) => ({ 'event.provider': { azure: 2 } }));
+        mockSetSavedFilter.mockReset();
+        mockRemoveSavedFilter.mockReset();
+    });
+    it('initializes from value, fetches custom lookups, updates values, and removes filters', async () => {
+        render(_jsx(HitFilter, { id: 1, value: 'howler.assessment:*' }));
+        await waitFor(() => expect(mockSetSavedFilter).toHaveBeenCalledWith(1, 'howler.assessment:*'));
+        fireEvent.click(screen.getAllByText('change-filter')[0]);
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({ query: 'howler.id:*', fields: ['event.provider'], rows: 100 }, { throwError: false }));
+        fireEvent.click(screen.getAllByText('change-filter')[1]);
+        expect(mockSetSavedFilter).toHaveBeenCalledWith(1, 'event.provider:"azure"');
+        fireEvent.click(screen.getByText('delete-filter'));
+        expect(mockRemoveSavedFilter).toHaveBeenCalledWith('howler.assessment:*');
+    });
+    it('uses configured lookups and wildcard values', async () => {
+        render(_jsx(HitFilter, { id: 2, value: 'howler.assessment:*' }));
+        await waitFor(() => expect(mockSetSavedFilter).toHaveBeenCalledWith(2, 'howler.assessment:*'));
+    });
+});

package/components/routes/hits/search/shared/HitSort.test.d.ts

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

package/components/routes/hits/search/shared/HitSort.test.js

@@ -0,0 +1,61 @@
+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 parameterContextToken = vi.hoisted(() => ({ name: 'parameter-context' }));
+const viewContextToken = vi.hoisted(() => ({ name: 'view-context' }));
+const mockSetSavedSort = vi.hoisted(() => vi.fn());
+const mockGetCurrentViews = vi.hoisted(() => vi.fn());
+let locationValue = { search: '' };
+let parameterValue = { views: [], sort: 'event.created desc', setSort: mockSetSavedSort };
+vi.mock('@mui/icons-material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, Sort: () => _jsx("div", { children: "sort-icon" }) };
+});
+vi.mock('@mui/material', () => ({
+    Autocomplete: ({ onChange, options }) => (_jsx("button", { onClick: () => onChange(null, options.at(-1)), children: "change-sort" })),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: () => _jsx("div", { children: "text-field" })
+}));
+vi.mock('components/app/providers/ParameterProvider', () => ({
+    ParameterContext: parameterContextToken
+}));
+vi.mock('components/app/providers/ViewProvider', () => ({
+    ViewContext: viewContextToken
+}));
+vi.mock('components/elements/display/ChipPopper', () => ({
+    default: ({ children, label }) => (_jsxs("div", { children: [_jsx("div", { children: label }), children] }))
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react-router', () => ({
+    useLocation: () => locationValue
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (context, selector) => selector(context === parameterContextToken ? parameterValue : { getCurrentViews: mockGetCurrentViews })
+}));
+vi.mock('./CustomSort', () => ({
+    default: () => _jsx("div", { children: "custom-sort" })
+}));
+import HitSort from './HitSort';
+describe('HitSort', () => {
+    beforeEach(() => {
+        locationValue = { search: '' };
+        parameterValue = { views: [], sort: 'event.created desc', setSort: mockSetSavedSort };
+        mockSetSavedSort.mockReset();
+        mockGetCurrentViews.mockReset();
+    });
+    it('loads the current view sort and switches to custom sorting when requested', async () => {
+        mockGetCurrentViews.mockResolvedValueOnce([{ sort: 'howler.score asc' }]);
+        render(_jsx(HitSort, {}));
+        await waitFor(() => expect(mockSetSavedSort).toHaveBeenCalledWith('howler.score asc'));
+        fireEvent.click(screen.getAllByText('change-sort')[0]);
+        expect(screen.getByText('custom-sort')).toBeInTheDocument();
+    });
+    it('skips view lookup when sort is in the URL', () => {
+        locationValue = { search: '?sort=event.created%20asc' };
+        render(_jsx(HitSort, {}));
+        expect(mockGetCurrentViews).not.toHaveBeenCalled();
+    });
+});

package/components/routes/hits/search/shared/LayoutSettings.test.d.ts

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

package/components/routes/hits/search/shared/LayoutSettings.test.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const recordSearchContextToken = vi.hoisted(() => ({ name: 'record-search' }));
+const mockSetDisplayType = vi.hoisted(() => vi.fn());
+const mockSetHitLayout = vi.hoisted(() => vi.fn());
+const mockSetTemplateFieldCount = vi.hoisted(() => vi.fn());
+let localStorageValues = {};
+let storageCall = 0;
+vi.mock('@mui/icons-material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        ArrowDropDown: () => _jsx("div", { children: "arrow-icon" }),
+        InfoOutlined: () => _jsx("div", { children: "info-icon" }),
+        Settings: () => _jsx("div", { children: "settings-icon" }),
+        ViewComfy: () => _jsx("div", { children: "comfy-icon" }),
+        ViewCompact: () => _jsx("div", { children: "compact-icon" }),
+        ViewModule: () => _jsx("div", { children: "normal-icon" })
+    };
+});
+vi.mock('@mui/material', () => ({
+    Checkbox: ({ checked, onChange }) => (_jsx("input", { "aria-label": "field-toggle", type: "checkbox", checked: checked, onChange: e => onChange(null, e.target.checked) })),
+    Divider: () => _jsx("div", { children: "divider" }),
+    FormLabel: ({ children }) => _jsx("div", { children: children }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ value, onChange, disabled }) => (_jsx("input", { "aria-label": "field-count", disabled: disabled, value: value, onChange: onChange })),
+    ToggleButton: ({ children, value }) => _jsx("button", { "data-value": value, children: children }),
+    ToggleButtonGroup: ({ onChange, children }) => (_jsxs("div", { children: [_jsx("button", { onClick: () => onChange(null, 'dense'), children: "set-layout" }), children] })),
+    Tooltip: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('components/app/providers/RecordSearchProvider', () => ({
+    RecordSearchContext: recordSearchContextToken
+}));
+vi.mock('components/elements/display/ChipPopper', () => ({
+    default: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('components/elements/hit/HitLayout', () => ({
+    HitLayout: { DENSE: 'dense', NORMAL: 'normal', COMFY: 'comfy' }
+}));
+vi.mock('components/elements/view/LayoutToggle', () => ({
+    __esModule: true,
+    default: ({ setDisplayType }) => _jsx("button", { onClick: () => setDisplayType('grid'), children: "layout-toggle" })
+}));
+vi.mock('components/hooks/useMyLocalStorage', () => ({
+    useMyLocalStorageItem: (_key) => {
+        storageCall += 1;
+        if (storageCall % 2 === 1)
+            return [localStorageValues.hitLayout, mockSetHitLayout];
+        return [localStorageValues.templateFieldCount, mockSetTemplateFieldCount];
+    }
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (_context, selector) => selector({ displayType: 'list', setDisplayType: mockSetDisplayType })
+}));
+import LayoutSettings from './LayoutSettings';
+describe('LayoutSettings', () => {
+    beforeEach(() => {
+        localStorageValues = { hitLayout: 'normal', templateFieldCount: null };
+        storageCall = 0;
+        mockSetDisplayType.mockReset();
+        mockSetHitLayout.mockReset();
+        mockSetTemplateFieldCount.mockReset();
+    });
+    it('updates display type, layout, and template field count settings', () => {
+        const { unmount } = render(_jsx(LayoutSettings, {}));
+        fireEvent.click(screen.getByText('layout-toggle'));
+        expect(mockSetDisplayType).toHaveBeenCalledWith('grid');
+        fireEvent.click(screen.getByText('set-layout'));
+        expect(mockSetHitLayout).toHaveBeenCalledWith('dense');
+        fireEvent.click(screen.getByLabelText('field-toggle'));
+        expect(mockSetTemplateFieldCount).toHaveBeenCalledWith(3);
+        localStorageValues.templateFieldCount = 3;
+        storageCall = 0;
+        unmount();
+        render(_jsx(LayoutSettings, {}));
+        fireEvent.change(screen.getByLabelText('field-count'), { target: { value: '20' } });
+        expect(mockSetTemplateFieldCount).toHaveBeenCalledWith(15);
+    });
+});

package/components/routes/hits/search/shared/SearchSpan.test.d.ts

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

package/components/routes/hits/search/shared/SearchSpan.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 parameterContextToken = vi.hoisted(() => ({ name: 'parameter-context' }));
+const viewContextToken = vi.hoisted(() => ({ name: 'view-context' }));
+const mockSetSpan = vi.hoisted(() => vi.fn());
+const mockGetCurrentViews = vi.hoisted(() => vi.fn());
+let locationValue = { search: '' };
+let parameterValue = {
+    views: [],
+    span: 'date.range.1.day',
+    setSpan: mockSetSpan,
+    startDate: undefined,
+    endDate: undefined
+};
+vi.mock('@mui/icons-material', async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, AvTimer: () => _jsx("div", { children: "timer-icon" }) };
+});
+vi.mock('@mui/material', () => ({
+    Autocomplete: ({ onChange, options }) => (_jsx("button", { onClick: () => onChange(null, options.at(-1)), children: "change-span" })),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ label }) => _jsx("div", { children: label }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('components/app/providers/ParameterProvider', () => ({
+    ParameterContext: parameterContextToken
+}));
+vi.mock('components/app/providers/ViewProvider', () => ({
+    ViewContext: viewContextToken
+}));
+vi.mock('components/elements/display/ChipPopper', () => ({
+    default: ({ children, label }) => (_jsxs("div", { children: [_jsx("div", { children: label }), children] }))
+}));
+vi.mock('dayjs', () => ({
+    default: () => ({ subtract: () => ({ format: () => '2024-01-01 00:00' }) })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react-router', () => ({
+    useLocation: () => locationValue
+}));
+vi.mock('use-context-selector', () => ({
+    useContextSelector: (context, selector) => selector(context === parameterContextToken ? parameterValue : { getCurrentViews: mockGetCurrentViews })
+}));
+vi.mock('utils/utils', () => ({
+    convertLuceneToDate: (value) => `converted:${value}`
+}));
+vi.mock('./CustomSpan', () => ({
+    default: () => _jsx("div", { children: "custom-span" })
+}));
+import SearchSpan from './SearchSpan';
+describe('SearchSpan', () => {
+    beforeEach(() => {
+        locationValue = { search: '' };
+        parameterValue = {
+            views: [],
+            span: 'date.range.1.day',
+            setSpan: mockSetSpan,
+            startDate: undefined,
+            endDate: undefined
+        };
+        mockSetSpan.mockReset();
+        mockGetCurrentViews.mockReset();
+    });
+    it('loads the span from the current view and handles custom selection', async () => {
+        mockGetCurrentViews.mockResolvedValueOnce([{ span: 'date.range.1.week' }]);
+        render(_jsx(SearchSpan, {}));
+        await waitFor(() => expect(mockSetSpan).toHaveBeenCalledWith('date.range.1.week'));
+        fireEvent.click(screen.getByText('change-span'));
+        expect(mockSetSpan).toHaveBeenCalledWith('date.range.custom');
+        expect(screen.getByText('custom-span')).toBeInTheDocument();
+    });
+    it('converts lucene date spans and skips view lookup when span is already in the URL', async () => {
+        mockGetCurrentViews.mockResolvedValueOnce([{ span: '2024-01-01T00:00:00Z:2024-01-02T00:00:00Z' }]);
+        render(_jsx(SearchSpan, {}));
+        await waitFor(() => expect(mockSetSpan).toHaveBeenCalledWith('converted:2024-01-01T00:00:00Z:2024-01-02T00:00:00Z'));
+        locationValue = { search: '?span=date.range.1.month' };
+        render(_jsx(SearchSpan, { omitCustom: true }));
+        expect(mockGetCurrentViews).toHaveBeenCalledTimes(1);
+    });
+});

package/components/routes/home/AnalyticCard.test.d.ts

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

package/components/routes/home/AnalyticCard.test.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockGetAnalyticFromId = vi.hoisted(() => vi.fn());
+const resetZoom = vi.fn();
+const analyticContextToken = vi.hoisted(() => ({ name: 'analytic-context' }));
+vi.mock('@mui/icons-material', () => ({
+    CenterFocusWeak: () => _jsx("div", { children: "reset-icon" }),
+    OpenInNew: () => _jsx("div", { children: "open-icon" })
+}));
+vi.mock('@mui/material', () => ({
+    Box: ({ children }) => _jsx("div", { children: children }),
+    Card: ({ children }) => _jsx("div", { children: children }),
+    CardContent: ({ children }) => _jsx("div", { children: children }),
+    IconButton: ({ children, onClick }) => _jsx("button", { onClick: onClick, children: children }),
+    Skeleton: () => _jsx("div", { children: "loading" }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    Tooltip: ({ children }) => _jsx("div", { children: children }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('components/app/providers/AnalyticProvider', () => ({
+    AnalyticContext: analyticContextToken
+}));
+vi.mock('components/elements/addons/layout/FlexOne', () => ({
+    default: () => _jsx("div", { children: "flex" })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === analyticContextToken)
+                return { getAnalyticFromId: mockGetAnalyticFromId };
+            return actual.useContext(context);
+        }
+    };
+});
+vi.mock('react-router', () => ({
+    Link: ({ children, to }) => _jsx("a", { href: to, children: children })
+}));
+vi.mock('../analytics/widgets/Assessment', () => ({
+    default: () => _jsx("div", { children: "assessment-widget" })
+}));
+vi.mock('../analytics/widgets/Created', () => ({
+    default: (_props) => {
+        if (_props.ref)
+            _props.ref.current = { resetZoom };
+        return _jsx("div", { children: "created-widget" });
+    }
+}));
+vi.mock('../analytics/widgets/Detection', () => ({
+    default: () => _jsx("div", { children: "detection-widget" })
+}));
+vi.mock('../analytics/widgets/Escalation', () => ({
+    default: () => _jsx("div", { children: "escalation-widget" })
+}));
+vi.mock('../analytics/widgets/Status', () => ({
+    default: () => _jsx("div", { children: "status-widget" })
+}));
+import AnalyticCard from './AnalyticCard';
+describe('AnalyticCard', () => {
+    beforeEach(() => {
+        mockGetAnalyticFromId.mockReset();
+        resetZoom.mockReset();
+    });
+    it('loads analytic details and renders created charts with reset control', async () => {
+        mockGetAnalyticFromId.mockResolvedValue({ analytic_id: 'a1', name: 'Analytic One' });
+        render(_jsx(AnalyticCard, { analyticId: "a1", type: "created" }));
+        expect(screen.getByText('loading')).toBeInTheDocument();
+        await waitFor(() => expect(screen.getByText('Analytic One')).toBeInTheDocument());
+        expect(screen.getByText('created-widget')).toBeInTheDocument();
+        fireEvent.click(screen.getAllByRole('button')[1]);
+        expect(resetZoom).toHaveBeenCalled();
+    });
+    it('renders the assessment and escalation widget variants', async () => {
+        mockGetAnalyticFromId.mockResolvedValue({ analytic_id: 'a2', name: 'Analytic Two' });
+        const { rerender } = render(_jsx(AnalyticCard, { analyticId: "a2", type: "assessment" }));
+        await waitFor(() => expect(screen.getByText('assessment-widget')).toBeInTheDocument());
+        rerender(_jsx(AnalyticCard, { analyticId: "a2", type: "escalation" }));
+        await act(async () => { });
+        expect(screen.getByText('escalation-widget')).toBeInTheDocument();
+    });
+});

package/components/routes/home/index.test.d.ts

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