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

package/api/search/user.test.js

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHpost = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn(() => '/api/v1/search/user'));
+vi.mock('api', () => ({
+    hpost: mockHpost,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/search', () => ({
+    uri: () => '/api/v1/search'
+}));
+import { post, uri } from './user';
+describe('search user API', () => {
+    beforeEach(() => {
+        mockHpost.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the user search endpoint URI', () => {
+        expect(uri()).toBe('/api/v1/search/user');
+        expect(mockJoinUri).toHaveBeenCalledWith('/api/v1/search', 'user');
+    });
+    it('defaults the query and maps uname to username', async () => {
+        mockHpost.mockResolvedValue({
+            items: [{ uname: 'alice', display_name: 'Alice' }],
+            total: 1
+        });
+        await expect(post()).resolves.toEqual({
+            items: [{ uname: 'alice', display_name: 'Alice', username: 'alice' }],
+            total: 1
+        });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/search/user', { query: 'name:*' });
+    });
+    it('preserves the provided request while ensuring a default query exists', async () => {
+        mockHpost.mockResolvedValue({ items: [], total: 0 });
+        await post({ rows: 10, query: 'name:demo' });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/search/user', { rows: 10, query: 'name:demo' });
+    });
+    it('throws when the search response is empty', async () => {
+        mockHpost.mockResolvedValue(undefined);
+        await expect(post({ query: 'name:test' })).rejects.toThrow('Search response was empty.');
+    });
+});

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

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

package/api/socket/index.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it, vi } from 'vitest';
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+vi.mock('api', () => ({
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/socket/viewers', () => ({
+    sentinel: 'viewers'
+}));
+import { uri, viewers } from './index';
+describe('socket API', () => {
+    it('builds the socket root URI and re-exports viewers', () => {
+        expect(uri()).toBe('/socket/v1');
+        expect(viewers).toEqual({ sentinel: 'viewers' });
+    });
+});

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

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

package/api/template/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(() => '/api/v1/template'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+import { del, get, post, put, uri } from './index';
+describe('template API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail template URIs', () => {
+        expect(uri()).toBe('/api/v1/template');
+        expect(uri('template-1')).toBe('/api/v1/template/template-1');
+    });
+    it('gets templates with an empty fallback and performs write operations', async () => {
+        const refresh = new URLSearchParams({ refresh: 'false' });
+        mockHget.mockResolvedValueOnce(undefined).mockResolvedValueOnce([{ id: 'template-1' }]);
+        await expect(get()).resolves.toEqual([]);
+        await expect(get()).resolves.toEqual([{ id: 'template-1' }]);
+        await post({ title: 'new' }, 'false');
+        await put('template-1', ['field'], 'false');
+        await del('template-1', 'false');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/template', { title: 'new' }, undefined, refresh);
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/template/template-1', ['field'], undefined, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/template/template-1', undefined, undefined, refresh);
+    });
+});

package/api/user/avatar/index.test.d.ts

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

package/api/user/avatar/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((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hget: mockHget,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/user', () => ({
+    uri: () => '/api/v1/user'
+}));
+import { get, uri } from './index';
+describe('user avatar API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the avatar URI and performs the GET request', async () => {
+        expect(uri('alice')).toBe('/api/v1/user/avatar/alice');
+        await get('alice');
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/user/avatar/alice');
+    });
+});

package/api/user/groups.test.d.ts

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

package/api/user/groups.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((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hget: mockHget,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/user', () => ({
+    uri: () => '/api/v1/user'
+}));
+import { get, uri } from './groups';
+describe('user groups API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the groups URI and performs the GET request', async () => {
+        expect(uri()).toBe('/api/v1/user/groups');
+        await get();
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/user/groups');
+    });
+});

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

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

package/api/user/index.test.js

