@cccsaurora/howler-ui 2.19.0-dev.1143 → 2.19.0-dev.1151

package/components/elements/addons/buttons/CustomIconButton.test.d.ts

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

package/components/elements/addons/buttons/CustomIconButton.test.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { render, screen } from '@testing-library/react';
+import { setupReactRouterMock } from '@cccsaurora/howler-ui/tests/mocks';
+import { vi } from 'vitest';
+setupReactRouterMock();
+import CustomIconButton from './CustomIconButton';
+describe('CustomIconButton', () => {
+    afterAll(() => vi.resetModules());
+    describe('rendering', () => {
+        it('renders a button element', () => {
+            render(_jsx(CustomIconButton, { "aria-label": "test", children: "icon" }));
+            expect(screen.getByRole('button', { name: 'test' })).toBeInTheDocument();
+        });
+        it('renders children inside the button', () => {
+            render(_jsx(CustomIconButton, { children: "\u2605" }));
+            expect(screen.getByText('★')).toBeInTheDocument();
+        });
+        it('renders with MUI IconButton classes', () => {
+            render(_jsx(CustomIconButton, { children: "i" }));
+            expect(screen.getByRole('button')).toHaveClass('MuiIconButton-root');
+        });
+    });
+    describe('disabled state', () => {
+        it('is disabled when disabled prop is true', () => {
+            render(_jsx(CustomIconButton, { disabled: true, children: "icon" }));
+            expect(screen.getByRole('button')).toBeDisabled();
+        });
+        it('is disabled when progress is truthy', () => {
+            render(_jsx(CustomIconButton, { progress: true, children: "icon" }));
+            expect(screen.getByRole('button')).toBeDisabled();
+        });
+        it('is NOT disabled when progress is set but clickableWithProgress=true', () => {
+            render(_jsx(CustomIconButton, { progress: true, clickableWithProgress: true, children: "icon" }));
+            expect(screen.getByRole('button')).not.toBeDisabled();
+        });
+    });
+    describe('progress indicator', () => {
+        it('renders a CircularProgress when progress is truthy', () => {
+            render(_jsx(CustomIconButton, { progress: true, children: "icon" }));
+            // CircularProgress renders an svg with role="progressbar"
+            expect(document.querySelector('circle')).toBeInTheDocument();
+        });
+        it('does not render CircularProgress when progress is falsy', () => {
+            render(_jsx(CustomIconButton, { children: "icon" }));
+            expect(document.querySelector('[role="progressbar"]')).not.toBeInTheDocument();
+        });
+    });
+    describe('tooltip', () => {
+        it('wraps the button in a Tooltip when tooltip prop is provided', () => {
+            render(_jsx(CustomIconButton, { tooltip: "Save", children: "icon" }));
+            // The button is wrapped in a <span> when a Tooltip is used
+            const span = screen.getByRole('button').closest('span');
+            expect(span).toBeInTheDocument();
+        });
+        it('does not add a surrounding span when no tooltip is given', () => {
+            render(_jsx(CustomIconButton, { children: "icon" }));
+            const button = screen.getByRole('button');
+            // Without tooltip the immediate parent should NOT be a span wrapper
+            expect(button.parentElement?.tagName).not.toBe('SPAN');
+        });
+    });
+    describe('route link', () => {
+        it('wraps the button in a Link when route prop is provided', () => {
+            render(_jsx(CustomIconButton, { route: "/hits", children: "icon" }));
+            expect(screen.getByRole('link')).toBeInTheDocument();
+        });
+        it('does not render a link when no route is given', () => {
+            render(_jsx(CustomIconButton, { children: "icon" }));
+            expect(screen.queryByRole('link')).not.toBeInTheDocument();
+        });
+    });
+    describe('href link', () => {
+        it('wraps the button in an anchor tag when href is provided', () => {
+            render(_jsx(CustomIconButton, { href: "https://example.com", children: "icon" }));
+            const anchor = screen.getByRole('link');
+            expect(anchor).toBeInTheDocument();
+            expect(anchor).toHaveAttribute('href', 'https://example.com');
+        });
+    });
+});

package/components/elements/addons/layout/FlexVertical.test.d.ts

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

package/components/elements/addons/layout/FlexVertical.test.js

