@cccsaurora/howler-ui 2.19.0-cases.863 → 2.19.0-dev.1000

package/tests/server-handlers.js

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

package/tests/utils.d.ts

@@ -1,20 +1,16 @@
 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 { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
-import type { Observable } from '@cccsaurora/howler-ui/models/entities/generated/Observable';
 import type { Template } from '@cccsaurora/howler-ui/models/entities/generated/Template';
 import type { View } from '@cccsaurora/howler-ui/models/entities/generated/View';
 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 createMockObservable: (overrides?: RecursivePartial<Observable>) => Observable;
 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,7 +1,5 @@
 // Mock data factories
 export const createMockHit = (overrides) => ({
-    ...overrides,
-    __index: 'hit',
     howler: {
         id: 'test-hit-1',
         analytic: 'test-analytic',
@@ -16,17 +14,6 @@ export const createMockHit = (overrides) => ({
         ...overrides?.event
     }
 });
-export const createMockObservable = (overrides) => ({
-    ...overrides,
-    __index: 'observable',
-    howler: {
-        id: 'test-observable-1',
-        analytic: 'test-analytic',
-        detection: 'Test Detection',
-        hash: '',
-        ...overrides?.howler
-    }
-});
 export const createMockAnalytic = (overrides) => ({
     analytic_id: 'test-analytic-id',
     name: 'test-analytic',
@@ -65,13 +52,6 @@ export const createMockView = (overrides) => ({
     },
     ...overrides
 });
-export const createMockCase = (overrides) => ({
-    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.d.ts

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

package/utils/Throttler.test.js

@@ -0,0 +1,135 @@
+/// <reference types="vitest" />
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import Throttler from './Throttler';
+describe('Throttler', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    // -------------------------------------------------------------------------
+    // throttle
+    // -------------------------------------------------------------------------
+    describe('throttle', () => {
+        it('calls fn immediately on the first invocation', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('suppresses subsequent calls within the throttle window', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.throttle(fn);
+            t.throttle(fn);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('allows another call after the throttle interval expires', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.throttle(fn);
+            vi.advanceTimersByTime(150);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+        it('does not fire a second call if the interval has not yet elapsed', () => {
+            const fn = vi.fn();
+            const t = new Throttler(200);
+            t.throttle(fn);
+            vi.advanceTimersByTime(100);
+            t.throttle(fn);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // debounce
+    // -------------------------------------------------------------------------
+    describe('debounce', () => {
+        it('does not call fn immediately', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            expect(fn).not.toHaveBeenCalled();
+        });
+        it('calls fn after the delay elapses', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            vi.advanceTimersByTime(100);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('resets the delay when called again before it fires', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            vi.advanceTimersByTime(80);
+            t.debounce(fn);
+            vi.advanceTimersByTime(80);
+            expect(fn).not.toHaveBeenCalled();
+            vi.advanceTimersByTime(30);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('calls fn only once after many rapid invocations', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            for (let i = 0; i < 10; i++) {
+                t.debounce(fn);
+            }
+            vi.advanceTimersByTime(200);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+        it('fires a second call correctly after the first has resolved', () => {
+            const fn = vi.fn();
+            const t = new Throttler(100);
+            t.debounce(fn);
+            vi.advanceTimersByTime(150);
+            t.debounce(fn);
+            vi.advanceTimersByTime(150);
+            expect(fn).toHaveBeenCalledTimes(2);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // delayAsync
+    // -------------------------------------------------------------------------
+    describe('delayAsync', () => {
+        it('does not invoke fn before the delay', async () => {
+            const fn = vi.fn().mockResolvedValue('x');
+            const t = new Throttler(100);
+            t.delayAsync(fn);
+            expect(fn).not.toHaveBeenCalled();
+        });
+        it('resolves with the return value of fn', async () => {
+            const fn = vi.fn().mockResolvedValue('result');
+            const t = new Throttler(100);
+            const promise = t.delayAsync(fn);
+            vi.advanceTimersByTime(100);
+            await expect(promise).resolves.toBe('result');
+        });
+        it('passes variadic arguments through to fn', async () => {
+            const fn = vi.fn().mockImplementation(async (a, b) => a + b);
+            const t = new Throttler(100);
+            const promise = t.delayAsync(fn, 3, 4);
+            vi.advanceTimersByTime(100);
+            await expect(promise).resolves.toBe(7);
+        });
+        it('rejects when fn throws', async () => {
+            const fn = vi.fn().mockRejectedValue(new Error('boom'));
+            const t = new Throttler(100);
+            const promise = t.delayAsync(fn);
+            vi.advanceTimersByTime(100);
+            await expect(promise).rejects.toThrow('boom');
+        });
+        it('cancels the previous pending call when invoked again', async () => {
+            const fn = vi.fn().mockResolvedValue(42);
+            const t = new Throttler(100);
+            t.delayAsync(fn);
+            vi.advanceTimersByTime(50);
+            const second = t.delayAsync(fn);
+            vi.advanceTimersByTime(100);
+            await expect(second).resolves.toBe(42);
+            expect(fn).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/utils/actionUtils.test.d.ts

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

package/utils/actionUtils.test.js

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+import { checkArgsAreFilled, getArgsByContext, getOptionsByContext, operationReady } from './actionUtils';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const makeStep = (args, options = {}) => ({
+    args,
+    options,
+    validation: {}
+});
+const makeAction = (steps) => ({
+    id: 'test-action',
+    title: 'Test Action',
+    i18nKey: 'test.action',
+    description: { short: '', long: '' },
+    roles: [],
+    steps,
+    triggers: []
+});
+// ---------------------------------------------------------------------------
+// checkArgsAreFilled
+// ---------------------------------------------------------------------------
+describe('checkArgsAreFilled', () => {
+    it('returns false when values is empty/falsy', () => {
+        const step = makeStep({ status: [] });
+        expect(checkArgsAreFilled(step, '')).toBe(false);
+    });
+    it('returns true when all required args are present and truthy', () => {
+        const step = makeStep({ status: [] });
+        expect(checkArgsAreFilled(step, JSON.stringify({ status: 'open' }))).toBe(true);
+    });
+    it('returns false when a required arg is missing from values', () => {
+        const step = makeStep({ status: [], assignment: [] });
+        expect(checkArgsAreFilled(step, JSON.stringify({ status: 'open' }))).toBe(false);
+    });
+    it('returns false when a required arg is present but falsy (empty string)', () => {
+        const step = makeStep({ status: [] });
+        expect(checkArgsAreFilled(step, JSON.stringify({ status: '' }))).toBe(false);
+    });
+    it('returns true when there are no required args', () => {
+        const step = makeStep({});
+        expect(checkArgsAreFilled(step, JSON.stringify({}))).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// getOptionsByContext
+// ---------------------------------------------------------------------------
+describe('getOptionsByContext', () => {
+    it('returns an empty array when the arg is not in options', () => {
+        const options = {};
+        expect(getOptionsByContext(options, 'status', '{}')).toEqual([]);
+    });
+    it('returns the full list when the arg maps to a plain array', () => {
+        const options = { status: ['open', 'in-progress', 'resolved'] };
+        expect(getOptionsByContext(options, 'status', '{}')).toEqual(['open', 'in-progress', 'resolved']);
+    });
+    it('returns options matching the current context when arg has conditional options', () => {
+        const options = {
+            assessment: {
+                'status:open': ['false_positive', 'legitimate'],
+                'status:resolved': ['correct']
+            }
+        };
+        const context = JSON.stringify({ status: 'open' });
+        expect(getOptionsByContext(options, 'assessment', context)).toEqual(['false_positive', 'legitimate']);
+    });
+    it('returns an empty array when context does not match any conditional key', () => {
+        const options = {
+            assessment: {
+                'status:open': ['false_positive']
+            }
+        };
+        const context = JSON.stringify({ status: 'resolved' });
+        expect(getOptionsByContext(options, 'assessment', context)).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// getArgsByContext
+// ---------------------------------------------------------------------------
+describe('getArgsByContext', () => {
+    it('always returns an arg with an empty conditions array', () => {
+        const args = { status: [] };
+        expect(getArgsByContext(args, '{}')).toContain('status');
+    });
+    it('includes an arg whose condition matches the current context', () => {
+        const args = { assessment: ['status:open'] };
+        const values = JSON.stringify({ status: 'open' });
+        expect(getArgsByContext(args, values)).toContain('assessment');
+    });
+    it('excludes an arg whose condition does not match the current context', () => {
+        const args = { assessment: ['status:open'] };
+        const values = JSON.stringify({ status: 'resolved' });
+        expect(getArgsByContext(args, values)).not.toContain('assessment');
+    });
+    it('includes an arg when any one of multiple conditions matches (OR logic)', () => {
+        const args = { rationale: ['status:open', 'status:in-progress'] };
+        const values = JSON.stringify({ status: 'in-progress' });
+        expect(getArgsByContext(args, values)).toContain('rationale');
+    });
+    it('returns an empty array when no args match', () => {
+        const args = { assessment: ['status:open'] };
+        const values = JSON.stringify({ status: 'resolved' });
+        expect(getArgsByContext(args, values)).toEqual([]);
+    });
+});
+// ---------------------------------------------------------------------------
+// operationReady
+// ---------------------------------------------------------------------------
+describe('operationReady', () => {
+    it('returns false when data is null/falsy', () => {
+        const action = makeAction([makeStep({ status: [] })]);
+        expect(operationReady(null, action)).toBe(false);
+    });
+    it('returns falsy when action is falsy', () => {
+        expect(operationReady(JSON.stringify({ status: 'open' }), null)).toBeFalsy();
+    });
+    it('returns true when all unconditional args are present', () => {
+        const action = makeAction([makeStep({ status: [] })]);
+        const data = JSON.stringify({ status: 'open' });
+        expect(operationReady(data, action)).toBe(true);
+    });
+    it('returns false when a required unconditional arg is missing', () => {
+        const action = makeAction([makeStep({ status: [], assessment: [] })]);
+        const data = JSON.stringify({ status: 'open' });
+        expect(operationReady(data, action)).toBe(false);
+    });
+    it('ignores conditional args that do not apply in the current context', () => {
+        // assessment only required when status=open; here status=resolved so assessment is not required
+        const action = makeAction([makeStep({ status: [], assessment: ['status:open'] })]);
+        const data = JSON.stringify({ status: 'resolved' });
+        expect(operationReady(data, action)).toBe(true);
+    });
+    it('merges args across multiple steps', () => {
+        const step1 = makeStep({ status: [] });
+        const step2 = makeStep({ assignment: [] });
+        const action = makeAction([step1, step2]);
+        const data = JSON.stringify({ status: 'open', assignment: 'alice' });
+        expect(operationReady(data, action)).toBe(true);
+    });
+});

package/utils/constants.d.ts

@@ -5,9 +5,9 @@ export declare const VERSION: any;
 export declare const MY_LOCAL_STORAGE_PREFIX = "howler.ui";
 export declare const MY_SESSION_STORAGE_PREFIX = "howler.ui.cache";
 export declare const ESCALATION_COLORS: {
-    alert: "warning";
-    evidence: "error";
-    hit: "primary";
+    alert: string;
+    evidence: string;
+    hit: string;
 };
 export declare const STATUS_COLORS: {
     open: string;
@@ -49,6 +49,7 @@ export declare enum StorageKey {
     COMPACT_JSON = "compact_json_view",
     FLATTEN_JSON = "flatten_json_view",
     FORCE_DRAWER = "force_drawer",
+    SHOW_HIT_SUMMARY_GRAPH = "show_hit_summary_graph",
     LAST_VIEW = "last_view",
     ONLY_RULES = "only_rules",
     PAGE_COUNT = "page_count",
@@ -74,7 +75,6 @@ export declare const RULE_INTERVALS: {
     crontab: string;
 }[];
 export declare const DATE_RANGES: string[];
-export declare const DATE_RANGE_LUCENE: Partial<Record<(typeof DATE_RANGES)[number], string>>;
 interface LabelData {
     icon?: ReactElement;
     color?: string;

package/utils/constants.js

@@ -54,6 +54,7 @@ export var StorageKey;
     StorageKey["COMPACT_JSON"] = "compact_json_view";
     StorageKey["FLATTEN_JSON"] = "flatten_json_view";
     StorageKey["FORCE_DRAWER"] = "force_drawer";
+    StorageKey["SHOW_HIT_SUMMARY_GRAPH"] = "show_hit_summary_graph";
     StorageKey["LAST_VIEW"] = "last_view";
     StorageKey["ONLY_RULES"] = "only_rules";
     StorageKey["PAGE_COUNT"] = "page_count";
@@ -104,12 +105,6 @@ export const DATE_RANGES = [
     'date.range.all',
     'date.range.custom'
 ];
-export const DATE_RANGE_LUCENE = {
-    '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'
-};
 export const LABEL_TYPES = {
     insight: { icon: _jsx(PsychologyAlt, { fontSize: "small" }), color: '#FFFFFF' }, //brain icon
     mitigation: { icon: _jsx(LocalPolice, { fontSize: "small" }), color: blue[600] }, //police badge

package/utils/hitFunctions.d.ts

@@ -1,3 +1,2 @@
 import type { Hit } from '@cccsaurora/howler-ui/models/entities/generated/Hit';
-import type { Observable } from '@cccsaurora/howler-ui/models/entities/generated/Observable';
-export declare const getUserList: (record: Hit | Observable) => Set<string>;
+export declare const getUserList: (hit: Hit) => Set<string>;

package/utils/hitFunctions.js

@@ -1,8 +1,8 @@
-export const getUserList = (record) => {
+export const getUserList = (hit) => {
     const ids = new Set();
-    if (record) {
-        record.howler?.log?.forEach(l => ids.add(l.user));
-        record.howler?.comment?.forEach(c => ids.add(c.user), ids);
+    if (hit) {
+        hit.howler?.log?.forEach(l => ids.add(l.user));
+        hit.howler?.comment?.forEach(c => ids.add(c.user), ids);
     }
     return ids;
 };

package/utils/hitFunctions.test.d.ts

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

package/utils/hitFunctions.test.js

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { getUserList } from './hitFunctions';
+const makeHit = (howlerOverrides = {}) => ({
+    howler: {
+        log: [],
+        comment: [],
+        ...howlerOverrides
+    }
+});
+describe('getUserList', () => {
+    it('returns an empty Set when the hit is null', () => {
+        expect(getUserList(null)).toEqual(new Set());
+    });
+    it('returns an empty Set when the hit is undefined', () => {
+        expect(getUserList(undefined)).toEqual(new Set());
+    });
+    it('returns an empty Set when both log and comment are empty', () => {
+        expect(getUserList(makeHit())).toEqual(new Set());
+    });
+    it('collects users from the log array', () => {
+        const hit = makeHit({ log: [{ user: 'alice' }, { user: 'bob' }] });
+        expect(getUserList(hit)).toEqual(new Set(['alice', 'bob']));
+    });
+    it('collects users from the comment array', () => {
+        const hit = makeHit({ comment: [{ user: 'carol' }] });
+        expect(getUserList(hit)).toEqual(new Set(['carol']));
+    });
+    it('collects users from both log and comment', () => {
+        const hit = makeHit({
+            log: [{ user: 'alice' }],
+            comment: [{ user: 'bob' }]
+        });
+        expect(getUserList(hit)).toEqual(new Set(['alice', 'bob']));
+    });
+    it('deduplicates users that appear in both arrays', () => {
+        const hit = makeHit({
+            log: [{ user: 'alice' }],
+            comment: [{ user: 'alice' }]
+        });
+        const result = getUserList(hit);
+        expect(result).toEqual(new Set(['alice']));
+        expect(result.size).toBe(1);
+    });
+    it('deduplicates users that appear multiple times in the same array', () => {
+        const hit = makeHit({ log: [{ user: 'alice' }, { user: 'alice' }] });
+        expect(getUserList(hit).size).toBe(1);
+    });
+    it('handles a hit with no howler field gracefully', () => {
+        const hit = {};
+        expect(getUserList(hit)).toEqual(new Set());
+    });
+});

package/utils/localStorage.test.d.ts

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

package/utils/localStorage.test.js

@@ -0,0 +1,96 @@
+/// <reference types="vitest" />
+import { afterEach, describe, expect, it } from 'vitest';
+import { StorageKey } from './constants';
+import { getStored, removeStored, saveLoginCredential, setStored } from './localStorage';
+const PREFIX = 'howler.ui';
+describe('localStorage utilities', () => {
+    afterEach(() => {
+        localStorage.clear();
+    });
+    // -------------------------------------------------------------------------
+    // setStored / getStored
+    // -------------------------------------------------------------------------
+    describe('setStored / getStored', () => {
+        it('stores and retrieves a string value', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            expect(getStored(StorageKey.USERNAME)).toBe('alice');
+        });
+        it('stores and retrieves an object value', () => {
+            const value = { token: 'abc', expires: 123 };
+            setStored(StorageKey.APP_TOKEN, value);
+            expect(getStored(StorageKey.APP_TOKEN)).toEqual(value);
+        });
+        it('uses the prefixed key in the underlying localStorage', () => {
+            setStored(StorageKey.USERNAME, 'bob');
+            expect(localStorage.getItem(`${PREFIX}.${StorageKey.USERNAME}`)).toBe(JSON.stringify('bob'));
+        });
+        it('returns null for a key that has not been set', () => {
+            expect(getStored(StorageKey.USERNAME)).toBeNull();
+        });
+        it('overwrites an existing value', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            setStored(StorageKey.USERNAME, 'bob');
+            expect(getStored(StorageKey.USERNAME)).toBe('bob');
+        });
+        it('stores a number value', () => {
+            setStored(StorageKey.PAGE_COUNT, 25);
+            expect(getStored(StorageKey.PAGE_COUNT)).toBe(25);
+        });
+    });
+    // -------------------------------------------------------------------------
+    // removeStored
+    // -------------------------------------------------------------------------
+    describe('removeStored', () => {
+        it('removes an existing key so it returns null on subsequent reads', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            removeStored(StorageKey.USERNAME);
+            expect(getStored(StorageKey.USERNAME)).toBeNull();
+        });
+        it('does not throw when removing a key that was never stored', () => {
+            expect(() => removeStored(StorageKey.USERNAME)).not.toThrow();
+        });
+        it('removes only the targeted key and leaves others intact', () => {
+            setStored(StorageKey.USERNAME, 'alice');
+            setStored(StorageKey.PROVIDER, 'howler');
+            removeStored(StorageKey.USERNAME);
+            expect(getStored(StorageKey.USERNAME)).toBeNull();
+            expect(getStored(StorageKey.PROVIDER)).toBe('howler');
+        });
+    });
+    // -------------------------------------------------------------------------
+    // saveLoginCredential
+    // -------------------------------------------------------------------------
+    describe('saveLoginCredential', () => {
+        it('returns true and stores app_token when app_token is present', () => {
+            const result = saveLoginCredential({ app_token: 'tok123' });
+            expect(result).toBe(true);
+            expect(getStored(StorageKey.APP_TOKEN)).toBe('tok123');
+        });
+        it('also stores refresh_token and provider when they are present', () => {
+            saveLoginCredential({ app_token: 'tok', refresh_token: 'ref', provider: 'howler' });
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBe('ref');
+            expect(getStored(StorageKey.PROVIDER)).toBe('howler');
+        });
+        it('does not store refresh_token when it is absent', () => {
+            saveLoginCredential({ app_token: 'tok' });
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBeNull();
+        });
+        it('returns false and clears stored tokens when app_token is absent', () => {
+            setStored(StorageKey.APP_TOKEN, 'old-token');
+            setStored(StorageKey.REFRESH_TOKEN, 'old-refresh');
+            const result = saveLoginCredential({});
+            expect(result).toBe(false);
+            expect(getStored(StorageKey.APP_TOKEN)).toBeNull();
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBeNull();
+        });
+        it('clears APP_TOKEN, REFRESH_TOKEN, and PROVIDER on empty credential', () => {
+            setStored(StorageKey.APP_TOKEN, 't');
+            setStored(StorageKey.REFRESH_TOKEN, 'r');
+            setStored(StorageKey.PROVIDER, 'p');
+            saveLoginCredential({});
+            expect(getStored(StorageKey.APP_TOKEN)).toBeNull();
+            expect(getStored(StorageKey.REFRESH_TOKEN)).toBeNull();
+            expect(getStored(StorageKey.PROVIDER)).toBeNull();
+        });
+    });
+});

package/utils/menuUtils.test.d.ts

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