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

package/api/action/execute.test.d.ts

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

package/api/action/execute.test.js

@@ -0,0 +1,38 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/action/execute'));
+vi.mock('api', () => ({
+    hpost: mockHpost,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/action', () => ({
+    uri: () => '/api/v1/action'
+}));
+import { post, uri } from './execute';
+describe('action execute API', () => {
+    beforeEach(() => {
+        mockHpost.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail execute URIs', () => {
+        expect(uri()).toBe('/api/v1/action/execute');
+        expect(uri('action-1')).toBe('/api/v1/action/action-1/execute');
+    });
+    it('posts either an existing action execution or an ad-hoc action execution', async () => {
+        mockHpost.mockResolvedValue({ success: true });
+        await post({ action_id: 'action-1', request_id: 'req-1', query: 'status:open' });
+        await post({ request_id: 'req-2', query: 'status:new', operations: [{ operation: 'x' }] });
+        expect(mockHpost).toHaveBeenNthCalledWith(1, '/api/v1/action/action-1/execute', {
+            request_id: 'req-1',
+            query: 'status:open'
+        });
+        expect(mockHpost).toHaveBeenNthCalledWith(2, '/api/v1/action/execute', {
+            request_id: 'req-2',
+            query: 'status:new',
+            operations: [{ operation: 'x' }]
+        });
+    });
+});

package/api/action/index.test.d.ts

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

package/api/action/index.test.js

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockCreatePermissionsApi = vi.hoisted(() => vi.fn(() => ({ put: vi.fn(), delete: vi.fn() })));
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHpatch = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/action'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpatch: mockHpatch,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('../utils/createPermissionsApi', () => ({
+    default: mockCreatePermissionsApi
+}));
+vi.mock('api/action/execute', () => ({ sentinel: 'execute' }));
+vi.mock('api/action/operations', () => ({ sentinel: 'operations' }));
+import { del, execute, get, operations, patch, permission, post, put, uri } from './index';
+describe('action API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpatch.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds list and detail URIs', () => {
+        expect(uri()).toBe('/api/v1/action');
+        expect(uri('abc')).toBe('/api/v1/action/abc');
+    });
+    it('gets, creates, updates, patches, and deletes actions', async () => {
+        const refresh = new URLSearchParams({ refresh: 'wait_for' });
+        await get('id-1');
+        await post({ id: 'new' }, 'wait_for');
+        await put('id-2', { id: 'updated' }, 'wait_for');
+        await patch('id-3', { id: 'patched' }, 'wait_for');
+        await del('id-4', 'wait_for');
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/action/id-1');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/action', { id: 'new' }, {}, refresh);
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/action/id-2', { id: 'updated' }, {}, refresh);
+        expect(mockHpatch).toHaveBeenCalledWith('/api/v1/action/id-3', { id: 'patched' }, {}, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/action/id-4', undefined, undefined, refresh);
+    });
+    it('creates permission helpers and re-exports nested action modules', () => {
+        expect(mockCreatePermissionsApi).toHaveBeenCalledWith(uri);
+        expect(permission).toEqual({ put: expect.any(Function), delete: expect.any(Function) });
+        expect(execute).toEqual({ sentinel: 'execute' });
+        expect(operations).toEqual({ sentinel: 'operations' });
+    });
+});

package/api/action/operations.test.d.ts

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

package/api/action/operations.test.js

@@ -0,0 +1,23 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHget = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/action/operations'));
+vi.mock('api', () => ({
+    hget: mockHget,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/action', () => ({
+    uri: () => '/api/v1/action'
+}));
+import { get, uri } from './operations';
+describe('action operations API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the operations URI and returns an empty fallback', async () => {
+        mockHget.mockResolvedValueOnce(undefined).mockResolvedValueOnce([{ id: 'add_label' }]);
+        expect(uri()).toBe('/api/v1/action/operations');
+        await expect(get()).resolves.toEqual([]);
+        await expect(get()).resolves.toEqual([{ id: 'add_label' }]);
+    });
+});

package/api/analytic/comments/index.test.d.ts

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

package/api/analytic/comments/index.test.js

@@ -0,0 +1,43 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/analytic', () => ({
+    uri: (analytic) => `/api/v1/analytic/${analytic}`
+}));
+vi.mock('./react', () => ({ sentinel: 'react-comments' }));
+import { del, get, post, put, react, uri } from './index';
+describe('analytic comments API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail URIs, performs CRUD operations, and re-exports reactions', async () => {
+        expect(uri('an-1')).toBe('/api/v1/analytic/an-1/comments');
+        expect(uri('an-1', 'c-1')).toBe('/api/v1/analytic/an-1/comments/c-1');
+        await get('an-1', 'c-1');
+        await put('an-1', 'c-1', 'edited');
+        await post('an-1', 'value', 'det-1');
+        await del('an-1', ['c-1']);
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/analytic/an-1/comments/c-1');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/analytic/an-1/comments/c-1', { value: 'edited' });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/analytic/an-1/comments', { value: 'value', detection: 'det-1' });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/analytic/an-1/comments', ['c-1']);
+        expect(react).toEqual({ sentinel: 'react-comments' });
+    });
+});

