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

package/components/app/drawers/ApiKeyDrawer.test.js

@@ -0,0 +1,119 @@
+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 mockShowInfoMessage = vi.hoisted(() => vi.fn());
+const mockApiKeyPost = vi.hoisted(() => vi.fn((name, privs, expiry) => ({ name, privs, expiry })));
+const apiConfigContextToken = vi.hoisted(() => ({ name: 'api-config-context' }));
+let configValue = {
+    configuration: {
+        auth: {
+            max_apikey_duration_amount: 1,
+            max_apikey_duration_unit: 'days',
+            allow_extended_apikeys: true
+        }
+    }
+};
+vi.mock('@mui/material', () => ({
+    Alert: ({ children }) => _jsx("div", { children: children }),
+    AlertTitle: ({ children }) => _jsx("div", { children: children }),
+    Button: ({ children, onClick, disabled }) => (_jsx("button", { disabled: disabled, onClick: onClick, children: children })),
+    Checkbox: ({ onChange }) => _jsx("input", { "aria-label": "checkbox", type: "checkbox", onChange: onChange }),
+    Divider: () => _jsx("div", { children: "divider" }),
+    FormControl: ({ children }) => _jsx("div", { children: children }),
+    FormControlLabel: ({ control, label }) => (_jsxs("label", { children: [control, label] })),
+    FormGroup: ({ children }) => _jsx("div", { children: children }),
+    FormLabel: ({ children }) => _jsx("div", { children: children }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ label, value, onChange, inputProps, size }) => (_jsxs("label", { children: [label ?? size ?? 'text', _jsx("input", { "aria-label": label ?? size ?? 'text', value: value, onChange: onChange, readOnly: inputProps?.readOnly })] })),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('@mui/x-date-pickers', () => ({
+    LocalizationProvider: ({ children }) => _jsx(_Fragment, { children: children }),
+    StaticDateTimePicker: ({ value, onChange }) => (_jsx("button", { onClick: () => onChange({ toISOString: () => '2027-01-01T00:00:00.000Z' }), children: value ? 'change-date' : 'set-date' }))
+}));
+vi.mock('@mui/x-date-pickers/AdapterDayjs', () => ({
+    AdapterDayjs: class {
+    }
+}));
+vi.mock('api', () => ({
+    default: {
+        auth: {
+            apikey: {
+                post: mockApiKeyPost
+            }
+        }
+    }
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({ showInfoMessage: mockShowInfoMessage })
+}));
+vi.mock('dayjs', () => {
+    const factory = () => ({
+        add: () => ({ toISOString: () => '2026-09-19T00:00:00.000Z', format: () => 'Sep 19 00:00:00' })
+    });
+    factory.duration = (amount, unit) => ({
+        asSeconds: () => (unit === 'days' ? amount * 86400 : amount)
+    });
+    return { default: factory };
+});
+vi.mock('react-i18next', () => ({
+    Trans: ({ i18nKey }) => _jsx(_Fragment, { children: i18nKey }),
+    useTranslation: () => ({ t: (key) => key })
+}));
+vi.mock('../providers/ApiConfigProvider', () => ({
+    ApiConfigContext: apiConfigContextToken
+}));
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === apiConfigContextToken)
+                return { config: configValue };
+            return actual.useContext(context);
+        }
+    };
+});
+import ApiKeyDrawer from './ApiKeyDrawer';
+describe('ApiKeyDrawer', () => {
+    beforeEach(() => {
+        configValue = {
+            configuration: {
+                auth: {
+                    max_apikey_duration_amount: 1,
+                    max_apikey_duration_unit: 'days',
+                    allow_extended_apikeys: true
+                }
+            }
+        };
+        mockDispatchApi.mockReset();
+        mockShowInfoMessage.mockReset();
+        mockApiKeyPost.mockClear();
+        Object.assign(navigator, {
+            clipboard: { writeText: vi.fn().mockResolvedValue(undefined) }
+        });
+    });
+    it('validates input, creates a key, and copies the generated value', async () => {
+        const onCreated = vi.fn();
+        mockDispatchApi.mockResolvedValueOnce({ apikey: 'demo-key:secret' });
+        render(_jsx(ApiKeyDrawer, { onCreated: onCreated }));
+        expect(screen.getByText('app.drawer.user.apikey.limit.title')).toBeInTheDocument();
+        fireEvent.change(screen.getByLabelText('app.drawer.user.apikey.field.name'), { target: { value: 'bad-name!' } });
+        expect(screen.getByLabelText('app.drawer.user.apikey.field.name')).toHaveValue('');
+        fireEvent.change(screen.getByLabelText('app.drawer.user.apikey.field.name'), { target: { value: 'demo_key' } });
+        fireEvent.click(screen.getAllByLabelText('checkbox')[0]);
+        fireEvent.click(screen.getByText('change-date'));
+        fireEvent.click(screen.getByText('button.create'));
+        await waitFor(() => expect(mockDispatchApi).toHaveBeenCalledWith({ name: 'demo_key', privs: ['R'], expiry: '2027-01-01T00:00:00.000Z' }, { throwError: true, showError: true }));
+        expect(onCreated).toHaveBeenCalledWith('demo-key', ['R'], '2027-01-01T00:00:00.000Z', 'demo-key:secret');
+        expect(screen.getByDisplayValue('demo-key:secret')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('button.copy'));
+        await waitFor(() => expect(navigator.clipboard.writeText).toHaveBeenCalledWith('demo-key:secret'));
+        expect(mockShowInfoMessage).toHaveBeenCalledWith('drawer.apikey.copied');
+    });
+});