@@ -0,0 +1,37 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHget = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinUri = vi.hoisted(() => vi.fn((base, part) => `${base}/${part}`));
+vi.mock('api', () => ({
+    hget: mockHget,
+    hput: mockHput,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('api/user/avatar', () => ({ sentinel: 'avatar' }));
+vi.mock('api/user/groups', () => ({ sentinel: 'groups' }));
+vi.mock('api/user/whoami', () => ({ sentinel: 'whoami' }));
+import { avatar, get, groups, put, uri, whoami } from './index';
+describe('user API', () => {
+    beforeEach(() => {
+        mockHget.mockReset();
+        mockHput.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail user URIs', () => {
+        expect(uri()).toBe('/api/v1/user');
+        expect(uri('alice')).toBe('/api/v1/user/alice');
+    });
+    it('gets and updates a user with optional refresh params', async () => {
+        const refresh = new URLSearchParams({ refresh: 'false' });
+        await get('alice');
+        await put('alice', { display_name: 'Alice' }, 'false');
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/user/alice');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/user/alice', { display_name: 'Alice' }, undefined, refresh);
+    });
+    it('re-exports nested user modules', () => {
+        expect(avatar).toEqual({ sentinel: 'avatar' });
+        expect(groups).toEqual({ sentinel: 'groups' });
+        expect(whoami).toEqual({ sentinel: 'whoami' });
+    });
+});

package/api/user/whoami.test.d.ts

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

package/api/user/whoami.test.js

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

package/api/utils/createPermissionsApi.test.d.ts

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

package/api/utils/createPermissionsApi.test.js

@@ -0,0 +1,30 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHput = vi.hoisted(() => vi.fn());
+const mockJoinAllUri = vi.hoisted(() => vi.fn((...parts) => parts.join('/').replace(/\/+/g, '/')));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri
+}));
+import createPermissionsApi from './createPermissionsApi';
+describe('createPermissionsApi', () => {
+    const parentUri = (id) => `/api/v1/example/${id}`;
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds permission routes relative to the parent URI', async () => {
+        const permissionApi = createPermissionsApi(parentUri);
+        const payload = [
+            { privilege: 'W', user_id: '1' },
+            { privilege: 'W', user_id: '2' }
+        ];
+        await permissionApi.put('abc', payload);
+        await permissionApi.delete('abc', payload);
+        expect(mockJoinAllUri).toHaveBeenCalledWith('/api/v1/example/abc', 'permission');
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/example/abc/permission', payload);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/example/abc/permission', payload);
+    });
+});

package/api/v2/case/index.test.d.ts

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

package/api/v2/case/index.test.js

@@ -0,0 +1,57 @@
+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(() => '/api/v2/case'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/v2', () => ({
+    uri: () => '/api/v2'
+}));
+vi.mock('api/v2/case/items', () => ({
+    sentinel: 'items'
+}));
+vi.mock('api/v2/case/rules', () => ({
+    sentinel: 'rules'
+}));
+import { del, get, items, post, put, rules, uri } from './index';
+describe('v2 case API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail URIs', () => {
+        expect(uri()).toBe('/api/v2/case');
+        expect(uri('case-1')).toBe('/api/v2/case/case-1');
+    });
+    it('gets, creates, updates, and deletes cases', async () => {
+        mockHget.mockResolvedValue({ id: 'case-1' });
+        mockHpost.mockResolvedValue({ id: 'case-2' });
+        mockHput.mockResolvedValue({ id: 'case-3' });
+        mockHdelete.mockResolvedValue(undefined);
+        await expect(get('case-1')).resolves.toEqual({ id: 'case-1' });
+        await expect(post({ title: 'new case' })).resolves.toEqual({ id: 'case-2' });
+        await expect(put('case-3', { title: 'updated' })).resolves.toEqual({ id: 'case-3' });
+        await expect(del('case-4')).resolves.toBeUndefined();
+        expect(mockHget).toHaveBeenCalledWith('/api/v2/case/case-1');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v2/case', { title: 'new case' });
+        expect(mockHput).toHaveBeenCalledWith('/api/v2/case/case-3', { title: 'updated' });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v2/case/case-4');
+    });
+    it('re-exports the nested items and rules APIs', () => {
+        expect(items).toEqual({ sentinel: 'items' });
+        expect(rules).toEqual({ sentinel: 'rules' });
+    });
+});

package/api/v2/case/items.test.d.ts

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

package/api/v2/case/items.test.js

@@ -0,0 +1,37 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = vi.hoisted(() => vi.fn());
+const mockHpost = 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,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinUri: mockJoinUri
+}));
+vi.mock('api/v2/case', () => ({
+    uri: (id) => `/api/v2/case/${id}`
+}));
+import { del, post, put, uri } from './items';
+describe('v2 case items API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinUri.mockClear();
+    });
+    it('builds the items URI and performs create, delete, and update operations', async () => {
+        expect(uri('case-1')).toBe('/api/v2/case/case-1/items');
+        await post('case-1', { id: 'item-1', name: 'Item' });
+        await del('case-1', 'item-1');
+        await del('case-1', ['item-1', 'item-2'], true);
+        await put('case-1', 'item-3', { name: 'Updated' });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v2/case/case-1/items', { id: 'item-1', name: 'Item' });
+        expect(mockHdelete).toHaveBeenNthCalledWith(1, '/api/v2/case/case-1/items', { ids: ['item-1'], force: false });
+        expect(mockHdelete).toHaveBeenNthCalledWith(2, '/api/v2/case/case-1/items', {
+            ids: ['item-1', 'item-2'],
+            force: true
+        });
+        expect(mockHput).toHaveBeenCalledWith('/api/v2/case/case-1/items', { id: 'item-3', name: 'Updated' });
+    });
+});