package/api/analytic/comments/react.test.d.ts

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

package/api/analytic/comments/react.test.js

@@ -0,0 +1,27 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hput: mockHput,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/analytic/comments', () => ({
+    uri: (analytic, comment) => `/api/v1/analytic/${analytic}/comments/${comment}`
+}));
+import { del, put, uri } from './react';
+describe('analytic comment reactions API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHput.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds nested reaction URIs and performs add/remove requests', async () => {
+        expect(uri('an-1', 'c-1')).toBe('/api/v1/analytic/an-1/comments/c-1/react');
+        await put('an-1', 'c-1', 'thumbs_up');
+        await del('an-1', 'c-1');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/analytic/an-1/comments/c-1/react', { type: 'thumbs_up' });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/analytic/an-1/comments/c-1/react');
+    });
+});

package/api/analytic/favourite.test.d.ts

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

package/api/analytic/favourite.test.js

@@ -0,0 +1,20 @@
+/// <reference types="vitest" />
+import { describe, expect, it, vi } from 'vitest';
+const mockDelete = vi.hoisted(() => vi.fn((url) => ({ method: 'delete', url })));
+const mockPost = vi.hoisted(() => vi.fn((url, body) => ({ method: 'post', url, body })));
+vi.mock('api', () => ({
+    hdelete: mockDelete,
+    hpost: mockPost,
+    joinAllUri: (...parts) => parts.join('/')
+}));
+vi.mock('api/analytic', () => ({
+    uri: () => '/api/v1/analytic'
+}));
+import * as favourite from './favourite';
+describe('api/analytic/favourite', () => {
+    it('builds favourite routes and requests', () => {
+        expect(favourite.uri('abc')).toBe('/api/v1/analytic/abc/favourite');
+        expect(favourite.del('abc')).toEqual({ method: 'delete', url: '/api/v1/analytic/abc/favourite' });
+        expect(favourite.post('abc')).toEqual({ method: 'post', url: '/api/v1/analytic/abc/favourite', body: {} });
+    });
+});

package/api/analytic/index.test.d.ts

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

package/api/analytic/index.test.js

@@ -0,0 +1,54 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/analytic'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('api/analytic/comments', () => ({ sentinel: 'comments' }));
+vi.mock('api/analytic/favourite', () => ({ sentinel: 'favourite' }));
+vi.mock('api/analytic/notebooks', () => ({ sentinel: 'notebooks' }));
+vi.mock('api/analytic/owner', () => ({ sentinel: 'owner' }));
+import { comments, del, favourite, get, notebooks, owner, put, uri } from './index';
+describe('analytic API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds list and detail URIs', () => {
+        expect(uri()).toBe('/api/v1/analytic');
+        expect(uri('abc')).toBe('/api/v1/analytic/abc');
+    });
+    it('gets one analytic or the collection', async () => {
+        mockHget.mockResolvedValueOnce([{ id: '1' }]).mockResolvedValueOnce({ id: '2' });
+        await expect(get()).resolves.toEqual([{ id: '1' }]);
+        await expect(get('2')).resolves.toEqual({ id: '2' });
+        expect(mockHget).toHaveBeenNthCalledWith(1, '/api/v1/analytic');
+        expect(mockHget).toHaveBeenNthCalledWith(2, '/api/v1/analytic/2');
+    });
+    it('updates and deletes analytics with optional refresh params', async () => {
+        const refresh = new URLSearchParams({ refresh: 'wait_for' });
+        mockHput.mockResolvedValue({ id: '2' });
+        mockHdelete.mockResolvedValue(undefined);
+        await put('2', { description: 'updated' }, 'wait_for');
+        await del('2', 'wait_for');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/analytic/2', { description: 'updated' }, undefined, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/analytic/2', undefined, undefined, refresh);
+    });
+    it('re-exports related analytic API modules', () => {
+        expect(comments).toEqual({ sentinel: 'comments' });
+        expect(favourite).toEqual({ sentinel: 'favourite' });
+        expect(notebooks).toEqual({ sentinel: 'notebooks' });
+        expect(owner).toEqual({ sentinel: 'owner' });
+    });
+});

package/api/analytic/notebooks/index.test.d.ts

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

package/api/analytic/notebooks/index.test.js