package/components/app/drawers/AssignUserDrawer.test.d.ts

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

package/components/app/drawers/AssignUserDrawer.test.js

@@ -0,0 +1,75 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockShowInfoMessage = vi.hoisted(() => vi.fn());
+const mockAssignPut = vi.hoisted(() => vi.fn((id, body) => ({ id, body })));
+vi.mock('@mui/icons-material', () => ({
+    PersonOff: () => _jsx("div", { children: "person-off" })
+}));
+vi.mock('@mui/material', () => ({
+    Autocomplete: ({ onChange, options, renderInput, disabled }) => (_jsxs("div", { children: [_jsx("div", { children: String(disabled) }), _jsx("button", { onClick: () => onChange(null, options[0]), children: "pick-first" }), _jsx("button", { onClick: () => onChange(null, options[options.length - 1]), children: "pick-unassigned" }), renderInput({})] })),
+    Avatar: ({ children }) => _jsx("div", { children: children }),
+    Box: ({ children }) => _jsx("div", { children: children }),
+    Button: ({ children, disabled, onClick }) => (_jsx("button", { disabled: disabled, onClick: onClick, children: children })),
+    CircularProgress: () => _jsx("div", { children: "loading" }),
+    Stack: ({ children }) => _jsx("div", { children: children }),
+    TextField: ({ label }) => _jsx("div", { children: label }),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('api', () => ({
+    default: {
+        hit: {
+            assign: { put: mockAssignPut }
+        }
+    }
+}));
+vi.mock('components/elements/display/HowlerAvatar', () => ({
+    default: ({ userId }) => _jsx("div", { children: userId })
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+vi.mock('components/hooks/useMySnackbar', () => ({
+    default: () => ({ showInfoMessage: mockShowInfoMessage })
+}));
+vi.mock('components/hooks/useMyUserList', () => ({
+    default: () => ({
+        alice: { username: 'alice', name: 'Alice', email: 'alice@example.com' }
+    })
+}));
+vi.mock('react-i18next', () => ({
+    Trans: ({ i18nKey }) => _jsx("span", { children: i18nKey }),
+    useTranslation: () => ({ t: (key) => key })
+}));
+import AssignUserDrawer from './AssignUserDrawer';
+describe('AssignUserDrawer', () => {
+    beforeEach(() => {
+        mockDispatchApi.mockReset();
+        mockShowInfoMessage.mockReset();
+        mockAssignPut.mockReset();
+    });
+    it('submits assignments through the API and reports success', async () => {
+        const onAssigned = vi.fn();
+        render(_jsx(AssignUserDrawer, { assignment: "unassigned", ids: ['h1', 'h2'], onAssigned: onAssigned }));
+        fireEvent.click(screen.getByText('pick-first'));
+        await act(async () => {
+            fireEvent.click(screen.getByText('button.save'));
+        });
+        expect(mockAssignPut).toHaveBeenCalledWith('h1', { value: 'alice' });
+        expect(mockAssignPut).toHaveBeenCalledWith('h2', { value: 'alice' });
+        expect(mockShowInfoMessage).toHaveBeenCalledWith('app.drawer.hit.assignment.success');
+        expect(onAssigned).toHaveBeenCalledWith('alice');
+    });
+    it('supports unassigned targets and skip-submit mode', async () => {
+        const onAssigned = vi.fn();
+        render(_jsx(AssignUserDrawer, { assignment: "alice", ids: ['h1'], onAssigned: onAssigned, skipSubmit: true }));
+        fireEvent.click(screen.getByText('pick-unassigned'));
+        await act(async () => {
+            fireEvent.click(screen.getByText('button.save'));
+        });
+        expect(mockDispatchApi).not.toHaveBeenCalled();
+        expect(onAssigned).toHaveBeenCalledWith('unassigned');
+    });
+});

package/components/app/hooks/useTitle.test.d.ts

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

package/components/app/hooks/useTitle.test.js

@@ -0,0 +1,103 @@
+/// <reference types="vitest" />
+import { renderHook, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const analyticContextToken = vi.hoisted(() => ({ name: 'analytic-context' }));
+const recordContextToken = vi.hoisted(() => ({ name: 'record-context' }));
+let locationValue = { pathname: '/', search: '' };
+let paramsValue = {};
+let searchParamsValue = new URLSearchParams();
+let breadcrumbsValue = [];
+let analyticContextValue = {};
+let recordValue = { records: {}, getRecord: vi.fn() };
+vi.mock('@tui/core', () => ({
+    useAppRouter: () => ({ breadcrumbs: () => breadcrumbsValue })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => `translated:${key}` })
+}));
+vi.mock('react-router', () => ({
+    useLocation: () => locationValue,
+    useParams: () => paramsValue,
+    useSearchParams: () => [searchParamsValue]
+}));
+vi.mock('../providers/AnalyticProvider', () => ({
+    AnalyticContext: analyticContextToken
+}));
+vi.mock('../providers/RecordProvider', () => ({
+    RecordContext: recordContextToken
+}));
+vi.mock('use-context-selector', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContextSelector: (_context, selector) => selector(recordValue)
+    };
+});
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === analyticContextToken) {
+                return analyticContextValue;
+            }
+            return actual.useContext(context);
+        }
+    };
+});
+import useTitle from './useTitle';
+describe('useTitle', () => {
+    beforeEach(() => {
+        document.head.innerHTML = '<title></title>';
+        locationValue = { pathname: '/', search: '' };
+        paramsValue = {};
+        searchParamsValue = new URLSearchParams();
+        breadcrumbsValue = [];
+        analyticContextValue = {};
+        recordValue = { records: {}, getRecord: vi.fn() };
+    });
+    it('sets analytic titles from ids or falls back to the section title', async () => {
+        locationValue = { pathname: '/analytics/123', search: '' };
+        paramsValue = { id: '123' };
+        analyticContextValue = { getAnalyticFromId: vi.fn().mockResolvedValue({ name: 'Suspicious Login' }) };
+        renderHook(() => useTitle());
+        await waitFor(() => expect(document.title).toBe('translated:route.analytics.view - Suspicious Login'));
+        analyticContextValue = { getAnalyticFromId: vi.fn().mockResolvedValue(undefined) };
+        renderHook(() => useTitle());
+        await waitFor(() => expect(document.title).toBe('translated:route.analytics.view'));
+        locationValue = { pathname: '/analytics', search: '' };
+        paramsValue = {};
+        renderHook(() => useTitle());
+        await waitFor(() => expect(document.title).toBe('Howler - translated:route.analytics'));
+    });
+    it('sets hit titles from cached or fetched records', async () => {
+        locationValue = { pathname: '/hits/h1', search: '' };
+        paramsValue = { id: 'h1' };
+        recordValue = {
+            records: {
+                h1: { howler: { escalation: 'alert', analytic: 'One', detection: 'Two' } }
+            },
+            getRecord: vi.fn()
+        };
+        renderHook(() => useTitle());
+        await waitFor(() => expect(document.title).toBe('Alert - One: Two'));
+        recordValue = {
+            records: {},
+            getRecord: vi.fn().mockResolvedValue({ howler: { escalation: 'hit', analytic: 'Three' } })
+        };
+        paramsValue = { id: 'h2' };
+        renderHook(() => useTitle());
+        await waitFor(() => expect(document.title).toBe('Hit - Three'));
+    });
+    it('sets template and breadcrumb titles', async () => {
+        locationValue = { pathname: '/templates/view', search: '?analytic=Demo&detection=X' };
+        searchParamsValue = new URLSearchParams('analytic=Demo&detection=X');
+        renderHook(() => useTitle());
+        await waitFor(() => expect(document.title).toBe('translated:route.templates.view - Demo: X'));
+        locationValue = { pathname: '/views', search: '' };
+        searchParamsValue = new URLSearchParams();
+        breadcrumbsValue = [{ i18nKey: 'route.views' }];
+        renderHook(() => useTitle());
+        await waitFor(() => expect(document.title).toBe('Howler - translated:route.views'));
+    });
+});

