@jmruthers/pace-core 0.5.68 → 0.5.69

package/src/rbac/hooks/usePermissions.test.ts

@@ -40,15 +40,12 @@ describe('usePermissions Hook', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
+    // Pre-setup mock responses to avoid async delays
+    mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Permission Fetching', () => {
+    describe('Permission Fetching', () => {
     it('fetches permissions for valid user', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -264,6 +261,208 @@ describe('usePermissions Hook', () => {
     });
   });
 
+  describe('Role-Based Permission Scenarios', () => {
+    it('handles super admin permissions', async () => {
+      const superAdminPermissions = {
+        'read:users': true,
+        'create:users': true,
+        'update:users': true,
+        'delete:users': true,
+        'manage:organisations': true,
+        'manage:events': true,
+        'super_admin': true
+      };
+
+      mockGetPermissionMap.mockResolvedValue(superAdminPermissions);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(superAdminPermissions);
+      });
+
+      // Super admin should have all permissions
+      expect(result.current.hasPermission('read:users')).toBe(true);
+      expect(result.current.hasPermission('create:users')).toBe(true);
+      expect(result.current.hasPermission('update:users')).toBe(true);
+      expect(result.current.hasPermission('delete:users')).toBe(true);
+      expect(result.current.hasPermission('manage:organisations')).toBe(true);
+      expect(result.current.hasPermission('super_admin')).toBe(true);
+    });
+
+    it('handles organisation admin permissions', async () => {
+      const orgAdminPermissions = {
+        'read:users': true,
+        'create:users': true,
+        'update:users': true,
+        'delete:users': false, // Org admin can't delete users
+        'manage:organisations': true,
+        'manage:events': true,
+        'org_admin': true
+      };
+
+      mockGetPermissionMap.mockResolvedValue(orgAdminPermissions);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(orgAdminPermissions);
+      });
+
+      // Org admin should have most permissions but not all
+      expect(result.current.hasPermission('read:users')).toBe(true);
+      expect(result.current.hasPermission('create:users')).toBe(true);
+      expect(result.current.hasPermission('update:users')).toBe(true);
+      expect(result.current.hasPermission('delete:users')).toBe(false);
+      expect(result.current.hasPermission('manage:organisations')).toBe(true);
+      expect(result.current.hasPermission('org_admin')).toBe(true);
+    });
+
+    it('handles event admin permissions', async () => {
+      const eventAdminPermissions = {
+        'read:users': true,
+        'create:users': false,
+        'update:users': false,
+        'delete:users': false,
+        'manage:organisations': false,
+        'manage:events': true,
+        'event_admin': true
+      };
+
+      mockGetPermissionMap.mockResolvedValue(eventAdminPermissions);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(eventAdminPermissions);
+      });
+
+      // Event admin should have limited permissions
+      expect(result.current.hasPermission('read:users')).toBe(true);
+      expect(result.current.hasPermission('create:users')).toBe(false);
+      expect(result.current.hasPermission('update:users')).toBe(false);
+      expect(result.current.hasPermission('delete:users')).toBe(false);
+      expect(result.current.hasPermission('manage:organisations')).toBe(false);
+      expect(result.current.hasPermission('manage:events')).toBe(true);
+      expect(result.current.hasPermission('event_admin')).toBe(true);
+    });
+
+    it('handles member permissions', async () => {
+      const memberPermissions = {
+        'read:users': true,
+        'create:users': false,
+        'update:users': false,
+        'delete:users': false,
+        'manage:organisations': false,
+        'manage:events': false,
+        'member': true
+      };
+
+      mockGetPermissionMap.mockResolvedValue(memberPermissions);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(memberPermissions);
+      });
+
+      // Member should have very limited permissions
+      expect(result.current.hasPermission('read:users')).toBe(true);
+      expect(result.current.hasPermission('create:users')).toBe(false);
+      expect(result.current.hasPermission('update:users')).toBe(false);
+      expect(result.current.hasPermission('delete:users')).toBe(false);
+      expect(result.current.hasPermission('manage:organisations')).toBe(false);
+      expect(result.current.hasPermission('manage:events')).toBe(false);
+      expect(result.current.hasPermission('member')).toBe(true);
+    });
+
+    it('handles participant permissions', async () => {
+      const participantPermissions = {
+        'read:users': false,
+        'create:users': false,
+        'update:users': false,
+        'delete:users': false,
+        'manage:organisations': false,
+        'manage:events': false,
+        'participant': true
+      };
+
+      mockGetPermissionMap.mockResolvedValue(participantPermissions);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(participantPermissions);
+      });
+
+      // Participant should have no permissions except their role
+      expect(result.current.hasPermission('read:users')).toBe(false);
+      expect(result.current.hasPermission('create:users')).toBe(false);
+      expect(result.current.hasPermission('update:users')).toBe(false);
+      expect(result.current.hasPermission('delete:users')).toBe(false);
+      expect(result.current.hasPermission('manage:organisations')).toBe(false);
+      expect(result.current.hasPermission('manage:events')).toBe(false);
+      expect(result.current.hasPermission('participant')).toBe(true);
+    });
+
+    it('handles mixed permission scenarios with hasAnyPermission', async () => {
+      const mixedPermissions = {
+        'read:users': true,
+        'create:users': false,
+        'update:users': true,
+        'delete:users': false,
+        'manage:organisations': false,
+        'manage:events': true
+      };
+
+      mockGetPermissionMap.mockResolvedValue(mixedPermissions);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(mixedPermissions);
+      });
+
+      // Test hasAnyPermission with mixed results
+      expect(result.current.hasAnyPermission(['read:users', 'create:users'])).toBe(true); // One is true
+      expect(result.current.hasAnyPermission(['create:users', 'delete:users'])).toBe(false); // Both are false
+      expect(result.current.hasAnyPermission(['update:users', 'manage:events'])).toBe(true); // Both are true
+      expect(result.current.hasAnyPermission(['read:users', 'update:users', 'manage:events'])).toBe(true); // All are true
+    });
+
+    it('handles mixed permission scenarios with hasAllPermissions', async () => {
+      const mixedPermissions = {
+        'read:users': true,
+        'create:users': false,
+        'update:users': true,
+        'delete:users': false,
+        'manage:organisations': false,
+        'manage:events': true
+      };
+
+      mockGetPermissionMap.mockResolvedValue(mixedPermissions);
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(mixedPermissions);
+      });
+
+      // Test hasAllPermissions with mixed results
+      expect(result.current.hasAllPermissions(['read:users', 'update:users'])).toBe(true); // Both are true
+      expect(result.current.hasAllPermissions(['read:users', 'create:users'])).toBe(false); // One is false
+      expect(result.current.hasAllPermissions(['create:users', 'delete:users'])).toBe(false); // Both are false
+      expect(result.current.hasAllPermissions(['read:users', 'update:users', 'manage:events'])).toBe(true); // All are true
+    });
+  });
+
   describe('Edge Cases', () => {
     it('handles null userId', async () => {
       const { result } = renderHook(() => usePermissions(null as any, mockScope));
@@ -314,6 +513,47 @@ describe('usePermissions Hook', () => {
         expect(Object.keys(result.current.permissions)).toHaveLength(1000);
       });
     });
+
+    it('handles empty permission map', async () => {
+      mockGetPermissionMap.mockResolvedValue({});
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual({});
+        expect(result.current.error).toBeNull();
+      });
+
+      // All permission checks should return false
+      expect(result.current.hasPermission('read:users')).toBe(false);
+      expect(result.current.hasAnyPermission(['read:users', 'create:users'])).toBe(false);
+      expect(result.current.hasAllPermissions([])).toBe(true); // Empty array returns true
+    });
+
+    it('handles scope with empty organisationId', async () => {
+      const invalidScope = { organisationId: '', eventId: 'event-123' };
+      
+      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(true);
+        expect(result.current.permissions).toEqual({});
+        expect(mockGetPermissionMap).not.toHaveBeenCalled();
+      });
+    });
+
+    it('handles scope with whitespace-only organisationId', async () => {
+      const invalidScope = { organisationId: '   ', eventId: 'event-123' };
+      
+      const { result } = renderHook(() => usePermissions(mockUserId, invalidScope));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(true);
+        expect(result.current.permissions).toEqual({});
+        expect(mockGetPermissionMap).not.toHaveBeenCalled();
+      });
+    });
   });
 
   describe('Performance', () => {

package/src/rbac/hooks/useRBAC.simple.test.ts

@@ -65,11 +65,7 @@ vi.mock('./useRBAC', () => ({
 import { useRBAC } from './useRBAC';
 
 describe('useRBAC Hook - Simple Tests', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('renders without crashing', () => {
+    it('renders without crashing', () => {
     const { result } = renderHook(() => useRBAC());
     
     expect(result.current).toBeDefined();