@@ -0,0 +1,31 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hpost: mockHpost,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/analytic', () => ({
+    uri: (analytic) => `/api/v1/analytic/${analytic}`
+}));
+import { del, post, uri } from './index';
+describe('analytic notebooks API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHpost.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the notebooks URI and performs create/delete requests', async () => {
+        expect(uri('an-1')).toBe('/api/v1/analytic/an-1/notebooks');
+        await post('an-1', { detection: 'det', value: 'link', name: 'Notebook' });
+        await del('an-1', ['n-1']);
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/analytic/an-1/notebooks', {
+            detection: 'det',
+            value: 'link',
+            name: 'Notebook'
+        });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/analytic/an-1/notebooks', ['n-1']);
+    });
+});

package/api/analytic/owner.test.d.ts

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

package/api/analytic/owner.test.js

@@ -0,0 +1,25 @@
+/// <reference types="vitest" />
+import { describe, expect, it, vi } from 'vitest';
+const mockPost = vi.hoisted(() => vi.fn((url, body, headers, params) => ({ url, body, headers, params })));
+vi.mock('api', () => ({
+    hpost: mockPost,
+    joinAllUri: (...parts) => parts.join('/')
+}));
+vi.mock('api/analytic', () => ({
+    uri: () => '/api/v1/analytic'
+}));
+import * as owner from './owner';
+describe('api/analytic/owner', () => {
+    it('builds owner routes and refresh-aware requests', async () => {
+        expect(owner.uri('abc')).toBe('/api/v1/analytic/abc/owner');
+        expect(await owner.post('abc', { username: 'alice' })).toEqual({
+            url: '/api/v1/analytic/abc/owner',
+            body: { username: 'alice' },
+            headers: undefined,
+            params: undefined
+        });
+        const withRefresh = await owner.post('abc', { username: 'alice' }, 'wait_for');
+        expect(withRefresh.url).toBe('/api/v1/analytic/abc/owner');
+        expect(withRefresh.params.toString()).toBe('refresh=wait_for');
+    });
+});

package/api/auth/apikey.test.d.ts

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

package/api/auth/apikey.test.js

@@ -0,0 +1,34 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hpost: mockHpost,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/auth', () => ({
+    uri: () => '/api/v1/auth'
+}));
+import { del, post, uri } from './apikey';
+describe('auth apikey API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHpost.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds list and detail API key URIs', () => {
+        expect(uri()).toBe('/api/v1/auth/apikey');
+        expect(uri('demo')).toBe('/api/v1/auth/apikey/demo');
+    });
+    it('creates and deletes API keys', async () => {
+        await post('demo', ['R', 'W'], '2026-10-10');
+        await del('demo');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/auth/apikey', {
+            name: 'demo',
+            priv: ['R', 'W'],
+            expiry_date: '2026-10-10'
+        });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/auth/apikey/demo');
+    });
+});

package/api/auth/index.test.d.ts

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

package/api/auth/index.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it, vi } from 'vitest';
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/auth'));
+vi.mock('api', () => ({
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('api/auth/apikey', () => ({
+    sentinel: 'apikey'
+}));
+vi.mock('api/auth/login', () => ({
+    sentinel: 'login'
+}));
+import { apikey, login, uri } from './index';
+describe('auth API', () => {
+    it('builds the auth URI and re-exports auth modules', () => {
+        expect(uri()).toBe('/api/v1/auth');
+        expect(mockJoinUri).toHaveBeenCalledWith('/api/v1', 'auth');
+        expect(apikey).toEqual({ sentinel: 'apikey' });
+        expect(login).toEqual({ sentinel: 'login' });
+    });
+});

package/api/auth/login.test.d.ts

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

package/api/auth/login.test.js

@@ -0,0 +1,53 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((_base, _part, params) => {
+    const base = '/api/v1/auth/login';
+    return params ? `${base}?${params.toString()}` : base;
+}));
+vi.mock('api', () => ({
+    hget: mockHget,
+    hpost: mockHpost,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/auth', () => ({
+    uri: () => '/api/v1/auth'
+}));
+import { get, post, uri } from './login';
+import { MY_LOCAL_STORAGE_PREFIX, StorageKey } from '@cccsaurora/howler-ui/utils/constants';
+describe('auth login API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockJoinUri.mockClear();
+        localStorage.clear();
+    });
+    it('builds the login endpoint URI and forwards search params', () => {
+        const params = new URLSearchParams({ next: '/hits' });
+        expect(uri(params)).toBe('/api/v1/auth/login?next=%2Fhits');
+        expect(mockJoinUri).toHaveBeenCalledWith('/api/v1/auth', 'login', params);
+    });
+    it('posts credentials to the login endpoint', async () => {
+        const response = { app_token: 'token' };
+        mockHpost.mockResolvedValue(response);
+        await expect(post({ user: 'demo', password: 'secret' })).resolves.toEqual(response);
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/auth/login', { user: 'demo', password: 'secret' });
+    });
+    it('adds and clears the stored OAuth nonce before fetching login state', async () => {
+        const params = new URLSearchParams({ code: 'oauth-code' });
+        const removeItemSpy = vi.spyOn(Storage.prototype, 'removeItem');
+        localStorage.setItem(`${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.LOGIN_NONCE}`, JSON.stringify('saved-nonce'));
+        mockHget.mockResolvedValue({ app_token: 'token' });
+        await get(params);
+        expect(params.get('nonce')).toBe('saved-nonce');
+        expect(removeItemSpy).toHaveBeenCalledWith(`${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.LOGIN_NONCE}`);
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/auth/login', params);
+    });
+    it('fetches login state unchanged when no nonce is stored', async () => {
+        const params = new URLSearchParams({ provider: 'oidc' });
+        mockHget.mockResolvedValue({ refresh_token: 'refresh' });
+        await get(params);
+        expect(params.get('nonce')).toBeNull();
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/auth/login', params);
+    });
+});