package/components/app/providers/AnalyticProvider.test.d.ts

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

package/components/app/providers/AnalyticProvider.test.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useContext } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockAnalyticGet = vi.hoisted(() => vi.fn());
+const mockAnalyticSearchPost = vi.hoisted(() => vi.fn());
+let userReady = true;
+vi.mock('@tui/core', () => ({
+    useAppUser: () => ({
+        isReady: () => userReady
+    })
+}));
+vi.mock('api', () => ({
+    default: {
+        analytic: { get: mockAnalyticGet },
+        search: { analytic: { post: mockAnalyticSearchPost } }
+    }
+}));
+import AnalyticProvider, { AnalyticContext } from './AnalyticProvider';
+describe('AnalyticProvider', () => {
+    const wrapper = ({ children }) => _jsx(AnalyticProvider, { children: children });
+    beforeEach(() => {
+        userReady = true;
+        mockAnalyticGet.mockReset();
+        mockAnalyticSearchPost.mockReset();
+    });
+    it('loads analytics once the user is ready', async () => {
+        mockAnalyticGet.mockResolvedValue([{ analytic_id: 'a1', name: 'Analytic One' }]);
+        const { result } = renderHook(() => useContext(AnalyticContext), { wrapper });
+        await waitFor(() => expect(result.current.ready).toBe(true));
+        expect(result.current.analytics).toEqual([{ analytic_id: 'a1', name: 'Analytic One' }]);
+        expect(mockAnalyticGet).toHaveBeenCalledTimes(1);
+    });
+    it('returns cached analytics and falls back to search by id', async () => {
+        mockAnalyticGet.mockResolvedValue([{ analytic_id: 'a1', name: 'Analytic One' }]);
+        mockAnalyticSearchPost.mockResolvedValue({ items: [{ analytic_id: 'a2', name: 'Analytic Two' }] });
+        const { result } = renderHook(() => useContext(AnalyticContext), { wrapper });
+        await waitFor(() => expect(result.current.ready).toBe(true));
+        await expect(result.current.getAnalyticFromId('a1')).resolves.toEqual({ analytic_id: 'a1', name: 'Analytic One' });
+        await act(async () => {
+            await expect(result.current.getAnalyticFromId('a2')).resolves.toEqual({
+                analytic_id: 'a2',
+                name: 'Analytic Two'
+            });
+        });
+        expect(mockAnalyticSearchPost).toHaveBeenCalledWith({ query: 'analytic_id:a2' });
+    });
+    it('handles search failures gracefully', async () => {
+        mockAnalyticGet.mockResolvedValue([]);
+        mockAnalyticSearchPost.mockRejectedValue(new Error('boom'));
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        const { result } = renderHook(() => useContext(AnalyticContext), { wrapper });
+        await waitFor(() => expect(result.current.ready).toBe(true));
+        await expect(result.current.getAnalyticFromId('missing')).resolves.toBeUndefined();
+        expect(errorSpy).toHaveBeenCalled();
+    });
+});

