@cccsaurora/howler-ui 2.19.0-dev.999 → 2.19.0

package/rest/AxiosClient.test.js

@@ -0,0 +1,185 @@
+/// <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', () => ({
+    create: vi.fn(() => mockAxiosInstance),
+    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/tests/mocks.d.ts

@@ -7,7 +7,17 @@ export declare const setupContextSelectorMock: () => void;
  * Sets up a mock for react-router-dom with common defaults
  * @param options - Override specific router behavior
  */
-export declare const setupReactRouterMock: () => void;
+export declare const setupReactRouterMock: () => {
+    mockSearchParams: URLSearchParams;
+    mockSetParams: import("vitest").Mock<(...args: any[]) => any>;
+    mockLocation: {
+        pathname: string;
+        search: string;
+    };
+    mockParams: {
+        id: any;
+    };
+};
 /**
  * Sets up a mock localStorage instance
  */

package/tests/mocks.js

@@ -31,15 +31,20 @@ export const setupReactRouterMock = () => {
     const mockSearchParams = vi.hoisted(() => new URLSearchParams());
     const mockSetParams = vi.hoisted(() => vi.fn());
     beforeAll(() => {
-        vi.mock('react-router-dom', () => ({
-            Link: forwardRef(({ to, children, ...props }, ref) => (_jsx("a", { ref: ref, href: to, ...props, children: children }))),
-            useLocation: vi.fn(() => mockLocation),
-            useParams: vi.fn(() => mockParams),
-            useSearchParams: vi.fn(() => [mockSearchParams, mockSetParams]),
-            useNavigate: () => vi.fn()
-        }));
+        vi.mock('react-router-dom', async () => {
+            const actual = await vi.importActual('react-router-dom');
+            return {
+                ...actual,
+                Link: forwardRef(({ to, children, ...props }, ref) => (_jsx("a", { ref: ref, href: to, ...props, children: children }))),
+                useLocation: vi.fn(() => mockLocation),
+                useParams: vi.fn(() => mockParams),
+                useSearchParams: vi.fn(() => [mockSearchParams, mockSetParams]),
+                useNavigate: () => vi.fn()
+            };
+        });
     });
     afterAll(() => vi.resetModules());
+    return { mockSearchParams, mockSetParams, mockLocation, mockParams };
 };
 /**
  * Sets up a mock localStorage instance

package/tests/server-handlers.js

@@ -30,7 +30,17 @@ export const MOCK_RESPONSES = {
         total: 1,
         rows: 1
     },
-    '/api/v1/analytic': [createMockAnalytic()]
+    '/api/v1/analytic': [createMockAnalytic()],
+    '/api/v2/search/hit,event': {
+        items: [],
+        total: 0,
+        rows: 0
+    },
+    '/api/v2/search/hit': {
+        items: [],
+        total: 0,
+        rows: 0
+    }
 };
 const handlers = [
     ...Object.entries(MOCK_RESPONSES).map(([path, data]) => http.all(path, async () => HttpResponse.json({ api_response: data }))),

package/tests/utils.d.ts

@@ -1,6 +1,8 @@
 import type { Action } from '@cccsaurora/howler-ui/models/entities/generated/Action';
 import type { Analytic } from '@cccsaurora/howler-ui/models/entities/generated/Analytic';
+import type { Case } from '@cccsaurora/howler-ui/models/entities/generated/Case';
 import type { Dossier } from '@cccsaurora/howler-ui/models/entities/generated/Dossier';
+import type { Event } from '@cccsaurora/howler-ui/models/entities/generated/Event';
 import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
 import type { Template } from '@cccsaurora/howler-ui/models/entities/generated/Template';
 import type { View } from '@cccsaurora/howler-ui/models/entities/generated/View';
@@ -8,9 +10,11 @@ type RecursivePartial<T> = {
     [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object | undefined ? RecursivePartial<T[P]> : T[P];
 };
 export declare const createMockHit: (overrides?: RecursivePartial<Hit>) => Hit;
+export declare const createMockEvent: (overrides?: RecursivePartial<Event>) => Event;
 export declare const createMockAnalytic: (overrides?: Partial<Analytic>) => Analytic;
 export declare const createMockTemplate: (overrides?: Partial<Template>) => Template;
 export declare const createMockAction: (overrides?: Partial<Action>) => Action;
 export declare const createMockView: (overrides?: Partial<View>) => View;
+export declare const createMockCase: (overrides?: Partial<Case>) => Case;
 export declare const createMockDossier: (overrides?: Partial<Dossier>) => Dossier;
 export {};

package/tests/utils.js

@@ -1,5 +1,7 @@
 // Mock data factories
 export const createMockHit = (overrides) => ({
+    ...overrides,
+    __index: 'hit',
     howler: {
         id: 'test-hit-1',
         analytic: 'test-analytic',
@@ -14,6 +16,17 @@ export const createMockHit = (overrides) => ({
         ...overrides?.event
     }
 });
+export const createMockEvent = (overrides) => ({
+    ...overrides,
+    __index: 'event',
+    howler: {
+        id: 'test-event-1',
+        analytic: 'test-analytic',
+        detection: 'Test Detection',
+        hash: '',
+        ...overrides?.howler
+    }
+});
 export const createMockAnalytic = (overrides) => ({
     analytic_id: 'test-analytic-id',
     name: 'test-analytic',
@@ -52,6 +65,14 @@ export const createMockView = (overrides) => ({
     },
     ...overrides
 });
+export const createMockCase = (overrides) => ({
+    __index: 'case',
+    case_id: 'test-case-id',
+    title: 'Test Case',
+    summary: 'Test case summary',
+    items: [],
+    ...overrides
+});
 // Helper function to create mock dossiers
 export const createMockDossier = (overrides) => ({
     dossier_id: 'test-dossier-id',

package/utils/Throttler.test.js

@@ -97,7 +97,7 @@ describe('Throttler', () => {
         it('does not invoke fn before the delay', async () => {
             const fn = vi.fn().mockResolvedValue('x');
             const t = new Throttler(100);
-            t.delayAsync(fn);
+            void t.delayAsync(fn);
             expect(fn).not.toHaveBeenCalled();
         });
         it('resolves with the return value of fn', async () => {
@@ -124,7 +124,7 @@ describe('Throttler', () => {
         it('cancels the previous pending call when invoked again', async () => {
             const fn = vi.fn().mockResolvedValue(42);
             const t = new Throttler(100);
-            t.delayAsync(fn);
+            void t.delayAsync(fn);
             vi.advanceTimersByTime(50);
             const second = t.delayAsync(fn);
             vi.advanceTimersByTime(100);

package/utils/actionUtils.d.ts

@@ -14,18 +14,18 @@ export declare const checkArgsAreFilled: (step: ActionOperationStep, values: str
  * @param context The values provided so far by the user
  * @returns a list of options matching the current context
  */
