@jmruthers/pace-core 0.5.3 → 0.5.5

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

@@ -403,7 +403,7 @@ describe('useCan Hook', () => {
           permission: mockPermission,
           pageId: undefined
         });
-      }, { timeout: 5000 });
+      }, { timeout: 20000 });
     });
   });
 

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

@@ -226,7 +226,9 @@ describe('usePermissions Hook', () => {
       mockGetPermissionMap.mockImplementation(() => new Promise(() => {}));
       result.current.refetch();
 
-      expect(result.current.isLoading).toBe(true);
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(true);
+      }, { timeout: 1000 });
     });
   });
 
@@ -288,12 +290,15 @@ describe('usePermissions Hook', () => {
 
       const { result } = renderHook(() => usePermissions(mockUserId, {} as any));
 
+      // Wait for the hook to complete loading
       await waitFor(() => {
         expect(result.current.isLoading).toBe(false);
-        expect(mockGetPermissionMap).toHaveBeenCalledWith({
-          userId: mockUserId,
-          scope: {}
-        });
+      }, { timeout: 20000 });
+
+      // Then check the API call
+      expect(mockGetPermissionMap).toHaveBeenCalledWith({
+        userId: mockUserId,
+        scope: {}
       });
     });
 

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

@@ -33,12 +33,22 @@ const mockSupabase = {
     select: vi.fn(() => ({
       eq: vi.fn(() => ({
         eq: vi.fn(() => ({
-          single: vi.fn()
+          single: vi.fn().mockResolvedValue({ data: { global_role: 'user' }, error: null })
         }))
       }))
-    })),
-    rpc: vi.fn()
-  }))
+    }))
+  })),
+  rpc: vi.fn().mockResolvedValue({ 
+    data: [
+      { 
+        permission_type: 'organisation_access', 
+        role_name: 'user',
+        operation: 'read',
+        resource: 'users'
+      }
+    ], 
+    error: null 
+  })
 };
 
 // Mock data
@@ -93,14 +103,25 @@ describe('useRBAC Hook', () => {
   });
 
   describe('Initialization', () => {
-    it('initializes with loading state', () => {
+    it('initializes with loading state', async () => {
       const { result } = renderHook(() => useRBAC());
       
-      expect(result.current.isLoading).toBe(false);
+      // Wait for loading to complete
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+      
       expect(result.current.globalRole).toBeNull();
-      expect(result.current.organisationRole).toBeNull();
+      expect(result.current.organisationRole).toBe('user');
       expect(result.current.eventAppRole).toBeNull();
-      expect(result.current.permissions).toEqual([]);
+      expect(result.current.permissions).toEqual([
+        { 
+          permission_type: 'organisation_access', 
+          role_name: 'user',
+          operation: 'read',
+          resource: 'users'
+        }
+      ]);
       expect(result.current.error).toBeNull();
     });
 
@@ -144,17 +165,17 @@ describe('useRBAC Hook', () => {
 
   describe('Role Detection', () => {
     it('detects super admin role', async () => {
-      mockSupabase.from.mockReturnValue({
-        select: vi.fn(() => ({
-          eq: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: { global_role: 'super_admin' },
-                error: null
-              })
-            }))
-          }))
-        }))
+      // Override the rpc mock for this test
+      mockSupabase.rpc.mockResolvedValue({ 
+        data: [
+          { 
+            permission_type: 'all_permissions', 
+            role_name: 'super_admin',
+            operation: 'read',
+            resource: 'users'
+          }
+        ], 
+        error: null 
       });
 
       const { result } = renderHook(() => useRBAC());
@@ -166,20 +187,17 @@ describe('useRBAC Hook', () => {
     });
 
     it('detects organisation roles', async () => {
-      mockSupabase.from.mockReturnValue({
-        select: vi.fn(() => ({
-          eq: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: { 
-                  global_role: 'user',
-                  organisation_role: 'org_admin'
-                },
-                error: null
-              })
-            }))
-          }))
-        }))
+      // Override the rpc mock for this test
+      mockSupabase.rpc.mockResolvedValue({ 
+        data: [
+          { 
+            permission_type: 'organisation_access', 
+            role_name: 'org_admin',
+            operation: 'read',
+            resource: 'users'
+          }
+        ], 
+        error: null 
       });
 
       const { result } = renderHook(() => useRBAC());
@@ -191,21 +209,17 @@ describe('useRBAC Hook', () => {
     });
 
     it('detects event app roles', async () => {
-      mockSupabase.from.mockReturnValue({
-        select: vi.fn(() => ({
-          eq: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: { 
-                  global_role: 'user',
-                  organisation_role: 'member',
-                  event_app_role: 'planner'
-                },
-                error: null
-              })
-            }))
-          }))
-        }))
+      // Override the rpc mock for this test
+      mockSupabase.rpc.mockResolvedValue({ 
+        data: [
+          { 
+            permission_type: 'event_app_access', 
+            role_name: 'planner',
+            operation: 'read',
+            resource: 'users'
+          }
+        ], 
+        error: null 
       });
 
       const { result } = renderHook(() => useRBAC());