@@ -0,0 +1,32 @@
+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 } from 'vitest';
+import FlexVertical from './FlexVertical';
+describe('FlexVertical', () => {
+    it('renders a div with display:flex and flex-direction:column', () => {
+        const { container } = render(_jsx(FlexVertical, { children: _jsx("span", { children: "child" }) }));
+        const div = container.firstChild;
+        expect(div).toBeInTheDocument();
+        expect(div).toHaveStyle({ display: 'flex', flexDirection: 'column' });
+    });
+    it('renders children inside the flex container', () => {
+        render(_jsx(FlexVertical, { children: _jsx("span", { id: "inner", children: "hello" }) }));
+        expect(screen.getByTestId('inner')).toBeInTheDocument();
+    });
+    it('renders multiple children', () => {
+        render(_jsxs(FlexVertical, { children: [_jsx("span", { id: "a", children: "A" }), _jsx("span", { id: "b", children: "B" })] }));
+        expect(screen.getByTestId('a')).toBeInTheDocument();
+        expect(screen.getByTestId('b')).toBeInTheDocument();
+    });
+    it('applies the default flex value of 1', () => {
+        const { container } = render(_jsx(FlexVertical, { children: _jsx("span", { children: "child" }) }));
+        const div = container.firstChild;
+        expect(div).toHaveStyle({ flex: 1 });
+    });
+    it('applies a custom flex value when provided', () => {
+        const { container } = render(_jsx(FlexVertical, { flex: 2, children: _jsx("span", { children: "child" }) }));
+        const div = container.firstChild;
+        expect(div).toHaveStyle({ flex: 2 });
+    });
+});

package/components/elements/addons/layout/vsbox/VSBoxContent.test.d.ts

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

package/components/elements/addons/layout/vsbox/VSBoxContent.test.js

@@ -0,0 +1,26 @@
+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 } from 'vitest';
+import VSBoxContent from './VSBoxContent';
+describe('VSBoxContent', () => {
+    it('renders children inside a div with data-vsbox-content attribute', () => {
+        render(_jsx(VSBoxContent, { children: _jsx("span", { children: "hello" }) }));
+        const el = document.querySelector('[data-vsbox-content]');
+        expect(el).toBeInTheDocument();
+        expect(el).toHaveAttribute('data-vsbox-content', 'true');
+    });
+    it('renders children correctly', () => {
+        render(_jsx(VSBoxContent, { children: _jsx("span", { id: "child", children: "content" }) }));
+        expect(screen.getByTestId('child')).toBeInTheDocument();
+    });
+    it('passes additional MUI Box props through', () => {
+        const { container } = render(_jsx(VSBoxContent, { sx: { display: 'flex' }, children: _jsx("span", { children: "content" }) }));
+        expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders multiple children', () => {
+        render(_jsxs(VSBoxContent, { children: [_jsx("span", { id: "a", children: "A" }), _jsx("span", { id: "b", children: "B" })] }));
+        expect(screen.getByTestId('a')).toBeInTheDocument();
+        expect(screen.getByTestId('b')).toBeInTheDocument();
+    });
+});

package/components/elements/addons/search/phrase/WordLexer.test.d.ts

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

package/components/elements/addons/search/phrase/WordLexer.test.js

@@ -0,0 +1,55 @@
+/// <reference types="vitest" />
+import { describe, expect, it } from 'vitest';
+import WordLexer from './word/WordLexer';
+describe('WordLexer', () => {
+    const lexer = new WordLexer();
+    describe('parse', () => {
+        it('parses a single word', () => {
+            const result = lexer.parse('hello');
+            expect(result.tokens).toHaveLength(2); // word + eop
+            expect(result.tokens[0].type).toBe('word');
+            expect(result.tokens[0].value).toBe('hello');
+        });
+        it('parses two words separated by a space', () => {
+            const result = lexer.parse('hello world');
+            const nonEop = result.tokens.filter(t => t.type !== 'eop');
+            expect(nonEop.some(t => t.type === 'word' && t.value === 'hello')).toBe(true);
+            expect(nonEop.some(t => t.type === 'word' && t.value === 'world')).toBe(true);
+        });
+        it('always ends with an eop token', () => {
+            const result = lexer.parse('foo bar');
+            const last = result.tokens[result.tokens.length - 1];
+            expect(last.type).toBe('eop');
+            expect(last.value).toBe('');
+        });
+        it('returns an eop-only token list for empty input', () => {
+            const result = lexer.parse('');
+            expect(result.tokens).toHaveLength(1);
+            expect(result.tokens[0].type).toBe('eop');
+        });
+        it('sets cursor correctly', () => {
+            const result = lexer.parse('hello', 3);
+            expect(result.cursor).toBe(3);
+        });
+        it('sets current token for cursor in the middle of a word', () => {
+            const result = lexer.parse('hello', 3);
+            expect(result.current?.type).toBe('word');
+        });
+        it('provides suggest token for current cursor position', () => {
+            const result = lexer.parse('hello world', 7);
+            expect(result.suggest).toBeDefined();
+            expect(result.suggest.token).toBeDefined();
+        });
+        it('sets startIndex/endIndex correctly on word tokens', () => {
+            const result = lexer.parse('hi');
+            const wordToken = result.tokens.find(t => t.type === 'word');
+            expect(wordToken.startIndex).toBe(0);
+            expect(wordToken.endIndex).toBe(1);
+        });
+        it('whitespace tokens have correct type', () => {
+            const result = lexer.parse('a b');
+            const wsToken = result.tokens.find(t => t.type === 'whitespace');
+            expect(wsToken).toBeDefined();
+        });
+    });
+});