package/api/v2/case/rules.test.d.ts

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

package/api/v2/case/rules.test.js

@@ -0,0 +1,33 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mockHdelete = 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, '/')));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/v2/case', () => ({
+    uri: (caseId) => `/api/v2/case/${caseId}`
+}));
+import { del, post, put, uri } from './rules';
+describe('v2 case rules API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds collection and detail rule URIs and calls each HTTP method', async () => {
+        expect(uri('case-1')).toBe('/api/v2/case/case-1/rules');
+        expect(uri('case-1', 'rule-1')).toBe('/api/v2/case/case-1/rules/rule-1');
+        await post('case-1', { name: 'rule' });
+        await put('case-1', 'rule-1', { name: 'updated' });
+        await del('case-1', 'rule-1');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v2/case/case-1/rules', { name: 'rule' });
+        expect(mockHput).toHaveBeenCalledWith('/api/v2/case/case-1/rules/rule-1', { name: 'updated' });
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v2/case/case-1/rules/rule-1');
+    });
+});

package/api/v2/fuzzy.test.d.ts

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

package/api/v2/fuzzy.test.js

@@ -0,0 +1,30 @@
+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, '/')));
+vi.mock('api', () => ({
+    hpost: mockHpost,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/v2', () => ({
+    uri: () => '/api/v2'
+}));
+import { post, uri } from './fuzzy';
+describe('v2 fuzzy API', () => {
+    beforeEach(() => {
+        mockHpost.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds the fuzzy endpoint URI', () => {
+        expect(uri()).toBe('/api/v2/fuzzy');
+        expect(mockJoinAllUri).toHaveBeenCalledWith('/api/v2', 'fuzzy');
+    });
+    it('posts a fuzzy search request to the nested search endpoint', async () => {
+        mockHpost.mockResolvedValue({ items: [], total: 0 });
+        await post({ query: 'hello world', indexes: ['hit'] });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v2/fuzzy/search', { query: 'hello world', indexes: ['hit'] });
+    });
+    it('rejects blank fuzzy search queries', () => {
+        expect(() => post({ query: '   ' })).toThrow('Search query is required.');
+        expect(() => post({ query: '' })).toThrow('Search query is required.');
+    });
+});

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

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

package/api/v2/index.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('api/v2/case', () => ({ sentinel: 'case' }));
+vi.mock('api/v2/fuzzy', () => ({ sentinel: 'fuzzy' }));
+vi.mock('api/v2/search', () => ({ sentinel: 'search' }));
+import { case as caseApi, fuzzy, search, uri } from './index';
+describe('v2 API', () => {
+    it('builds the v2 root URI and re-exports v2 modules', () => {
+        expect(uri()).toBe('/api/v2');
+        expect(caseApi).toEqual({ sentinel: 'case' });
+        expect(fuzzy).toEqual({ sentinel: 'fuzzy' });
+        expect(search).toEqual({ sentinel: 'search' });
+    });
+});

package/api/v2/search/index.test.d.ts

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

package/api/v2/search/index.test.js

@@ -0,0 +1,42 @@
+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, '/')));
+vi.mock('api', () => ({
+    hpost: mockHpost,
+    joinAllUri: mockJoinAllUri
+}));
+vi.mock('api/v2', () => ({
+    uri: () => '/api/v2'
+}));
+vi.mock('./facet', () => ({
+    facet: { sentinel: true }
+}));
+import { facet, post, uri } from './index';
+describe('v2 search API', () => {
+    beforeEach(() => {
+        mockHpost.mockReset();
+        mockJoinAllUri.mockClear();
+    });
+    it('builds the v2 multi-index search URI', () => {
+        expect(uri(['hit', 'event'])).toBe('/api/v2/search/hit,event');
+        expect(mockJoinAllUri).toHaveBeenCalledWith('/api/v2', 'search', 'hit,event');
+    });
+    it('posts a search request for a single index string', async () => {
+        mockHpost.mockResolvedValue({ items: [], total: 0 });
+        await post('hit', { rows: 25 });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v2/search/hit', { rows: 25, query: 'howler.id:*' });
+    });
+    it('preserves a provided query for multiple indexes', async () => {
+        mockHpost.mockResolvedValue({ items: [], total: 0 });
+        await post(['hit', 'case'], { query: 'status:open' });
+        expect(mockHpost).toHaveBeenCalledWith('/api/v2/search/hit,case', { query: 'status:open' });
+    });
+    it('rejects nullish, invalid, or empty indexes', async () => {
+        expect(() => post(undefined, {})).toThrow('Indexes cannot be null or undefined.');
+        expect(() => post('hit,invalid', {})).toThrow('Only hit, case, and event indexes should be used currently.');
+        expect(() => post('', {})).toThrow('indexes must have length of at least 1.');
+    });
+    it('re-exports the facet module', () => {
+        expect(facet.facet).toEqual({ sentinel: true });
+    });
+});

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

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