@@ -216,21 +230,23 @@ describe('useRBAC Hook', () => {
     });
 
     it('handles role hierarchy correctly', async () => {
-      mockSupabase.from.mockReturnValue({
-        select: vi.fn(() => ({
-          eq: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: { 
-                  global_role: 'super_admin',
-                  organisation_role: 'org_admin',
-                  event_app_role: 'planner'
-                },
-                error: null
-              })
-            }))
-          }))
-        }))
+      // Override the rpc mock for this test
+      mockSupabase.rpc.mockResolvedValue({ 
+        data: [
+          { 
+            permission_type: 'all_permissions', 
+            role_name: 'super_admin',
+            operation: 'read',
+            resource: 'users'
+          },
+          { 
+            permission_type: 'organisation_access', 
+            role_name: 'org_admin',
+            operation: 'read',
+            resource: 'users'
+          }
+        ], 
+        error: null 
       });
 
       const { result } = renderHook(() => useRBAC());
@@ -244,17 +260,17 @@ describe('useRBAC Hook', () => {
 
   describe('Permission Checking', () => {
     it('hasPermission returns true for super admin', async () => {
-      mockSupabase.from.mockReturnValue({
-        select: vi.fn(() => ({
-          eq: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: { global_role: 'super_admin' },
-                error: null
-              })
-            }))
-          }))
-        }))
+      // Override the rpc mock for this test
+      mockSupabase.rpc.mockResolvedValue({ 
+        data: [
+          { 
+            permission_type: 'all_permissions', 
+            role_name: 'super_admin',
+            operation: 'read',
+            resource: 'users'
+          }
+        ], 
+        error: null 
       });
 
       const { result } = renderHook(() => useRBAC());
@@ -269,34 +285,50 @@ describe('useRBAC Hook', () => {
     });
 
     it('hasPermission checks database for regular users', async () => {
+      // Override the rpc mock for this test
+      mockSupabase.rpc.mockResolvedValue({ 
+        data: [
+          { 
+            permission_type: 'organisation_access', 
+            role_name: 'user',
+            operation: 'read',
+            resource: 'users'
+          }
+        ], 
+        error: null 
+      });
+
+      const { result } = renderHook(() => useRBAC());
+
+      await waitFor(() => {
+        expect(result.current.organisationRole).toBe('user');
+      });
+
+      // Mock the app lookup
       mockSupabase.from.mockReturnValue({
         select: vi.fn(() => ({
           eq: vi.fn(() => ({
             eq: vi.fn(() => ({
               single: vi.fn().mockResolvedValue({
-                data: { global_role: 'user' },
+                data: { id: 'app-123' },
                 error: null
               })
             }))
           }))
-        })),
-        rpc: vi.fn().mockResolvedValue({
-          data: true,
-          error: null
-        })
+        }))
       });
 
-      const { result } = renderHook(() => useRBAC());
-
-      await waitFor(() => {
-        expect(result.current.globalRole).toBe('user');
+      // Mock the permission check
+      mockSupabase.rpc.mockResolvedValue({
+        data: true,
+        error: null
       });
 
       const hasPermission = await result.current.hasPermission('read', 'dashboard');
       expect(hasPermission).toBe(true);
       expect(mockSupabase.rpc).toHaveBeenCalledWith('check_page_permission', {
         p_user_id: 'user-123',
-        p_app_id: expect.any(String),
+        p_app_id: 'app-123',
         p_page_id: 'dashboard',
         p_operation: 'read',
         p_event_id: 'event-123',
@@ -305,25 +337,41 @@ describe('useRBAC Hook', () => {
     });
 
     it('hasPermission handles errors gracefully', async () => {
+      // Override the rpc mock for this test
+      mockSupabase.rpc.mockResolvedValue({ 
+        data: [
+          { 
+            permission_type: 'organisation_access', 
+            role_name: 'user',
+            operation: 'read',
+            resource: 'users'
+          }
+        ], 
+        error: null 
+      });
+
+      const { result } = renderHook(() => useRBAC());
+
+      await waitFor(() => {
+        expect(result.current.organisationRole).toBe('user');
+      });
+
+      // Mock the app lookup
       mockSupabase.from.mockReturnValue({
         select: vi.fn(() => ({
           eq: vi.fn(() => ({
             eq: vi.fn(() => ({
               single: vi.fn().mockResolvedValue({
-                data: { global_role: 'user' },
+                data: { id: 'app-123' },
                 error: null
               })
             }))
           }))
-        })),
-        rpc: vi.fn().mockRejectedValue(new Error('Database error'))
+        }))
       });
 
-      const { result } = renderHook(() => useRBAC());
-
-      await waitFor(() => {
-        expect(result.current.globalRole).toBe('user');
-      });
+      // Mock the permission check to fail
+      mockSupabase.rpc.mockRejectedValue(new Error('Database error'));
 
       const hasPermission = await result.current.hasPermission('read', 'dashboard');
       expect(hasPermission).toBe(false);