@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -44,8 +44,8 @@ describe('usePermissions Hook', () => {
 
   beforeEach(() => {
     vi.clearAllMocks();
-    // Pre-setup mock responses to avoid async delays
-    mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+    // Pre-setup mock responses (ApiResult shape)
+    mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
   });
 
     describe('Permission Fetching', () => {
@@ -87,7 +87,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('refetches permissions when dependencies change', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result, rerender } = renderHook(
         ({ userId, scope }) => usePermissions(userId, scope),
@@ -112,7 +112,7 @@ describe('usePermissions Hook', () => {
 
   describe('Permission Checking', () => {
     beforeEach(async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
     });
 
     it('hasPermission returns correct boolean', async () => {
@@ -167,7 +167,7 @@ describe('usePermissions Hook', () => {
 
   describe('Refetch Functionality', () => {
     it('refetch function works correctly', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -185,7 +185,7 @@ describe('usePermissions Hook', () => {
 
     it('refetch handles errors correctly', async () => {
       mockGetPermissionMap
-        .mockResolvedValueOnce(mockPermissionMap)
+        .mockResolvedValueOnce({ ok: true, data: mockPermissionMap })
         .mockRejectedValueOnce(new Error('Refetch error'));
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
@@ -215,7 +215,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('shows loading state during refetch', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -248,7 +248,7 @@ describe('usePermissions Hook', () => {
     it('clears error on successful refetch', async () => {
       mockGetPermissionMap
         .mockRejectedValueOnce(new Error('Initial error'))
-        .mockResolvedValueOnce(mockPermissionMap);
+        .mockResolvedValueOnce({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -277,7 +277,7 @@ describe('usePermissions Hook', () => {
         'super_admin': true
       };
 
-      mockGetPermissionMap.mockResolvedValue(superAdminPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: superAdminPermissions });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -306,7 +306,7 @@ describe('usePermissions Hook', () => {
         'org_admin': true
       };
 
-      mockGetPermissionMap.mockResolvedValue(orgAdminPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: orgAdminPermissions });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -335,7 +335,7 @@ describe('usePermissions Hook', () => {
         'event_admin': true
       };
 
-      mockGetPermissionMap.mockResolvedValue(eventAdminPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: eventAdminPermissions });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -365,7 +365,7 @@ describe('usePermissions Hook', () => {
         'member': true
       };
 
-      mockGetPermissionMap.mockResolvedValue(memberPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: memberPermissions });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -395,7 +395,7 @@ describe('usePermissions Hook', () => {
         'participant': true
       };
 
-      mockGetPermissionMap.mockResolvedValue(participantPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: participantPermissions });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -424,7 +424,7 @@ describe('usePermissions Hook', () => {
         'update:events': true
       };
 
-      mockGetPermissionMap.mockResolvedValue(mixedPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mixedPermissions });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -450,7 +450,7 @@ describe('usePermissions Hook', () => {
         'update:events': true
       };
 
-      mockGetPermissionMap.mockResolvedValue(mixedPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mixedPermissions });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -489,7 +489,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles empty scope', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, '', undefined, undefined));
 
@@ -508,7 +508,7 @@ describe('usePermissions Hook', () => {
         largePermissionMap[`permission:${i}`] = i % 2 === 0;
       }
 
-      mockGetPermissionMap.mockResolvedValue(largePermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: largePermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -519,7 +519,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles empty permission map', async () => {
-      mockGetPermissionMap.mockResolvedValue({});
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: {} });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -560,7 +560,7 @@ describe('usePermissions Hook', () => {
 
   describe('Performance', () => {
     it('maintains stable references for same permissions', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result, rerender } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -580,7 +580,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles rapid permission checks efficiently', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
 
@@ -613,7 +613,7 @@ describe('usePermissions Hook', () => {
 
       // Invalidate and refetch
       const newPermissions = { ...mockPermissionMap, 'new:permission': true };
-      mockGetPermissionMap.mockResolvedValue(newPermissions);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: newPermissions });
       result.current.refetch();
 
       await waitFor(() => {
@@ -622,7 +622,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles cache expiration gracefully', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -640,7 +640,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('maintains consistent permissions across multiple refetches', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -659,7 +659,7 @@ describe('usePermissions Hook', () => {
 
   describe('[integration] Concurrent Operations', () => {
     it('handles concurrent permission checks', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -680,7 +680,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles rapid scope changes without errors', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result, rerender } = renderHook(
         ({ userId, scope }) => usePermissions(userId, scope),
@@ -711,7 +711,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles mixed permission and refetch operations', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -734,7 +734,7 @@ describe('usePermissions Hook', () => {
 
   describe('[integration] Permission Resolution Edge Cases', () => {
     it('handles organization context changes', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result, rerender } = renderHook(
         ({ userId, scope }) => usePermissions(userId, scope),
@@ -757,7 +757,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles event context changes', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result, rerender } = renderHook(
         ({ userId, scope }) => usePermissions(userId, scope),
@@ -781,7 +781,7 @@ describe('usePermissions Hook', () => {
 
     it('handles permission resolution with partial scope', async () => {
       const partialScope = { organisationId: mockScope.organisationId };
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, partialScope));
 
@@ -797,7 +797,7 @@ describe('usePermissions Hook', () => {
     it('recovers from transient errors', async () => {
       mockGetPermissionMap
         .mockRejectedValueOnce(new Error('Transient error'))
-        .mockResolvedValueOnce(mockPermissionMap);
+        .mockResolvedValueOnce({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -831,7 +831,7 @@ describe('usePermissions Hook', () => {
     it('maintains stability after error recovery', async () => {
       mockGetPermissionMap
         .mockRejectedValueOnce(new Error('Error'))
-        .mockResolvedValue(mockPermissionMap);
+        .mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -853,7 +853,7 @@ describe('usePermissions Hook', () => {
 
   describe('[integration] State Management', () => {
     it('preserves state across hook re-renders', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result, rerender } = renderHook(() => usePermissions(mockUserId, mockScope));
 
@@ -885,7 +885,7 @@ describe('usePermissions Hook', () => {
     });
 
     it('handles null event ID', async () => {
-      mockGetPermissionMap.mockResolvedValue(mockPermissionMap);
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
 
       const { result } = renderHook(() => usePermissions(mockUserId, 'org-123', null, undefined));
 
@@ -896,4 +896,430 @@ describe('usePermissions Hook', () => {
       expect(result.current.permissions).toEqual(mockPermissionMap);
     });
   });
+
+  describe('Edge Cases and Boundary Conditions', () => {
+    it('handles whitespace-only organisationId', async () => {
+      const { result } = renderHook(() => usePermissions(mockUserId, '   ', 'event-123', undefined));
+
+      // Wait for the timeout (3 seconds) to set error and clear loading
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.error).toBeInstanceOf(Error);
+      }, { timeout: 4000 });
+
+      expect(result.current.permissions).toEqual({});
+    });
+
+    it('handles undefined appId', async () => {
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, undefined));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.permissions).toEqual(mockPermissionMap);
+    });
+
+    it('handles null appId', async () => {
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, null as any));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.permissions).toEqual(mockPermissionMap);
+    });
+
+    it('handles rapid parameter changes without duplicate fetches', async () => {
+      let fetchCount = 0;
+      mockGetPermissionMap.mockImplementation(() => {
+        fetchCount++;
+        return Promise.resolve({ ok: true, data: mockPermissionMap });
+      });
+
+      const { rerender } = renderHook(
+        ({ userId, orgId, eventId, appId }) => usePermissions(userId, orgId, eventId, appId),
+        {
+          initialProps: {
+            userId: mockUserId,
+            orgId: mockOrgId,
+            eventId: mockEventId,
+            appId: mockAppId,
+          },
+        }
+      );
+
+      await waitFor(() => {
+        expect(fetchCount).toBeGreaterThan(0);
+      });
+
+      const initialFetchCount = fetchCount;
+
+      // Rapidly change parameters
+      for (let i = 0; i < 3; i++) {
+        rerender({
+          userId: mockUserId,
+          orgId: `org-${i}`,
+          eventId: mockEventId,
+          appId: mockAppId,
+        });
+      }
+
+      await waitFor(() => {
+        // Should have additional fetches for parameter changes
+        expect(fetchCount).toBeGreaterThan(initialFetchCount);
+      }, { timeout: 3000 });
+    });
+
+    it('handles permission map with all false values', async () => {
+      const allFalsePermissions = {
+        'read:users': false,
+        'create:users': false,
+        'update:users': false,
+        'delete:users': false,
+      };
+
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: allFalsePermissions });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.permissions).toEqual(allFalsePermissions);
+      expect(result.current.hasPermission('read:users')).toBe(false);
+      expect(result.current.hasAnyPermission(['read:users', 'create:users'])).toBe(false);
+      expect(result.current.hasAllPermissions(['read:users', 'create:users'])).toBe(false);
+    });
+
+    it('handles permission map with mixed true/false/undefined values', async () => {
+      const mixedPermissions = {
+        'read:users': true,
+        'create:users': false,
+        'update:users': undefined as any,
+        'delete:users': true,
+      };
+
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mixedPermissions });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.hasPermission('read:users')).toBe(true);
+      expect(result.current.hasPermission('create:users')).toBe(false);
+      expect(result.current.hasPermission('update:users')).toBe(false); // undefined treated as false
+      expect(result.current.hasPermission('delete:users')).toBe(true);
+    });
+
+    it('handles hasAnyPermission with empty array', async () => {
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Empty array should return false
+      expect(result.current.hasAnyPermission([])).toBe(false);
+    });
+
+    it('handles hasAllPermissions with empty array', async () => {
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Empty array should return true (all of nothing is true)
+      expect(result.current.hasAllPermissions([])).toBe(true);
+    });
+
+    it('handles hasAnyPermission with single permission', async () => {
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.hasAnyPermission(['read:users'])).toBe(true);
+      expect(result.current.hasAnyPermission(['nonexistent:permission'])).toBe(false);
+    });
+
+    it('handles hasAllPermissions with single permission', async () => {
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      expect(result.current.hasAllPermissions(['read:users'])).toBe(true);
+      expect(result.current.hasAllPermissions(['nonexistent:permission'])).toBe(false);
+    });
+
+    it('handles refetch when userId is empty string', async () => {
+      const { result } = renderHook(() => usePermissions('', mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Refetch should not crash with empty userId
+      await result.current.refetch();
+
+      expect(result.current.permissions).toEqual({});
+    });
+
+    it('handles refetch when organisationId is empty', async () => {
+      const { result } = renderHook(() => usePermissions(mockUserId, '', mockEventId, mockAppId));
+
+      // Wait for timeout error
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.error).toBeInstanceOf(Error);
+      }, { timeout: 4000 });
+
+      // Refetch should handle empty organisationId
+      await result.current.refetch();
+
+      // After refetch with empty orgId, should be loading or have error
+      // The hook may set loading to false after timeout, so check for either state
+      expect(result.current.isLoading || result.current.error).toBeTruthy();
+    });
+
+    it('preserves permissions during refetch error', async () => {
+      mockGetPermissionMap
+        .mockResolvedValueOnce({ ok: true, data: mockPermissionMap })
+        .mockRejectedValueOnce(new Error('Refetch error'));
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(mockPermissionMap);
+      });
+
+      // Refetch should fail but preserve existing permissions
+      await result.current.refetch();
+
+      await waitFor(() => {
+        expect(result.current.error).toBeInstanceOf(Error);
+        // Permissions should be preserved
+        expect(result.current.permissions).toEqual(mockPermissionMap);
+      });
+    });
+
+    it('handles concurrent refetch calls', async () => {
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Call refetch multiple times concurrently
+      const refetchPromises = [
+        result.current.refetch(),
+        result.current.refetch(),
+        result.current.refetch(),
+      ];
+
+      await Promise.all(refetchPromises);
+
+      // Should handle concurrent calls gracefully
+      expect(result.current.permissions).toEqual(mockPermissionMap);
+    });
+
+    it('handles permission map with very large number of permissions', async () => {
+      const largePermissionMap: any = {};
+      for (let i = 0; i < 1000; i++) {
+        largePermissionMap[`permission:${i}`] = i % 2 === 0;
+      }
+
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: largePermissionMap });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Should handle large permission maps efficiently
+      expect(Object.keys(result.current.permissions).length).toBe(1000);
+      expect(result.current.hasPermission('permission:0')).toBe(true);
+      expect(result.current.hasPermission('permission:1')).toBe(false);
+    });
+
+    it('handles permission map transition from empty to populated', async () => {
+      mockGetPermissionMap
+        .mockResolvedValueOnce({ ok: true, data: {} })
+        .mockResolvedValueOnce({ ok: true, data: mockPermissionMap });
+
+      const { result, rerender } = renderHook(
+        ({ userId, orgId }) => usePermissions(userId, orgId, mockEventId, mockAppId),
+        {
+          initialProps: { userId: mockUserId, orgId: mockOrgId },
+        }
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual({});
+      });
+
+      // Change orgId to trigger refetch
+      rerender({ userId: mockUserId, orgId: 'org-456' });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(mockPermissionMap);
+      });
+    });
+
+    it('handles permission map transition from populated to empty', async () => {
+      mockGetPermissionMap
+        .mockResolvedValueOnce({ ok: true, data: mockPermissionMap })
+        .mockResolvedValueOnce({ ok: true, data: {} });
+
+      const { result, rerender } = renderHook(
+        ({ userId, orgId }) => usePermissions(userId, orgId, mockEventId, mockAppId),
+        {
+          initialProps: { userId: mockUserId, orgId: mockOrgId },
+        }
+      );
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual(mockPermissionMap);
+      });
+
+      // Change orgId to trigger refetch
+      rerender({ userId: mockUserId, orgId: 'org-456' });
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+        expect(result.current.permissions).toEqual({});
+      });
+    });
+
+    it('handles hasPermission with wildcard permission', async () => {
+      const wildcardPermissions = {
+        '*': true,
+        'read:users': false,
+      };
+
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: wildcardPermissions });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Wildcard should grant all permissions
+      expect(result.current.hasPermission('read:users')).toBe(true);
+      expect(result.current.hasPermission('any:permission')).toBe(true);
+    });
+
+    it('handles hasAnyPermission with wildcard permission', async () => {
+      const wildcardPermissions = {
+        '*': true,
+      };
+
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: wildcardPermissions });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Wildcard should grant all permissions
+      expect(result.current.hasAnyPermission(['read:users', 'create:users'])).toBe(true);
+    });
+
+    it('handles hasAllPermissions with wildcard permission', async () => {
+      const wildcardPermissions = {
+        '*': true,
+      };
+
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: wildcardPermissions });
+
+      const { result } = renderHook(() => usePermissions(mockUserId, mockOrgId, mockEventId, mockAppId));
+
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
+
+      // Wildcard should grant all permissions
+      expect(result.current.hasAllPermissions(['read:users', 'create:users', 'update:users'])).toBe(true);
+    });
+
+    it('handles fetch trigger increment correctly', async () => {
+      let fetchCount = 0;
+      mockGetPermissionMap.mockImplementation(() => {
+        fetchCount++;
+        return Promise.resolve({ ok: true, data: mockPermissionMap });
+      });
+
+      const { rerender } = renderHook(
+        ({ userId, orgId }) => usePermissions(userId, orgId, mockEventId, mockAppId),
+        {
+          initialProps: { userId: mockUserId, orgId: mockOrgId },
+        }
+      );
+
+      await waitFor(() => {
+        expect(fetchCount).toBeGreaterThan(0);
+      });
+
+      const initialFetchCount = fetchCount;
+
+      // Change orgId to trigger fetch
+      rerender({ userId: mockUserId, orgId: 'org-456' });
+
+      await waitFor(() => {
+        expect(fetchCount).toBeGreaterThan(initialFetchCount);
+      }, { timeout: 3000 });
+    });
+
+    it('handles error clearing when organisation context becomes available', async () => {
+      const { result, rerender } = renderHook(
+        ({ userId, orgId }) => usePermissions(userId, orgId, mockEventId, mockAppId),
+        {
+          initialProps: { userId: mockUserId, orgId: '' }, // Empty orgId
+        }
+      );
+
+      // Wait for timeout error
+      await waitFor(() => {
+        expect(result.current.error).toBeInstanceOf(Error);
+        expect(result.current.error?.message).toContain('Organisation context is required');
+      }, { timeout: 4000 });
+
+      // Provide organisation context
+      mockGetPermissionMap.mockResolvedValue({ ok: true, data: mockPermissionMap });
+      rerender({ userId: mockUserId, orgId: mockOrgId });
+
+      await waitFor(() => {
+        expect(result.current.error).toBeNull();
+        expect(result.current.permissions).toEqual(mockPermissionMap);
+      }, { timeout: 3000 });
+    });
+  });
 });