@classic-homes/theme-svelte 0.1.56 → 1.0.1

package/dist/__tests__/nav-access.test.js

@@ -0,0 +1,145 @@
+/**
+ * Navigation Access Filtering Tests
+ *
+ * Covers which navigation items a user sees given the roles and permissions
+ * they hold — including the nested case, where a restricted child sits under
+ * an unrestricted parent.
+ */
+import { describe, it, expect } from 'vitest';
+import { filterNavItems, isNavItemVisible, matchesAccess } from '../lib/utils/nav-access.js';
+function item(partial) {
+    return { name: partial.id, ...partial };
+}
+const ids = (items) => items.map((i) => i.id);
+describe('matchesAccess', () => {
+    it('matches when nothing is required', () => {
+        expect(matchesAccess(undefined, [])).toBe(true);
+        expect(matchesAccess([], [])).toBe(true);
+    });
+    it('does not match a requirement when the user holds nothing', () => {
+        expect(matchesAccess(['admin'], undefined)).toBe(false);
+        expect(matchesAccess(['admin'], [])).toBe(false);
+    });
+    it('matches any by default', () => {
+        expect(matchesAccess(['admin', 'manager'], ['manager'])).toBe(true);
+        expect(matchesAccess(['admin', 'manager'], ['agent'])).toBe(false);
+    });
+    it('can require all', () => {
+        expect(matchesAccess(['admin', 'manager'], ['admin'], true)).toBe(false);
+        expect(matchesAccess(['admin', 'manager'], ['admin', 'manager'], true)).toBe(true);
+    });
+});
+describe('isNavItemVisible', () => {
+    it('shows unrestricted items to anyone', () => {
+        expect(isNavItemVisible(item({ id: 'a' }), {})).toBe(true);
+    });
+    it('matches against every role held, not just one', () => {
+        const nav = item({ id: 'a', roles: ['agent'] });
+        expect(isNavItemVisible(nav, { userRoles: ['manager', 'agent'] })).toBe(true);
+    });
+    it('does not imply roles from one another', () => {
+        // Mirrors the auth package: holding admin does not imply agent, so the UI
+        // cannot offer something the server would reject.
+        const nav = item({ id: 'a', roles: ['agent'] });
+        expect(isNavItemVisible(nav, { userRoles: ['admin'] })).toBe(false);
+    });
+    it('combines roles and permissions as AND', () => {
+        const nav = item({ id: 'a', roles: ['manager'], permissions: ['users:write'] });
+        expect(isNavItemVisible(nav, { userRoles: ['manager'], userPermissions: ['users:write'] })).toBe(true);
+        expect(isNavItemVisible(nav, { userRoles: ['manager'], userPermissions: ['users:read'] })).toBe(false);
+        expect(isNavItemVisible(nav, { userRoles: ['agent'], userPermissions: ['users:write'] })).toBe(false);
+    });
+    it('gates on permissions alone', () => {
+        const nav = item({ id: 'a', permissions: ['settings:read'] });
+        expect(isNavItemVisible(nav, { userPermissions: ['settings:read'] })).toBe(true);
+        expect(isNavItemVisible(nav, { userRoles: ['admin'] })).toBe(false);
+    });
+});
+describe('filterNavItems', () => {
+    it('shows the union across a multi-role user', () => {
+        const items = [
+            item({ id: 'dashboard' }),
+            item({ id: 'users', roles: ['manager'] }),
+            item({ id: 'homes', roles: ['agent'] }),
+            item({ id: 'system', roles: ['admin'] }),
+        ];
+        expect(ids(filterNavItems(items, { userRoles: ['manager', 'agent'] }))).toEqual([
+            'dashboard',
+            'users',
+            'homes',
+        ]);
+    });
+    it('filters a restricted child under an unrestricted parent', () => {
+        // The parent passes on its own merits; without recursion nothing would ever
+        // look inside it and the admin-only child would show to everyone.
+        const items = [
+            item({
+                id: 'main',
+                children: [item({ id: 'open' }), item({ id: 'audit', roles: ['admin'] })],
+            }),
+        ];
+        const filtered = filterNavItems(items, { userRoles: ['agent'] });
+        expect(ids(filtered[0].children)).toEqual(['open']);
+    });
+    it('filters arbitrarily deep', () => {
+        const items = [
+            item({
+                id: 'l1',
+                children: [
+                    item({
+                        id: 'l2',
+                        children: [item({ id: 'l3', roles: ['admin'] }), item({ id: 'l3-open' })],
+                    }),
+                ],
+            }),
+        ];
+        const filtered = filterNavItems(items, { userRoles: ['agent'] });
+        expect(ids(filtered[0].children[0].children)).toEqual(['l3-open']);
+    });
+    it('drops a container whose children are all filtered away', () => {
+        const items = [
+            item({ id: 'admin-area', children: [item({ id: 'system', roles: ['admin'] })] }),
+        ];
+        // Keeping it would render an expandable with nothing behind it.
+        expect(ids(filterNavItems(items, { userRoles: ['agent'] }))).toEqual([]);
+    });
+    it('keeps an emptied parent that is a destination in its own right', () => {
+        const items = [
+            item({
+                id: 'reports',
+                href: '/reports',
+                children: [item({ id: 'revenue', roles: ['admin'] })],
+            }),
+        ];
+        const filtered = filterNavItems(items, { userRoles: ['agent'] });
+        expect(ids(filtered)).toEqual(['reports']);
+        expect(filtered[0].children).toEqual([]);
+    });
+    it('hides everything restricted from a user with no roles', () => {
+        const items = [item({ id: 'dashboard' }), item({ id: 'users', roles: ['manager'] })];
+        expect(ids(filterNavItems(items, {}))).toEqual(['dashboard']);
+    });
+    it('honors requireAllRoles', () => {
+        const items = [item({ id: 'both', roles: ['admin', 'manager'] })];
+        expect(ids(filterNavItems(items, { userRoles: ['admin'], requireAllRoles: true }))).toEqual([]);
+        expect(ids(filterNavItems(items, { userRoles: ['admin', 'manager'], requireAllRoles: true }))).toEqual(['both']);
+    });
+    it('honors requireAllPermissions', () => {
+        const items = [item({ id: 'both', permissions: ['a:read', 'b:read'] })];
+        expect(ids(filterNavItems(items, { userPermissions: ['a:read'], requireAllPermissions: true }))).toEqual([]);
+        expect(ids(filterNavItems(items, {
+            userPermissions: ['a:read', 'b:read'],
+            requireAllPermissions: true,
+        }))).toEqual(['both']);
+    });
+    it('leaves childless items without a children key', () => {
+        const filtered = filterNavItems([item({ id: 'a' })], {});
+        expect('children' in filtered[0]).toBe(false);
+    });
+    it('does not mutate the input', () => {
+        const items = [item({ id: 'main', children: [item({ id: 'audit', roles: ['admin'] })] })];
+        const before = JSON.stringify(items);
+        filterNavItems(items, { userRoles: ['agent'] });
+        expect(JSON.stringify(items)).toBe(before);
+    });
+});

