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

package/utils/classificationParser.test.js

@@ -0,0 +1,199 @@
+/// <reference types="vitest" />
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { applyClassificationRules, canSeeGroups, canSeeRequired, defaultClassificationValidator, defaultDisabled, defaultParts, getLevelText, getMaxClassification, getParts, isAccessible, normalizedClassification } from './classificationParser';
+const classificationDefinition = {
+    RESTRICTED: 'S//REL TO CAN',
+    UNRESTRICTED: 'U',
+    access_req_aliases: {
+        CEO: ['CEO'],
+        OC: ['ORCON'],
+        ORCON: ['ORCON']
+    },
+    access_req_map_lts: {
+        'CANADIAN EYES ONLY': 'CEO',
+        'ORIGINATOR CONTROLLED': 'ORCON'
+    },
+    access_req_map_stl: {
+        CEO: 'CANADIAN EYES ONLY',
+        ORCON: 'ORIGINATOR CONTROLLED'
+    },
+    description: {},
+    dynamic_groups: false,
+    dynamic_groups_type: 'group',
+    enforce: true,
+    groups_aliases: {
+        'CANADA ONLY': ['CAN'],
+        FVEY: ['CAN', 'USA']
+    },
+    groups_auto_select: ['FVEY'],
+    groups_auto_select_short: ['FVEY'],
+    groups_map_lts: {
+        CANADA: 'CAN',
+        'FIVE EYES': 'FVEY',
+        'UNITED STATES': 'USA'
+    },
+    groups_map_stl: {
+        CAN: 'CANADA',
+        FVEY: 'FIVE EYES',
+        USA: 'UNITED STATES'
+    },
+    invalid_mode: false,
+    levels_aliases: {
+        PUBLIC: 'U'
+    },
+    levels_map: {
+        '0': 'U',
+        '1': 'C',
+        '2': 'S',
+        C: '1',
+        S: '2',
+        U: '0'
+    },
+    levels_map_lts: {
+        CONFIDENTIAL: 'C',
+        SECRET: 'S',
+        UNCLASSIFIED: 'U'
+    },
+    levels_map_stl: {
+        C: 'CONFIDENTIAL',
+        S: 'SECRET',
+        U: 'UNCLASSIFIED'
+    },
+    levels_styles_map: {},
+    original_definition: {
+        dynamic_groups: false,
+        dynamic_groups_type: 'group',
+        enforce: true,
+        groups: [],
+        levels: [],
+        required: [],
+        restricted: 'S//REL TO CAN',
+        subgroups: [],
+        unrestricted: 'U'
+    },
+    params_map: {
+        ALPHA: {
+            require_group: 'CAN'
+        },
+        BRAVO: {
+            limited_to_group: 'USA'
+        },
+        CAN: {
+            solitary_display_name: 'CANADA ONLY'
+        },
+        CEO: {
+            is_required_group: true,
+            require_lvl: 2
+        }
+    },
+    subgroups_aliases: {
+        ALPHA: ['ALPHA'],
+        BRAVO: ['BRAVO']
+    },
+    subgroups_auto_select: ['ALPHA TEAM'],
+    subgroups_auto_select_short: ['ALPHA'],
+    subgroups_map_lts: {
+        'ALPHA TEAM': 'ALPHA',
+        'BRAVO TEAM': 'BRAVO'
+    },
+    subgroups_map_stl: {
+        ALPHA: 'ALPHA TEAM',
+        BRAVO: 'BRAVO TEAM'
+    }
+};
+const cloneParts = (parts) => ({
+    lvlIdx: parts.lvlIdx,
+    lvl: parts.lvl,
+    req: [...parts.req],
+    groups: [...parts.groups],
+    subgroups: [...parts.subgroups]
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('classificationParser', () => {
+    it('exposes stable empty defaults for parser state', () => {
+        expect(defaultParts).toEqual({ lvlIdx: 0, lvl: '', req: [], groups: [], subgroups: [] });
+        expect(defaultDisabled).toEqual({ groups: [], levels: [] });
+        expect(defaultClassificationValidator).toEqual({ disabled: defaultDisabled, parts: defaultParts });
+    });
+    it('returns the short or long level label and reports unknown levels', () => {
+        const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        expect(getLevelText(1, classificationDefinition, 'short', false)).toBe('C');
+        expect(getLevelText(1, classificationDefinition, 'long', false)).toBe('CONFIDENTIAL');
+        expect(getLevelText(99, classificationDefinition, 'short', false)).toBe('INVALID');
+        expect(errorSpy).toHaveBeenCalledWith("[classificationParser] Classification level number '99' was not found in your classification definition.");
+    });
+    it('parses levels, required markings, groups, and subgroups from short classifications', () => {
+        const parts = getParts('C//OC/REL TO CAN, USA/ALPHA', classificationDefinition, 'short', false);
+        expect(parts).toEqual({
+            lvlIdx: 1,
+            lvl: 'C',
+            req: ['ORCON'],
+            groups: ['CAN', 'USA'],
+            subgroups: ['ALPHA']
+        });
+    });
+    it('parses long-form classifications into long-form display values', () => {
+        const parts = getParts('CONFIDENTIAL//ORIGINATOR CONTROLLED/REL TO CANADA/ALPHA TEAM', classificationDefinition, 'long', false);
+        expect(parts).toEqual({
+            lvlIdx: 1,
+            lvl: 'CONFIDENTIAL',
+            req: ['ORIGINATOR CONTROLLED'],
+            groups: ['CANADA'],
+            subgroups: ['ALPHA TEAM']
+        });
+    });
+    it('checks required and group access using set semantics', () => {
+        expect(canSeeRequired(['ORCON', 'CEO'], ['ORCON'])).toBe(true);
+        expect(canSeeRequired(['ORCON'], ['ORCON', 'CEO'])).toBe(false);
+        expect(canSeeGroups(['CAN', 'USA'], ['USA'])).toBe(true);
+        expect(canSeeGroups(['CAN'], ['USA'])).toBe(false);
+    });
+    it('normalizes classifications with level escalation, solitary group names, and required groups', () => {
+        const normalized = normalizedClassification(cloneParts({
+            lvlIdx: 1,
+            lvl: 'C',
+            req: ['CEO'],
+            groups: [],
+            subgroups: ['ALPHA']
+        }), classificationDefinition, 'short', false, true);
+        expect(normalized).toBe('S//CEO/CANADA ONLY/ALPHA');
+    });
+    it('returns the unrestricted label when enforcement is disabled or invalid mode is active', () => {
+        expect(normalizedClassification(cloneParts(defaultParts), { ...classificationDefinition, enforce: false }, 'short', false)).toBe('U');
+        expect(normalizedClassification(cloneParts(defaultParts), { ...classificationDefinition, invalid_mode: true }, 'short', false)).toBe('U');
+    });
+    it('applies classification rules to raise levels, add required groups, and disable incompatible options', () => {
+        const result = applyClassificationRules(cloneParts({
+            lvlIdx: 0,
+            lvl: 'U',
+            req: ['CEO'],
+            groups: ['CAN', 'USA'],
+            subgroups: ['BRAVO']
+        }), classificationDefinition, 'long', false);
+        expect(result.parts.lvlIdx).toBe(2);
+        expect(result.parts.lvl).toBe('SECRET');
+        expect(result.parts.req).toEqual(['CANADIAN EYES ONLY']);
+        expect(result.parts.groups).toEqual(['UNITED STATES']);
+        expect(result.parts.subgroups).toEqual(['BRAVO TEAM']);
+        expect(result.disabled.levels).toEqual(['CONFIDENTIAL', 'UNCLASSIFIED']);
+        expect(result.disabled.groups).toContain('CANADA');
+        expect(result.disabled.groups).toContain('FIVE EYES');
+    });
+    it('returns the most restrictive classification across two inputs', () => {
+        const output = getMaxClassification('C//ORCON/REL TO CAN/ALPHA', 'S//REL TO CAN', classificationDefinition, 'short', false);
+        expect(output).toBe('S//ORCON//REL CAN, FVEY/ALPHA');
+    });
+    it('falls back to unrestricted max classification when enforcement is disabled', () => {
+        expect(getMaxClassification('C//REL TO CAN', 'S//REL TO USA', { ...classificationDefinition, enforce: false }, 'short', false)).toBe('U');
+    });
+    it('checks accessibility using level, required, group, and subgroup restrictions', () => {
+        expect(isAccessible('S//ORCON/REL TO CAN/ALPHA', 'C//ORCON/REL TO CAN/ALPHA', classificationDefinition, true)).toBe(true);
+        expect(isAccessible('C//REL TO CAN', 'S//REL TO CAN', classificationDefinition, true)).toBe(false);
+        expect(isAccessible('S//REL TO USA', 'S//REL TO CAN', classificationDefinition, true)).toBe(false);
+        expect(isAccessible('C//REL TO CAN', 'S//REL TO CAN', classificationDefinition, false)).toBe(true);
+        expect(isAccessible('S//REL TO CAN', '', classificationDefinition, true)).toBe(true);
+        expect(isAccessible('S//REL TO CAN', 'C//REL TO CAN', { ...classificationDefinition, invalid_mode: true }, true)).toBe(false);
+    });
+});

package/utils/constants.test.d.ts

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

package/utils/constants.test.js

@@ -0,0 +1,62 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const loadConstants = async (isoDate = '2024-01-02T03:15:00Z') => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(isoDate));
+    vi.resetModules();
+    return import('./constants');
+};
+afterEach(() => {
+    vi.useRealTimers();
+    vi.resetModules();
+});
+describe('constants', () => {
+    it('builds prefixed storage keys for mock stores', async () => {
+        const { MOCK_FAVOURITES_STORE, MOCK_SEARCH_QUERY_STORE, MY_LOCAL_STORAGE_PREFIX, StorageKey } = await loadConstants();
+        expect(MOCK_SEARCH_QUERY_STORE).toBe(`${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.MOCK_SEARCH_QUERY_STORE}`);
+        expect(MOCK_FAVOURITES_STORE).toBe(`${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.MOCK_FAVOURITES_STORE}`);
+    });
+    it('keeps storage key values stable for persisted UI state', async () => {
+        const { StorageKey } = await loadConstants();
+        expect(StorageKey.APP_TOKEN).toBe('app_token');
+        expect(StorageKey.ETAG).toBe('etag');
+        expect(StorageKey.LOGIN_NONCE).toBe('login_nonce');
+        expect(StorageKey.DISPLAY_TYPE).toBe('display_type');
+    });
+    it('computes the staggered rule intervals from the current time', async () => {
+        const { RULE_INTERVALS, hours, minutes } = await loadConstants();
+        expect(minutes).toEqual([15, 45]);
+        expect(hours).toEqual([0, 3, 6, 9, 12, 15, 18, 21]);
+        expect(RULE_INTERVALS).toEqual([
+            { key: 'rule.interval.thirty.minutes', crontab: '15,45 * * * *' },
+            { key: 'rule.interval.one.hour', crontab: '15 * * * *' },
+            { key: 'rule.interval.three.hours', crontab: '15 0,3,6,9,12,15,18,21 * * *' },
+            { key: 'rule.interval.six.hours', crontab: '15 3,9,15,21 * * *' },
+            { key: 'rule.interval.one.day', crontab: '15 3 * * *' }
+        ]);
+    });
+    it('exports the supported date range presets and Lucene mappings', async () => {
+        const { DATE_RANGES, DATE_RANGE_LUCENE } = await loadConstants();
+        expect(DATE_RANGES).toEqual([
+            'date.range.1.day',
+            'date.range.3.day',
+            'date.range.1.week',
+            'date.range.1.month',
+            'date.range.all',
+            'date.range.custom'
+        ]);
+        expect(DATE_RANGE_LUCENE).toEqual({
+            'date.range.1.day': 'now-1d/d',
+            'date.range.3.day': 'now-3d/d',
+            'date.range.1.week': 'now-7d/d',
+            'date.range.1.month': 'now-1M/M'
+        });
+    });
+    it('exposes configured label metadata for known label types', async () => {
+        const { LABEL_TYPES, VALID_ACTION_TRIGGERS, DEFAULT_QUERY } = await loadConstants();
+        expect(VALID_ACTION_TRIGGERS).toEqual(['create', 'promote', 'demote']);
+        expect(DEFAULT_QUERY).toBe('howler.id:*');
+        expect(LABEL_TYPES.insight.icon.props.fontSize).toBe('small');
+        expect(LABEL_TYPES.operation.color).toBeDefined();
+        expect(LABEL_TYPES.generic).toEqual({});
+    });
+});

package/utils/typeUtils.test.d.ts

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

package/utils/typeUtils.test.js

@@ -0,0 +1,22 @@
+/// <reference types="vitest" />
+import { describe, expect, it } from 'vitest';
+import { isCase, isEvent, isHit } from './typeUtils';
+describe('typeUtils', () => {
+    it('identifies hits by __index', () => {
+        expect(isHit({ __index: 'hit' })).toBe(true);
+        expect(isHit({ __index: 'event' })).toBe(false);
+    });
+    it('identifies cases by __index', () => {
+        expect(isCase({ __index: 'case' })).toBe(true);
+        expect(isCase({ __index: 'hit' })).toBe(false);
+    });
+    it('identifies events by __index', () => {
+        expect(isEvent({ __index: 'event' })).toBe(true);
+        expect(isEvent({ __index: 'case' })).toBe(false);
+    });
+    it('returns false for nullish values and objects without an index', () => {
+        expect(isHit(null)).toBe(false);
+        expect(isCase(undefined)).toBe(false);
+        expect(isEvent({})).toBe(false);
+    });
+});