package/components/app/providers/AppBarProvider.test.d.ts

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

package/components/app/providers/AppBarProvider.test.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { act, render, screen } from '@testing-library/react';
+import { useContext } from 'react';
+import { describe, expect, it } from 'vitest';
+import AppBarProvider, { AppBarContext } from './AppBarProvider';
+const Consumer = () => {
+    const ctx = useContext(AppBarContext);
+    return (_jsxs("div", { children: [_jsx("button", { onClick: () => ctx.addToAppBar('left', 'a', _jsx("span", { children: "A" })), children: "add-left" }), _jsx("button", { onClick: () => ctx.addToAppBar('right', 'b', _jsx("span", { children: "B" })), children: "add-right" }), _jsx("button", { onClick: () => ctx.addToAppBar('left', 'a', _jsx("span", { children: "A2" })), children: "add-duplicate" }), _jsx("button", { onClick: () => ctx.removeFromAppBar('a'), children: "remove-left" }), _jsx("span", { children: ctx.leftItems.map(item => item.id).join(',') }), _jsx("span", { children: ctx.rightItems.map(item => item.id).join(',') })] }));
+};
+describe('AppBarProvider', () => {
+    it('adds unique app bar items and removes them from both sides', async () => {
+        render(_jsx(AppBarProvider, { children: _jsx(Consumer, {}) }));
+        await act(async () => screen.getByText('add-left').click());
+        await act(async () => screen.getByText('add-right').click());
+        await act(async () => screen.getByText('add-duplicate').click());
+        expect(screen.getByText('a')).toBeInTheDocument();
+        expect(screen.getByText('b')).toBeInTheDocument();
+        await act(async () => screen.getByText('remove-left').click());
+        expect(screen.queryByText(/^a$/)).not.toBeInTheDocument();
+        expect(screen.getByText('b')).toBeInTheDocument();
+    });
+});