package/dist/__tests__/sidebar-expansion.test.js

@@ -0,0 +1,59 @@
+/**
+ * Sidebar Role-based Expansion Tests
+ *
+ * Covers which sections start expanded for a given user. This is a UX
+ * affordance, not access control — it decides what starts open, not what is
+ * visible (that's nav-access).
+ */
+import { describe, it, expect } from 'vitest';
+import { sidebarStore } from '../lib/stores/sidebar.svelte.js';
+function section(partial) {
+    return { title: partial.id, items: [], ...partial };
+}
+describe('computeInitialExpansions', () => {
+    it('expands a section for any matching role', () => {
+        const sections = [section({ id: 'admin', expandForRoles: ['admin', 'superuser'] })];
+        expect(sidebarStore.computeInitialExpansions(sections, ['admin'])).toEqual(['admin']);
+        expect(sidebarStore.computeInitialExpansions(sections, ['superuser'])).toEqual(['admin']);
+    });
+    it('expands on a secondary role, not just the first held', () => {
+        const sections = [section({ id: 'ops', expandForRoles: ['agent'] })];
+        expect(sidebarStore.computeInitialExpansions(sections, ['manager', 'agent'])).toEqual(['ops']);
+    });
+    it('leaves a section collapsed when no role matches', () => {
+        const sections = [section({ id: 'admin', expandForRoles: ['admin'] })];
+        expect(sidebarStore.computeInitialExpansions(sections, ['agent'])).toEqual([]);
+    });
+    it('leaves a role-gated section collapsed for a user with no roles', () => {
+        const sections = [section({ id: 'admin', expandForRoles: ['admin'] })];
+        expect(sidebarStore.computeInitialExpansions(sections, [])).toEqual([]);
+        expect(sidebarStore.computeInitialExpansions(sections, undefined)).toEqual([]);
+    });
+    it('expands non-collapsible sections regardless of roles', () => {
+        const sections = [section({ id: 'main', collapsible: false })];
+        expect(sidebarStore.computeInitialExpansions(sections, [])).toEqual(['main']);
+    });
+    it('respects an explicitly collapsed section', () => {
+        const sections = [section({ id: 'main', collapsible: true, expanded: false })];
+        expect(sidebarStore.computeInitialExpansions(sections, ['admin'])).toEqual([]);
+    });
+    it('expands a collapsible section that is not explicitly collapsed', () => {
+        const sections = [section({ id: 'main', collapsible: true })];
+        expect(sidebarStore.computeInitialExpansions(sections, [])).toEqual(['main']);
+    });
+    it('prefers expandForRoles over the collapsed default', () => {
+        // expandForRoles is checked first, so it wins over `expanded: false`.
+        const sections = [
+            section({ id: 'admin', collapsible: true, expanded: false, expandForRoles: ['admin'] }),
+        ];
+        expect(sidebarStore.computeInitialExpansions(sections, ['admin'])).toEqual(['admin']);
+    });
+    it('handles a mixed navigation', () => {
+        const sections = [
+            section({ id: 'main', collapsible: false }),
+            section({ id: 'admin', expandForRoles: ['admin'] }),
+            section({ id: 'ops', expandForRoles: ['agent'] }),
+        ];
+        expect(sidebarStore.computeInitialExpansions(sections, ['agent'])).toEqual(['main', 'ops']);
+    });
+});