package/components/hooks/useMyTheme.test.d.ts

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

package/components/hooks/useMyTheme.test.js

@@ -0,0 +1,35 @@
+/// <reference types="vitest" />
+import { renderHook } from '@testing-library/react';
+import { describe, expect, it } from 'vitest';
+import useMyTheme from './useMyTheme';
+describe('useMyTheme', () => {
+    it('returns a theme configuration object', () => {
+        const { result } = renderHook(() => useMyTheme());
+        expect(result.current).toBeDefined();
+        expect(typeof result.current).toBe('object');
+    });
+    it('contains a dark palette entry', () => {
+        const { result } = renderHook(() => useMyTheme());
+        expect(result.current.palette?.dark).toBeDefined();
+    });
+    it('contains a light palette entry', () => {
+        const { result } = renderHook(() => useMyTheme());
+        expect(result.current.palette?.light).toBeDefined();
+    });
+    it('returns the same reference on re-render (stable return value)', () => {
+        const { result, rerender } = renderHook(() => useMyTheme());
+        const first = result.current;
+        rerender();
+        expect(result.current).toBe(first);
+    });
+    it('dark palette includes primary and secondary colours', () => {
+        const { result } = renderHook(() => useMyTheme());
+        expect(result.current.palette.dark.primary).toHaveProperty('main');
+        expect(result.current.palette.dark.secondary).toHaveProperty('main');
+    });
+    it('light palette includes primary and secondary colours', () => {
+        const { result } = renderHook(() => useMyTheme());
+        expect(result.current.palette.light.primary).toHaveProperty('main');
+        expect(result.current.palette.light.secondary).toHaveProperty('main');
+    });
+});

package/components/routes/advanced/eqlTokenProvider.test.d.ts

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

package/components/routes/advanced/eqlTokenProvider.test.js

@@ -0,0 +1,34 @@
+/// <reference types="vitest" />
+import { describe, expect, it } from 'vitest';
+import TOKEN_PROVIDER from './eqlTokenProvider';
+describe('EQL token provider', () => {
+    it('exports a non-null object', () => {
+        expect(TOKEN_PROVIDER).toBeDefined();
+        expect(TOKEN_PROVIDER).not.toBeNull();
+        expect(typeof TOKEN_PROVIDER).toBe('object');
+    });
+    it('has a "root" tokenizer entry', () => {
+        expect(TOKEN_PROVIDER.tokenizer).toBeDefined();
+        expect(TOKEN_PROVIDER.tokenizer.root).toBeDefined();
+        expect(Array.isArray(TOKEN_PROVIDER.tokenizer.root)).toBe(true);
+    });
+    it('uses "invalid" as the defaultToken', () => {
+        expect(TOKEN_PROVIDER.defaultToken).toBe('invalid');
+    });
+    it('defines the expected EQL keywords', () => {
+        const kws = TOKEN_PROVIDER.keywords;
+        expect(kws).toContain('where');
+        expect(kws).toContain('not');
+        expect(kws).toContain('in');
+        expect(kws).toContain('head');
+        expect(kws).toContain('tail');
+    });
+    it('defines boolean operators', () => {
+        const booleans = TOKEN_PROVIDER.booleans;
+        expect(booleans).toContain('and');
+        expect(booleans).toContain('or');
+    });
+    it('has includeLF set to true', () => {
+        expect(TOKEN_PROVIDER.includeLF).toBe(true);
+    });
+});

package/components/routes/advanced/luceneTokenProvider.test.d.ts

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

package/components/routes/advanced/luceneTokenProvider.test.js