package/components/app/providers/AppDrawerProvider.test.d.ts

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

package/components/app/providers/AppDrawerProvider.test.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { fireEvent, render, screen } from '@testing-library/react';
+import { useContext } from 'react';
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('@tui/core', () => ({
+    PageContent: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('@mui/material', () => ({
+    Drawer: ({ children, open, onClose }) => (_jsxs("div", { "data-open": String(open), children: [_jsx("button", { onClick: onClose, children: "close-drawer" }), children] })),
+    Typography: ({ children }) => _jsx("div", { children: children })
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => `translated:${key}` })
+}));
+import AppDrawerProvider, { AppDrawerContext } from './AppDrawerProvider';
+const Consumer = () => {
+    const drawer = useContext(AppDrawerContext);
+    return (_jsxs("div", { children: [_jsx("button", { onClick: () => drawer.open({ titleKey: 'drawer.title', children: _jsx("div", { children: "drawer-body" }), onClosed: vi.fn() }), children: "open" }), _jsx("button", { onClick: () => drawer.close(), children: "close" })] }));
+};
+describe('AppDrawerProvider', () => {
+    it('opens and closes the drawer with translated content', () => {
+        const onClosed = vi.fn();
+        const TestConsumer = () => {
+            const drawer = useContext(AppDrawerContext);
+            return (_jsx("button", { onClick: () => drawer.open({ titleKey: 'drawer.title', children: _jsx("div", { children: "drawer-body" }), onClosed }), children: "open" }));
+        };
+        render(_jsx(AppDrawerProvider, { children: _jsx(TestConsumer, {}) }));
+        expect(screen.getByText('close-drawer').parentElement).toHaveAttribute('data-open', 'false');
+        fireEvent.click(screen.getByText('open'));
+        expect(screen.getByText('close-drawer').parentElement).toHaveAttribute('data-open', 'true');
+        expect(screen.getByText('translated:drawer.title')).toBeInTheDocument();
+        expect(screen.getByText('drawer-body')).toBeInTheDocument();
+        fireEvent.click(screen.getByText('close-drawer'));
+        expect(onClosed).toHaveBeenCalled();
+    });
+    it('exposes default no-op context methods before open is called', () => {
+        render(_jsx(AppDrawerProvider, { children: _jsx(Consumer, {}) }));
+        fireEvent.click(screen.getByText('close'));
+        expect(screen.getByText('close-drawer').parentElement).toHaveAttribute('data-open', 'false');
+    });
+});

package/components/app/providers/AvatarProvider.test.d.ts

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

package/components/app/providers/AvatarProvider.test.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { act, render, screen } from '@testing-library/react';
+import { useContext } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockDispatchApi = vi.hoisted(() => vi.fn());
+const mockUserGet = vi.hoisted(() => vi.fn());
+const mockAvatarGet = vi.hoisted(() => vi.fn());
+vi.mock('api', () => ({
+    default: {
+        user: {
+            get: mockUserGet,
+            avatar: { get: mockAvatarGet }
+        }
+    }
+}));
+vi.mock('components/hooks/useMyApi', () => ({
+    default: () => ({ dispatchApi: mockDispatchApi })
+}));
+import AvatarProvider, { AvatarContext } from './AvatarProvider';
+const Consumer = () => {
+    const ctx = useContext(AvatarContext);
+    return (_jsxs("div", { children: [_jsx("button", { onClick: () => void ctx.getAvatar('alice').then(v => (document.body.dataset.value = v)), children: "load-alice" }), _jsx("button", { onClick: () => void ctx.getAvatar('bob').then(v => (document.body.dataset.value = v)), children: "load-bob" }), _jsx("button", { onClick: () => void ctx.getAvatar('').then(v => (document.body.dataset.empty = v)), children: "empty" })] }));
+};
+describe('AvatarProvider', () => {
+    beforeEach(() => {
+        document.body.dataset.value = '';
+        document.body.dataset.empty = '';
+        mockDispatchApi.mockReset();
+        mockUserGet.mockReset();
+        mockAvatarGet.mockReset();
+    });
+    it('returns empty avatars for blank ids and caches resolved avatar lookups', async () => {
+        mockDispatchApi.mockResolvedValue('avatar-url');
+        render(_jsx(AvatarProvider, { children: _jsx(Consumer, {}) }));
+        await act(async () => screen.getByText('empty').click());
+        expect(document.body.dataset.empty).toBe('');
+        await act(async () => screen.getByText('load-alice').click());
+        expect(document.body.dataset.value).toBe('avatar-url');
+        await act(async () => screen.getByText('load-alice').click());
+        expect(mockDispatchApi).toHaveBeenCalledTimes(1);
+    });
+    it('falls back to the user name when the avatar request returns nothing or throws', async () => {
+        mockUserGet.mockResolvedValue({ name: 'Alice Name' });
+        mockDispatchApi.mockResolvedValueOnce(undefined).mockRejectedValueOnce(new Error('boom'));
+        render(_jsx(AvatarProvider, { children: _jsx(Consumer, {}) }));
+        await act(async () => screen.getByText('load-bob').click());
+        expect(document.body.dataset.value).toBe('Alice Name');
+    });
+});

package/components/app/providers/CustomPluginProvider.test.d.ts

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

package/components/app/providers/CustomPluginProvider.test.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+const mockExecuteFunction = vi.hoisted(() => vi.fn());
+vi.mock('plugins/store', () => ({
+    default: { plugins: ['one', 'two', 'three'] }
+}));
+vi.mock('react-pluggable', () => ({
+    usePluginStore: () => ({ executeFunction: mockExecuteFunction })
+}));
+import CustomPluginProvider from './CustomPluginProvider';
+describe('CustomPluginProvider', () => {
+    it('wraps children with every plugin provider returned by the store', () => {
+        mockExecuteFunction.mockImplementation((key) => {
+            if (key === 'one.provider')
+                return ({ children }) => _jsxs("div", { children: ["one:", children] });
+            if (key === 'two.provider')
+                return undefined;
+            if (key === 'three.provider')
+                return ({ children }) => _jsxs("div", { children: ["three:", children] });
+            return undefined;
+        });
+        render(_jsx(CustomPluginProvider, { children: _jsx("span", { children: "child" }) }));
+        expect(screen.getByText('three:')).toBeInTheDocument();
+        expect(screen.getByText('one:')).toBeInTheDocument();
+        expect(screen.getByText('child')).toBeInTheDocument();
+    });
+});

package/components/app/providers/FavouritesProvider.test.d.ts

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

package/components/app/providers/FavouritesProvider.test.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { render, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockSetMenus = vi.hoisted(() => vi.fn());
+const mockApplyMainMenuOperations = vi.hoisted(() => vi.fn((_menu, operations) => ({ id: 'root', operations })));
+const mockFetchViews = vi.hoisted(() => vi.fn());
+let appUserValue = {
+    isReady: () => true,
+    user: {
+        favourite_views: ['view-2', 'view-1', 'view-1'],
+        favourite_analytics: ['analytic-2', 'missing', 'analytic-1']
+    }
+};
+const analyticContextToken = vi.hoisted(() => ({ name: 'analytic-context' }));
+const viewContextToken = vi.hoisted(() => ({ name: 'view-context' }));
+let analyticContextValue = { analytics: [], ready: false };
+vi.mock('@mui/icons-material', () => ({
+    QueryStats: () => _jsx("div", { children: "query-stats" }),
+    SavedSearch: () => _jsx("div", { children: "saved-search" })
+}));
+vi.mock('@tui/core', () => ({
+    useAppLeftNav: () => ({ setMenus: mockSetMenus }),
+    useAppUser: () => appUserValue
+}));
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (key) => `translated:${key}` })
+}));
+vi.mock('utils/menuUtils', () => ({
+    applyMainMenuOperations: mockApplyMainMenuOperations
+}));
+vi.mock('./AnalyticProvider', () => ({
+    AnalyticContext: analyticContextToken
+}));
+vi.mock('./ViewProvider', () => ({
+    ViewContext: viewContextToken
+}));
+vi.mock('use-context-selector', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContextSelector: (context, selector) => {
+            if (context === viewContextToken) {
+                return selector({ fetchViews: mockFetchViews });
+            }
+            return selector(null);
+        }
+    };
+});
+vi.mock('react', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        useContext: (context) => {
+            if (context === analyticContextToken) {
+                return analyticContextValue;
+            }
+            return actual.useContext(context);
+        }
+    };
+});
+import FavouriteProvider from './FavouritesProvider';
+describe('FavouriteProvider', () => {
+    beforeEach(() => {
+        mockSetMenus.mockReset();
+        mockApplyMainMenuOperations.mockReset();
+        mockFetchViews.mockReset();
+        analyticContextValue = {
+            ready: true,
+            analytics: [
+                { analytic_id: 'analytic-1', name: 'One' },
+                { analytic_id: 'analytic-2', name: 'Two' }
+            ]
+        };
+        appUserValue = {
+            isReady: () => true,
+            user: {
+                favourite_views: ['view-2', 'view-1', 'view-1'],
+                favourite_analytics: ['analytic-2', 'missing', 'analytic-1']
+            }
+        };
+    });
+    it('builds favourite view and analytic menus and applies main-menu operations', async () => {
+        mockFetchViews.mockResolvedValue([
+            { view_id: 'view-1', title: 'Zulu', span: 'date.range.1.month' },
+            { view_id: 'view-2', title: 'Alpha', sort: 'created asc', indexes: ['hit'] }
+        ]);
+        render(_jsx(FavouriteProvider, { children: _jsx("div", { children: "child" }) }));
+        await waitFor(() => expect(mockSetMenus).toHaveBeenCalled());
+        expect(mockFetchViews).toHaveBeenCalledWith(['view-2', 'view-1']);
+        const callback = mockSetMenus.mock.calls[0][0];
+        const updated = callback([{ id: 'root', items: [] }, { id: 'secondary' }]);
+        expect(mockApplyMainMenuOperations).toHaveBeenCalled();
+        expect(updated[0]).toEqual(expect.objectContaining({
+            id: 'root',
+            operations: expect.arrayContaining([
+                { type: 'remove', targetId: 'views' },
+                { type: 'remove', targetId: 'analytics' },
+                expect.objectContaining({ type: 'insertRelative', anchorId: 'cases' }),
+                expect.objectContaining({ type: 'insertRelative', anchorId: 'views' })
+            ])
+        }));
+    });
+    it('skips menu work until both the user and analytics are ready', async () => {
+        appUserValue = {
+            isReady: () => false,
+            user: { favourite_views: ['view-1'], favourite_analytics: ['analytic-1'] }
+        };
+        analyticContextValue = { ready: false, analytics: [] };
+        render(_jsx(FavouriteProvider, { children: _jsx("div", { children: "child" }) }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+        expect(mockSetMenus).not.toHaveBeenCalled();
+        expect(mockFetchViews).not.toHaveBeenCalled();
+    });
+});

package/components/app/providers/FieldProvider.test.d.ts

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