-export declare const getOptionsByContext: (options: ActionOperationStep["options"], arg: string, context: string) => string[];
+export declare const getOptionsByContext: (options: ActionOperationStep['options'], arg: string, context: string) => string[];
 /**
  * Get a list of arguments to display based on the current context, using the current values supplied for the action entry.
  * @param args a complete list of all arguments in the action
  * @param values the current list of values provided by the user
  * @returns A list of arguments to display
  */
-export declare const getArgsByContext: (args: ActionOperationStep["args"], values: string) => string[];
+export declare const getArgsByContext: (args: ActionOperationStep['args'], values: string) => string[];
 /**
  * Check to see if a given action has all the data necessary to execute successfully
  * @param data The user-provided data
  * @param action The action to validate
  * @returns whether the action is ready to execute
  */
-export declare const operationReady: (data: Operation["data_json"], action: ActionOperation) => boolean;
+export declare const operationReady: (data: Operation['data_json'], action: ActionOperation) => boolean;

package/utils/classificationParser.d.ts

@@ -0,0 +1,195 @@
+/**
+ * Classification related utils.
+ *
+ * WARNING:
+ * Actual classification enforcement is handled server side. These utils are convenience functions mostly used for
+ * display purposes. They and are not expected to be used for critical access control enforcement. As such, error
+ * conditions are not raised and suitable default values are returned.
+ *
+ */
+export type FormatProp = 'long' | 'short';
+type LevelStylesheet = {
+    banner?: string;
+    label?: string;
+    text?: string;
+    color?: string;
+};
+type ClassificationLevel = {
+    aliases: string[];
+    css: LevelStylesheet;
+    description: string;
+    lvl: number;
+    name: string;
+    short_name: string;
+    is_hidden?: boolean;
+};
+type ClassificationRequired = {
+    aliases: string[];
+    description: string;
+    name: string;
+    is_required_group?: boolean;
+    require_lvl?: number;
+    short_name: string;
+    is_hidden?: boolean;
+};
+type ClassificationGroup = {
+    aliases: string[];
+    auto_select?: boolean;
+    description: string;
+    name: string;
+    short_name: string;
+    solitary_display_name?: string;
+    is_hidden?: boolean;
+};
+type ClassificationSubGroup = {
+    aliases: string[];
+    auto_select?: boolean;
+    description: string;
+    limited_to_group?: string;
+    name: string;
+    require_group?: string;
+    short_name: string;
+    solitary_display_name?: string;
+    is_hidden?: boolean;
+};
+type ClassificationYAMLDefinition = {
+    dynamic_groups: boolean;
+    dynamic_groups_type: string;
+    enforce: boolean;
+    groups: ClassificationGroup[];
+    levels: ClassificationLevel[];
+    required: ClassificationRequired[];
+    restricted: string;
+    subgroups: ClassificationSubGroup[];
+    unrestricted: string;
+};
+type StringMap = {
+    [propName: string]: string;
+};
+type StringMapArray = {
+    [propName: string]: string[];
+};
+type StylesheetMap = {
+    [propName: string]: LevelStylesheet;
+};
+type ParamsMap = {
+    [propName: string]: {
+        is_required_group?: boolean;
+        solitary_display_name?: string;
+        require_lvl?: number;
+        require_group?: string;
+        limited_to_group?: string;
+        is_hidden?: boolean;
+    };
+};
+export type ClassificationDefinition = {
+    RESTRICTED: string;
+    UNRESTRICTED: string;
+    access_req_aliases: StringMapArray;
+    access_req_map_lts: StringMap;
+    access_req_map_stl: StringMap;
+    description: StringMap;
+    dynamic_groups: boolean;
+    dynamic_groups_type: 'email' | 'group' | 'all';
+    enforce: boolean;
+    groups_aliases: StringMapArray;
+    groups_auto_select: string[];
+    groups_auto_select_short: string[];
+    groups_map_lts: StringMap;
+    groups_map_stl: StringMap;
+    invalid_mode: boolean;
+    levels_aliases: StringMap;
+    levels_map: StringMap;
+    levels_map_lts: StringMap;
+    levels_map_stl: StringMap;
+    levels_styles_map: StylesheetMap;
+    original_definition: ClassificationYAMLDefinition;
+    params_map: ParamsMap;
+    subgroups_aliases: StringMapArray;
+    subgroups_auto_select: string[];
+    subgroups_auto_select_short: string[];
+    subgroups_map_lts: StringMap;
+    subgroups_map_stl: StringMap;
+};
+export type ClassificationParts = {
+    lvlIdx: number;
+    lvl: string;
+    req: string[];
+    groups: string[];
+    subgroups: string[];
+};
+export declare const defaultParts: ClassificationParts;
+type DisabledControls = {
+    levels: string[];
+    groups: string[];
+};
+export declare const defaultDisabled: DisabledControls;
+export declare class InvalidClassification extends Error {
+}
+export declare const getLevelText: (lvl: number, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean) => string;
+export declare const getParts: (c12n: string, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean) => ClassificationParts;
+export declare const canSeeRequired: (user_req: string[], req: string[]) => boolean;
+export declare const canSeeGroups: (user_groups: string[], groups: string[]) => boolean;
+/**
+ * Normalize a given classification by applying the rules defined in the classification definition.
+ * This function will remove any invalid parts and add missing parts to the classification.
+ * It will also ensure that the display of the classification is always done the same way
+ *
+ * Note: This function mutates the passed in `parts` parameter.
+ *
+ * @param parts - `ClassificationParts` object containing the parsed classification components
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param format - return results in `long` or `short` format
+ * @param isMobile - `true`/`false` if the results should be returned for display on a mobile device
+ * @param skipAutoSelect - `true`/`false` skip auto selecting required groups
+ *
+ * @returns A normalized version of the original classification
+ *
+ */
+export declare const normalizedClassification: (parts: ClassificationParts, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean, skipAutoSelect?: boolean) => string;
+type ClassificationValidator = {
+    disabled: DisabledControls;
+    parts: ClassificationParts;
+};
+export declare const defaultClassificationValidator: ClassificationValidator;
+/**
+ * Applies the Level, Require and Group rules and returns valid and invalid options based on the given input
+ *
+ * @param parts - `ClassificationParts` object containing the parsed classification components
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param format - return results in `long` or `short` format
+ * @param isMobile - `true`/`false` if the results should be returned for display on a mobile device
+ * @param userClassification - `true`/`false` if to apply `auto select` based on the user
+ *
+ * @returns The most restrictive classification that we could create out of the two
+ *
+ */
+export declare const applyClassificationRules: (parts: ClassificationParts, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean, userClassification?: boolean) => ClassificationValidator;
+/**
+ * Mixes two classifications and returns to most restrictive form for them
+ *
+ * @param c12n_1 - First classification
+ * @param c12n_2 - Second classification
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param format - return results in `long` or `short` format
+ * @param isMobile - `true`/`false` if the results should be returned for display on a mobile device
+ *
+ * @returns The most restrictive classification that we could create out of the two
+ *
+ */
+export declare const getMaxClassification: (c12n_1: string, c12n_2: string, c12nDef: ClassificationDefinition, format: FormatProp, isMobile: boolean) => string;
+/**
+ *
+ * Given a user classification, check if a user is allow to see a certain classification
+ *
+ * @param user_c12n - Maximum classification for the user
+ * @param c12n - Classification the user wishes to see
+ * @param c12nDef - ClassificationDefinition returned by the API server
+ * @param enforce - `true`/`false` if access controls are enabled
+ * @param ignoreInvalid - `true`/`false` if invalid classifications should raise errors or just deny access
+ *
+ * @returns True is the user can see the classification
+ *
+ */
+export declare const isAccessible: (user_c12n: string, c12n: string, c12nDef: ClassificationDefinition, enforce?: boolean, ignoreInvalid?: boolean) => boolean;
+export {};