@@ -0,0 +1,34 @@
+/// <reference types="vitest" />
+import { describe, expect, it } from 'vitest';
+import TOKEN_PROVIDER from './luceneTokenProvider';
+describe('Lucene token provider', () => {
+    it('exports a non-null object', () => {
+        expect(TOKEN_PROVIDER).toBeDefined();
+        expect(TOKEN_PROVIDER).not.toBeNull();
+        expect(typeof TOKEN_PROVIDER).toBe('object');
+    });
+    it('has a "root" tokenizer entry', () => {
+        expect(TOKEN_PROVIDER.tokenizer).toBeDefined();
+        expect(TOKEN_PROVIDER.tokenizer.root).toBeDefined();
+        expect(Array.isArray(TOKEN_PROVIDER.tokenizer.root)).toBe(true);
+    });
+    it('defines the expected operators', () => {
+        const ops = TOKEN_PROVIDER.operators;
+        expect(ops).toContain('-');
+        expect(ops).toContain('&&');
+        expect(ops).toContain('||');
+        expect(ops).toContain(':');
+    });
+    it('defines the expected keywords (AND, OR, NOT)', () => {
+        const kws = TOKEN_PROVIDER.keywords;
+        expect(kws).toContain('AND');
+        expect(kws).toContain('OR');
+        expect(kws).toContain('NOT');
+    });
+    it('uses "default" as the defaultToken', () => {
+        expect(TOKEN_PROVIDER.defaultToken).toBe('default');
+    });
+    it('includes a string tokenizer state for quoted values', () => {
+        expect(TOKEN_PROVIDER.tokenizer).toHaveProperty('string');
+    });
+});

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

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

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

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import i18n from '@cccsaurora/howler-ui/i18n';
+import { I18nextProvider } from 'react-i18next';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import HomeSettings from './HomeSettings';
+const Wrapper = ({ children }) => (_jsx(I18nextProvider, { i18n: i18n, children: children }));
+describe('HomeSettings', () => {
+    let onRefreshRateChange;
+    let onEdit;
+    beforeEach(() => {
+        onRefreshRateChange = vi.fn();
+        onEdit = vi.fn();
+        vi.clearAllMocks();
+    });
+    it('renders the settings icon button', () => {
+        render(_jsx(HomeSettings, { isEditing: false, refreshRate: 30, onRefreshRateChange: onRefreshRateChange, onEdit: onEdit }), { wrapper: Wrapper });
+        expect(screen.getByRole('button')).toBeInTheDocument();
+    });
+    it('opens the settings menu when the icon button is clicked', async () => {
+        const user = userEvent.setup();
+        render(_jsx(HomeSettings, { isEditing: false, refreshRate: 30, onRefreshRateChange: onRefreshRateChange, onEdit: onEdit }), { wrapper: Wrapper });
+        await user.click(screen.getByRole('button'));
+        // The menu should now be open – the edit menu item should be visible
+        expect(screen.getByRole('menu')).toBeInTheDocument();
+    });
+    it('calls onEdit when the Edit menu item is clicked', async () => {
+        const user = userEvent.setup();
+        render(_jsx(HomeSettings, { isEditing: false, refreshRate: 30, onRefreshRateChange: onRefreshRateChange, onEdit: onEdit }), { wrapper: Wrapper });
+        await user.click(screen.getByRole('button'));
+        const editItem = screen.getAllByRole('menuitem')[0];
+        await user.click(editItem);
+        expect(onEdit).toHaveBeenCalledTimes(1);
+    });
+    it('disables the Edit menu item when isEditing=true', async () => {
+        const user = userEvent.setup();
+        render(_jsx(HomeSettings, { isEditing: true, refreshRate: 30, onRefreshRateChange: onRefreshRateChange, onEdit: onEdit }), { wrapper: Wrapper });
+        await user.click(screen.getByRole('button'));
+        const editItem = screen.getAllByRole('menuitem')[0];
+        expect(editItem).toHaveAttribute('aria-disabled', 'true');
+    });
+});

package/components/routes/overviews/markdownExtendedTokenProvider.test.d.ts

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

package/components/routes/overviews/markdownExtendedTokenProvider.test.js