package/api/configs/index.test.d.ts

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

package/api/configs/index.test.js

@@ -0,0 +1,22 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHget = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/configs'));
+vi.mock('api', () => ({
+    hget: mockHget,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+import { get, uri } from './index';
+describe('configs API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the configs URI and fetches configs', async () => {
+        mockHget.mockResolvedValue({ indexes: {} });
+        expect(uri()).toBe('/api/v1/configs');
+        await expect(get()).resolves.toEqual({ indexes: {} });
+        expect(mockJoinUri).toHaveBeenCalledWith('/api/v1', 'configs');
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/configs');
+    });
+});

package/api/dossier/index.test.d.ts

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

package/api/dossier/index.test.js

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockCreatePermissionsApi = vi.hoisted(() => vi.fn(() => ({ canEdit: vi.fn() })));
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/dossier'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('api/utils/createPermissionsApi', () => ({
+    default: mockCreatePermissionsApi
+}));
+vi.mock('./groups', () => ({
+    sentinel: 'groups'
+}));
+import { del, get, groups, permission, post, put, uri } from './index';
+describe('dossier API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail URIs', () => {
+        expect(uri()).toBe('/api/v1/dossier');
+        expect(uri('abc')).toBe('/api/v1/dossier/abc');
+    });
+    it('fetches either one dossier or the dossier collection', async () => {
+        mockHget.mockResolvedValueOnce([{ id: 'one' }]).mockResolvedValueOnce({ id: 'two' });
+        await expect(get()).resolves.toEqual([{ id: 'one' }]);
+        await expect(get('two')).resolves.toEqual({ id: 'two' });
+    });
+    it('posts, puts, and deletes dossiers with refresh params', async () => {
+        const refresh = new URLSearchParams({ refresh: 'true' });
+        await post({ title: 'new' }, 'true');
+        await put('id-1', { title: 'updated' }, 'true');
+        await del('id-1', 'true');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/dossier', { title: 'new' }, undefined, refresh);
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/dossier/id-1', { title: 'updated' }, undefined, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/dossier/id-1', undefined, undefined, refresh);
+    });
+    it('creates the permission helper from the dossier URI and re-exports groups', () => {
+        expect(mockCreatePermissionsApi).toHaveBeenCalledWith(uri);
+        expect(permission).toEqual({ canEdit: expect.any(Function) });
+        expect(groups).toEqual({ sentinel: 'groups' });
+    });
+});

package/api/help.test.d.ts

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

package/api/help.test.js

@@ -0,0 +1,25 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHget = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1'));
+vi.mock('api', () => ({
+    hget: mockHget,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+import { get, uri } from './help';
+describe('help API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the help endpoint URI from the API root', () => {
+        expect(uri()).toBe('/api/v1');
+        expect(mockJoinUri).toHaveBeenCalledWith('/api/v1', '');
+    });
+    it('fetches the help payload from the help endpoint', async () => {
+        const payload = { apis: [], blueprints: {} };
+        mockHget.mockResolvedValue(payload);
+        await expect(get()).resolves.toEqual(payload);
+        expect(mockHget).toHaveBeenCalledWith('/api/v1');
+    });
+});

package/api/hit/assign.test.d.ts

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

package/api/hit/assign.test.js

@@ -0,0 +1,22 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+vi.mock('api', () => ({
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/hit', () => ({
+    uri: () => '/api/v1/hit'
+}));
+import { put, uri } from './assign';
+describe('hit assign API', () => {
+    beforeEach(() => {
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds the assign URI and performs the PUT request', async () => {
+        expect(uri('hit-1')).toBe('/api/v1/hit/hit-1/assign');
+        await put('hit-1', { value: 'demo' });
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/hit/hit-1/assign', { value: 'demo' });
+    });
+});

package/api/hit/comments/index.test.d.ts

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