package/api/view/index.test.js

@@ -0,0 +1,54 @@
+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 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/view'));
+vi.mock('api', () => ({
+    hdelete: mockHdelete,
+    hget: mockHget,
+    hpost: mockHpost,
+    hput: mockHput,
+    joinAllUri: mockJoinAllUri,
+    joinUri: mockJoinUri,
+    uri: () => '/api/v1'
+}));
+vi.mock('../utils/createPermissionsApi', () => ({
+    default: mockCreatePermissionsApi
+}));
+vi.mock('api/view/favourite', () => ({
+    sentinel: 'favourite'
+}));
+import { del, favourite, get, permission, post, put, uri } from './index';
+describe('view API', () => {
+    beforeEach(() => {
+        mockHdelete.mockReset();
+        mockHget.mockReset();
+        mockHpost.mockReset();
+        mockHput.mockReset();
+        mockJoinAllUri.mockClear();
+        mockJoinUri.mockClear();
+    });
+    it('builds collection and detail view URIs', () => {
+        expect(uri()).toBe('/api/v1/view');
+        expect(uri('view-1')).toBe('/api/v1/view/view-1');
+    });
+    it('gets, creates, updates, and deletes views', async () => {
+        const refresh = new URLSearchParams({ refresh: 'wait_for' });
+        await get();
+        await post({ title: 'new' }, 'wait_for');
+        await put('view-1', { title: 'updated' }, 'wait_for');
+        await del('view-1', 'wait_for');
+        expect(mockHget).toHaveBeenCalledWith('/api/v1/view');
+        expect(mockHpost).toHaveBeenCalledWith('/api/v1/view', { title: 'new' }, undefined, refresh);
+        expect(mockHput).toHaveBeenCalledWith('/api/v1/view/view-1', { title: 'updated' }, undefined, refresh);
+        expect(mockHdelete).toHaveBeenCalledWith('/api/v1/view/view-1', undefined, undefined, refresh);
+    });
+    it('creates permission helpers and re-exports favourites', () => {
+        expect(mockCreatePermissionsApi).toHaveBeenCalledWith(uri);
+        expect(permission).toEqual({ put: expect.any(Function), delete: expect.any(Function) });
+        expect(favourite).toEqual({ sentinel: 'favourite' });
+    });
+});

package/branding/AppBrand.test.d.ts

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

package/branding/AppBrand.test.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/// <reference types="vitest" />
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+let mode = 'light';
+vi.mock('@mui/material', () => ({
+    Stack: ({ children, direction, alignItems, style }) => (_jsx("div", { "data-direction": direction, "data-align-items": alignItems, "data-style": JSON.stringify(style), children: children })),
+    useTheme: () => ({ palette: { mode } })
+}));
+import { AppBrand, SIZES } from './AppBrand';
+describe('AppBrand', () => {
+    it('renders a logo-only variant', () => {
+        render(_jsx(AppBrand, { application: "howler", variant: "logo", size: "small" }));
+        const logo = screen.getByAltText('howler logo');
+        expect(logo).toHaveAttribute('src', '/branding/howler/noswoosh-light.svg');
+        expect(logo).toHaveStyle({ width: `${SIZES.small.icon.width}px`, height: `${SIZES.small.icon.height}px` });
+        expect(screen.queryByAltText('howler')).not.toBeInTheDocument();
+    });
+    it('renders app and banner variants with the themed name asset', () => {
+        mode = 'dark';
+        const { rerender, container } = render(_jsx(AppBrand, { application: "assemblyline", variant: "app", size: "medium" }));
+        expect(screen.getByAltText('assemblyline logo')).toHaveAttribute('src', '/branding/assemblyline/noswoosh-dark.svg');
+        expect(screen.getByAltText('assemblyline')).toHaveAttribute('src', '/branding/assemblyline/name-dark.svg');
+        expect(container.firstChild).toHaveAttribute('data-direction', 'row');
+        rerender(_jsx(AppBrand, { application: "analyticalplatform", variant: "banner-vertical", size: "xsmall" }));
+        expect(container.firstChild).toHaveAttribute('data-direction', 'column');
+        expect(screen.getByAltText('analyticalplatform')).toHaveAttribute('src', '/branding/analyticalplatform/name-dark.svg');
+    });
+});

package/components/app/drawers/ApiKeyDrawer.test.d.ts

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