@@ -0,0 +1,50 @@
+/// <reference types="vitest" />
+import { describe, expect, it } from 'vitest';
+import { conf, language } from './markdownExtendedTokenProvider';
+describe('markdownExtendedTokenProvider', () => {
+    describe('conf', () => {
+        it('exports a language configuration object', () => {
+            expect(conf).toBeDefined();
+            expect(typeof conf).toBe('object');
+        });
+        it('defines block comment markers', () => {
+            expect(conf.comments?.blockComment).toEqual(['<!--', '-->']);
+        });
+        it('defines bracket pairs', () => {
+            expect(Array.isArray(conf.brackets)).toBe(true);
+            expect(conf.brackets.length).toBeGreaterThan(0);
+        });
+        it('defines auto-closing pairs', () => {
+            expect(Array.isArray(conf.autoClosingPairs)).toBe(true);
+        });
+        it('defines folding markers', () => {
+            expect(conf.folding?.markers?.start).toBeInstanceOf(RegExp);
+            expect(conf.folding?.markers?.end).toBeInstanceOf(RegExp);
+        });
+    });
+    describe('language', () => {
+        it('exports a monarch language definition', () => {
+            expect(language).toBeDefined();
+            expect(typeof language).toBe('object');
+        });
+        it('has a root tokenizer state', () => {
+            expect(language.tokenizer).toBeDefined();
+            expect(Array.isArray(language.tokenizer.root)).toBe(true);
+        });
+        it('uses an empty string as the default token', () => {
+            expect(language.defaultToken).toBe('');
+        });
+        it('includes Handlebars operators in the language definition', () => {
+            const operators = language.handlebars_operators;
+            expect(Array.isArray(operators)).toBe(true);
+            expect(operators).toContain('#if');
+            expect(operators).toContain('/if');
+        });
+        it('includes a handlebars tokenizer state', () => {
+            expect(language.tokenizer).toHaveProperty('handlebars');
+        });
+        it('includes an html tokenizer state', () => {
+            expect(language.tokenizer).toHaveProperty('html');
+        });
+    });
+});

package/package.json

@@ -21,20 +21,20 @@
     "@iconify/icons-logos": "^1.2.36",
     "@iconify/icons-simple-icons": "^1.2.74",
     "@iconify/react": "^4.1.1",
-    "@jsonforms/core": "^3.7.0",
-    "@jsonforms/material-renderers": "^3.7.0",
-    "@jsonforms/react": "^3.7.0",
-    "@microlink/react-json-view": "^1.31.20",
+    "@jsonforms/core": "^3.8.0",
+    "@jsonforms/material-renderers": "^3.8.0",
+    "@jsonforms/react": "^3.8.0",
+    "@microlink/react-json-view": "^1.31.22",
     "@monaco-editor/react": "^4.7.0",
     "ajv": "^8.20.0",
     "ajv-i18n": "^4.2.0",
-    "axios": "^1.17.0",
+    "axios": "^1.18.1",
     "axios-retry": "^3.9.1",
     "chart.js": "^4.5.1",
     "chartjs-adapter-dayjs-4": "^1.0.4",
     "chartjs-plugin-zoom": "^2.2.0",
     "dayjs": "^1.11.21",
-    "dompurify": "^3.4.9",
+    "dompurify": "^3.4.11",
     "flat": "^6.0.1",
     "fuse.js": "^7.4.2",
     "handlebars": "^4.7.9",
@@ -44,7 +44,7 @@
     "json-schema": "^0.4.0",
     "lodash-es": "^4.18.1",
     "md5": "^2.3.0",
-    "mermaid": "^11.15.0",
+    "mermaid": "^11.16.0",
     "monaco-editor": "0.49.0",
     "notistack": "^3.0.2",
     "react": "^18.3.1",
@@ -67,7 +67,7 @@
     "unist-util-visit": "^5.1.0",
     "url-join": "^5.0.0",
     "use-context-selector": "^2.0.0",
-    "uuid": "^14.0.0",
+    "uuid": "^14.0.1",
     "web-vitals": "^4.2.4"
   },
   "jest": {
@@ -93,7 +93,7 @@
     "url": "https://github.com/CybercentreCanada/howler"
   },
   "type": "module",
-  "version": "2.19.0-dev.1143",
+  "version": "2.19.0-dev.1151",
   "exports": {
     "./i18n": "./i18n.js",
     "./index.css": "./index.css",

package/rest/AxiosClient.test.d.ts

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

package/rest/AxiosClient.test.js

@@ -0,0 +1,184 @@
+/// <reference types="vitest" />
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import AxiosClient from './AxiosClient';
+// ---------------------------------------------------------------------------
+// vi.hoisted() ensures these values are available when the vi.mock factories
+// run (which happens before any module code executes).
+// ---------------------------------------------------------------------------
+const { mockAxiosInstance, mockAxiosError, mockInterceptorResponseUse, interceptorRef } = vi.hoisted(() => {
+    // Ref object used to capture the response interceptor across test resets
+    const _interceptorRef = { fn: null };
+    const _mockInterceptorResponseUse = vi.fn().mockImplementation((onFulfilled) => {
+        _interceptorRef.fn = onFulfilled;
+    });
+    const _mockAxiosInstance = vi.fn();
+    _mockAxiosInstance.interceptors = {
+        response: { use: _mockInterceptorResponseUse }
+    };
+    class MockAxiosError extends Error {
+        response;
+        constructor(message, response) {
+            super(message);
+            this.name = 'AxiosError';
+            this.response = response;
+        }
+    }
+    return {
+        mockAxiosInstance: _mockAxiosInstance,
+        mockAxiosError: MockAxiosError,
+        mockInterceptorResponseUse: _mockInterceptorResponseUse,
+        interceptorRef: _interceptorRef
+    };
+});
+vi.mock('axios', () => ({
+    default: { create: vi.fn(() => mockAxiosInstance) },
+    AxiosError: mockAxiosError
+}));
+vi.mock('axios-retry', () => ({
+    default: vi.fn(),
+    exponentialDelay: vi.fn(),
+    isNetworkError: vi.fn()
+}));
+vi.mock('utils/sessionStorage', () => ({
+    getAxiosCache: vi.fn(() => ({})),
+    setAxiosCache: vi.fn()
+}));
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('AxiosClient', () => {
+    let client;
+    beforeEach(() => {
+        interceptorRef.fn = null;
+        client = new AxiosClient();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    // -------------------------------------------------------------------------
+    // fetch() – happy paths
+    // -------------------------------------------------------------------------
+    describe('fetch() – successful responses', () => {
+        it('returns [data, status, headers] on a 200 response', async () => {
+            const payload = { api_response: { items: [] } };
+            mockAxiosInstance.mockResolvedValueOnce({
+                data: payload,
+                status: 200,
+                headers: { 'content-type': 'application/json' }
+            });
+            const result = await client.fetch('/api/v1/hit');
+            expect(result[0]).toEqual(payload);
+            expect(result[1]).toBe(200);
+        });
+        it('uses GET as the default HTTP method', async () => {
+            mockAxiosInstance.mockResolvedValueOnce({ data: {}, status: 200, headers: {} });
+            await client.fetch('/api/v1/hit');
+            const config = mockAxiosInstance.mock.calls[0][0];
+            expect(config.method).toBe('get');
+        });
+        it('passes POST as the HTTP method when specified', async () => {
+            mockAxiosInstance.mockResolvedValueOnce({ data: {}, status: 201, headers: {} });
+            await client.fetch('/api/v1/hit', 'post', { key: 'val' });
+            const config = mockAxiosInstance.mock.calls[0][0];
+            expect(config.method).toBe('post');
+        });
+        it('serialises the body as a JSON string', async () => {
+            mockAxiosInstance.mockResolvedValueOnce({ data: {}, status: 200, headers: {} });
+            await client.fetch('/api/v1/hit', 'post', { status: 'open' });
+            const config = mockAxiosInstance.mock.calls[0][0];
+            expect(config.data).toBe(JSON.stringify({ status: 'open' }));
+        });
+        it('passes URLSearchParams through as params', async () => {
+            mockAxiosInstance.mockResolvedValueOnce({ data: {}, status: 200, headers: {} });
+            const params = new URLSearchParams({ q: 'test' });
+            await client.fetch('/api/v1/hit', 'get', undefined, params);
+            const config = mockAxiosInstance.mock.calls[0][0];
+            expect(config.params).toBe(params);
+        });
+        it('forwards custom headers', async () => {
+            mockAxiosInstance.mockResolvedValueOnce({ data: {}, status: 200, headers: {} });
+            const headers = { Authorization: '******' };
+            await client.fetch('/api/v1/hit', 'get', undefined, undefined, headers);
+            const config = mockAxiosInstance.mock.calls[0][0];
+            expect(config.headers).toEqual(headers);
+        });
+        it('sets withCredentials to true', async () => {
+            mockAxiosInstance.mockResolvedValueOnce({ data: {}, status: 200, headers: {} });
+            await client.fetch('/api/v1/hit');
+            const config = mockAxiosInstance.mock.calls[0][0];
+            expect(config.withCredentials).toBe(true);
+        });
+        it('passes the URL through to the axios config', async () => {
+            mockAxiosInstance.mockResolvedValueOnce({ data: {}, status: 200, headers: {} });
+            await client.fetch('/api/v1/test-url');
+            const config = mockAxiosInstance.mock.calls[0][0];
+            expect(config.url).toBe('/api/v1/test-url');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // fetch() – error handling
+    // -------------------------------------------------------------------------
+    describe('fetch() – error handling', () => {
+        it('returns [data, status, headers] when the error is an AxiosError with a response', async () => {
+            const errorResponse = { data: { error: 'not found' }, status: 404, headers: {} };
+            const axiosErr = new mockAxiosError('Not Found', errorResponse);
+            mockAxiosInstance.mockRejectedValueOnce(axiosErr);
+            const result = await client.fetch('/api/v1/missing');
+            expect(result[0]).toEqual({ error: 'not found' });
+            expect(result[1]).toBe(404);
+        });
+        it('rethrows non-AxiosError exceptions', async () => {
+            mockAxiosInstance.mockRejectedValueOnce(new TypeError('network failure'));
+            await expect(client.fetch('/api/v1/hit')).rejects.toThrow('network failure');
+        });
+        it('rethrows AxiosError that has no response body', async () => {
+            // AxiosError without a .response property → condition `e.response?.data` is falsy → rethrow
+            const axiosErr = new mockAxiosError('timeout');
+            mockAxiosInstance.mockRejectedValueOnce(axiosErr);
+            await expect(client.fetch('/api/v1/hit')).rejects.toThrow('timeout');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // AxiosCache – response interceptor
+    // -------------------------------------------------------------------------
+    describe('AxiosCache response interceptor', () => {
+        it('is registered on the axios instance during construction', () => {
+            expect(mockInterceptorResponseUse).toHaveBeenCalled();
+            expect(interceptorRef.fn).toBeTypeOf('function');
+        });
+        it('stores a new etag cache entry on a 2xx response with an etag header', async () => {
+            const { setAxiosCache } = await import('utils/sessionStorage');
+            const res = {
+                status: 200,
+                headers: { etag: '"abc123"' },
+                data: { value: 1 },
+                config: { headers: {} }
+            };
+            await interceptorRef.fn(res);
+            expect(setAxiosCache).toHaveBeenCalledWith('"abc123"', { value: 1 });
+        });
+        it('replaces data from cache on a 304 response', async () => {
+            const { getAxiosCache } = await import('utils/sessionStorage');
+            getAxiosCache.mockReturnValueOnce({ '"etag-v1"': { cached: true } });
+            const res = {
+                status: 304,
+                headers: {},
+                data: null,
+                config: { headers: { 'If-Match': '"etag-v1"' } }
+            };
+            const result = await interceptorRef.fn(res);
+            expect(result.data).toEqual({ cached: true });
+        });
+        it('passes through a 2xx response without an etag without caching', async () => {
+            const { setAxiosCache } = await import('utils/sessionStorage');
+            const res = {
+                status: 200,
+                headers: {},
+                data: { ok: true },
+                config: { headers: {} }
+            };
+            await interceptorRef.fn(res);
+            expect(setAxiosCache).not.toHaveBeenCalled();
+        });
+    });
+});

package/utils/utils.test.js

@@ -1,6 +1,6 @@
 /// <reference types="vitest" />
-import { describe, expect, it } from 'vitest';
-import { bytesToSize, compareTimestamp, convertCustomDateRangeToLucene, convertDateToLucene, convertLuceneToDate, flattenDeep, formatDate, getTimeRange, hashCode, humanReadableNumber, removeEmpty, searchObject, sortByTimestamp, tryParse, twitterShort } from './utils';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { bytesToSize, compareTimestamp, convertCustomDateRangeToLucene, convertDateToLucene, convertLuceneToDate, delay, flattenDeep, formatDate, getProvider, getTimeRange, hashCode, humanReadableNumber, removeEmpty, searchObject, searchResultsDisplay, sortByTimestamp, stringToColor, tryParse, twitterShort } from './utils';
 describe('bytesToSize', () => {
     it('returns "0 B" for 0', () => {
         expect(bytesToSize(0)).toBe('0 B');
@@ -290,3 +290,120 @@ describe('twitterShort', () => {
         expect(result).toMatch(/year/);
     });
 });
+describe('stringToColor', () => {
+    it('returns a non-empty string for any input', () => {
+        const result = stringToColor('hello');
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+    it('returns the same color for the same input', () => {
+        expect(stringToColor('alice')).toBe(stringToColor('alice'));
+    });
+    it('returns different colors for different inputs', () => {
+        // Not guaranteed for all pairs, but statistically very likely for distinct words
+        const colors = ['alice', 'bob', 'carol', 'dave'].map(stringToColor);
+        const unique = new Set(colors);
+        expect(unique.size).toBeGreaterThan(1);
+    });
+    it('handles an empty string without throwing', () => {
+        expect(() => stringToColor('')).not.toThrow();
+    });
+});
+describe('delay', () => {
+    it('resolves after the specified time', async () => {
+        vi.useFakeTimers();
+        const promise = delay(100);
+        vi.advanceTimersByTime(100);
+        await expect(promise).resolves.toBeUndefined();
+        vi.useRealTimers();
+    });
+    it('does not resolve before the specified time', async () => {
+        vi.useFakeTimers();
+        let resolved = false;
+        delay(200).then(() => {
+            resolved = true;
+        });
+        vi.advanceTimersByTime(100);
+        expect(resolved).toBe(false);
+        vi.advanceTimersByTime(100);
+        await Promise.resolve(); // flush microtasks
+        expect(resolved).toBe(true);
+        vi.useRealTimers();
+    });
+    it('can be cancelled via the .cancel() method without rejecting by default', () => {
+        vi.useFakeTimers();
+        const d = delay(100);
+        expect(() => d.cancel()).not.toThrow();
+        vi.useRealTimers();
+    });
+    it('rejects on cancel when rejectOnCancel=true', async () => {
+        vi.useFakeTimers();
+        const d = delay(100, true);
+        const rejection = expect(d).rejects.toBeUndefined();
+        d.cancel();
+        await rejection;
+        vi.useRealTimers();
+    });
+});
+describe('getProvider', () => {
+    const originalLocation = window.location;
+    afterEach(() => {
+        Object.defineProperty(window, 'location', { value: originalLocation, writable: true });
+    });
+    it('returns the provider from the search params when not in oauth path', () => {
+        Object.defineProperty(window, 'location', {
+            writable: true,
+            value: { pathname: '/login', search: '?provider=azure', href: 'http://localhost/login?provider=azure' }
+        });
+        expect(getProvider()).toBe('azure');
+    });
+    it('returns null when no provider param is present and path is not oauth', () => {
+        Object.defineProperty(window, 'location', {
+            writable: true,
+            value: { pathname: '/hits', search: '', href: 'http://localhost/hits' }
+        });
+        expect(getProvider()).toBeNull();
+    });
+});
+describe('searchResultsDisplay', () => {
+    const originalLocation = window.location;
+    afterEach(() => {
+        Object.defineProperty(window, 'location', { value: originalLocation, writable: true });
+    });
+    it('returns count as string when below the max', () => {
+        Object.defineProperty(window, 'location', {
+            writable: true,
+            value: { pathname: '/', search: '', href: 'http://localhost/' }
+        });
+        expect(searchResultsDisplay(500)).toBe('500');
+    });
+    it('appends "+" when count equals the default max (10000) and no track_total_hits param', () => {
+        Object.defineProperty(window, 'location', {
+            writable: true,
+            value: { pathname: '/', search: '', href: 'http://localhost/' }
+        });
+        expect(searchResultsDisplay(10000)).toBe('10000+');
+    });
+    it('appends "+" when count matches the explicit track_total_hits param', () => {
+        Object.defineProperty(window, 'location', {
+            writable: true,
+            value: { pathname: '/', search: '?track_total_hits=500', href: 'http://localhost/?track_total_hits=500' }
+        });
+        expect(searchResultsDisplay(500)).toBe('500+');
+    });
+    it('does not append "+" when count does not equal track_total_hits', () => {
+        Object.defineProperty(window, 'location', {
+            writable: true,
+            value: { pathname: '/', search: '?track_total_hits=1000', href: 'http://localhost/?track_total_hits=1000' }
+        });
+        expect(searchResultsDisplay(500)).toBe('500');
+    });
+    it('uses a custom max when provided', () => {
+        Object.defineProperty(window, 'location', {
+            writable: true,
+            value: { pathname: '/', search: '', href: 'http://localhost/' }
+        });
+        expect(searchResultsDisplay(500, 500)).toBe('500+');
+        expect(searchResultsDisplay(499, 500)).toBe('499');
+    });
+});