@jmruthers/pace-core 0.5.68 → 0.5.69

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

@@ -4,263 +4,498 @@
  * @module Hooks/useRBAC
  * @since 0.3.0
  * 
- * Simplified tests for the useRBAC hook focusing on core functionality.
+ * Comprehensive tests for the useRBAC hook covering all critical functionality.
  */
 
-import { renderHook } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { useRBAC } from './useRBAC';
 
-// Mock the useRBAC hook directly to avoid complex provider dependencies
-vi.mock('./useRBAC', () => ({
-  useRBAC: vi.fn()
+// Mock the providers and dependencies
+vi.mock('../../providers/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: vi.fn()
 }));
 
-import { useRBAC } from './useRBAC';
-const mockUseRBAC = vi.mocked(useRBAC);
+vi.mock('../../providers/OrganisationProvider', () => ({
+  useOrganisations: vi.fn()
+}));
+
+vi.mock('../../providers/EventProvider', () => ({
+  useEvents: vi.fn()
+}));
+
+// Mock Supabase client
+const mockSupabaseClient = {
+  rpc: vi.fn()
+};
+
+// Get the mocked functions
+import { useUnifiedAuth } from '../../providers/UnifiedAuthProvider';
+import { useOrganisations } from '../../providers/OrganisationProvider';
+import { useEvents } from '../../providers/EventProvider';
+
+const mockUseUnifiedAuth = vi.mocked(useUnifiedAuth);
+const mockUseOrganisations = vi.mocked(useOrganisations);
+const mockUseEvents = vi.mocked(useEvents);
 
 describe('useRBAC Hook', () => {
+  const mockUser = {
+    id: 'user-123',
+    email: 'test@example.com'
+  };
+
+  const mockSession = {
+    access_token: 'mock-token'
+  };
+
+  const mockOrganisation = {
+    id: 'org-123',
+    name: 'Test Organisation'
+  };
+
+  const mockEvent = {
+    id: 'event-123',
+    name: 'Test Event'
+  };
+
   beforeEach(() => {
     vi.clearAllMocks();
+    
+    // Setup default mocks
+    mockUseUnifiedAuth.mockReturnValue({
+      user: null,
+      session: null,
+      supabase: mockSupabaseClient,
+      appName: 'test-app'
+    });
+    
+    mockUseOrganisations.mockReturnValue({
+      selectedOrganisation: null
+    });
+    
+    mockUseEvents.mockReturnValue({
+      selectedEvent: null
+    });
   });
 
-  describe('Initialization', () => {
-    it('initializes with loading state', () => {
-      mockUseRBAC.mockReturnValue({
-        user: null,
-        isAuthenticated: false,
-        isLoading: true,
-        globalRole: null,
-        organisationRole: null,
-        eventAppRole: null,
-        hasPermission: vi.fn(() => false),
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: false,
-        error: null,
-      });
-
+    describe('Initialization', () => {
+    it('initializes with loading state when no user', () => {
       const { result } = renderHook(() => useRBAC());
       
-      expect(result.current.isLoading).toBe(true);
-      expect(result.current.isAuthenticated).toBe(false);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.user).toBeNull();
       expect(result.current.globalRole).toBeNull();
       expect(result.current.organisationRole).toBeNull();
       expect(result.current.eventAppRole).toBeNull();
       expect(result.current.error).toBeNull();
     });
 
-    it('initializes with authenticated state', () => {
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'test@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'user',
-        organisationRole: 'member',
-        eventAppRole: 'participant',
-        hasPermission: vi.fn(() => true),
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: false,
-        error: null,
+    it('initializes with authenticated state', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      mockUseEvents.mockReturnValue({
+        selectedEvent: mockEvent
+      });
+
+      // Mock successful RPC calls
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'all_permissions', role_name: 'super_admin' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
       
-      expect(result.current.isLoading).toBe(false);
-      expect(result.current.isAuthenticated).toBe(true);
-      expect(result.current.user?.id).toBe('user-123');
-      expect(result.current.globalRole).toBe('user');
-      expect(result.current.organisationRole).toBe('member');
-      expect(result.current.eventAppRole).toBe('participant');
+      expect(result.current.user).toEqual(mockUser);
+      
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
     });
   });
 
   describe('Role Detection', () => {
-    it('detects super admin role', () => {
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'admin@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'super_admin',
-        organisationRole: 'org_admin',
-        eventAppRole: 'event_admin',
-        hasPermission: vi.fn(() => true),
-        hasGlobalPermission: vi.fn(() => true),
-        isSuperAdmin: true,
-        isOrgAdmin: true,
-        error: null,
+    it('detects super admin role from RPC response', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock super admin RPC response
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'all_permissions', role_name: 'super_admin' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
-      
-      expect(result.current.globalRole).toBe('super_admin');
-      expect(result.current.isSuperAdmin).toBe(true);
+
+      await waitFor(() => {
+        expect(result.current.globalRole).toBe('super_admin');
+        expect(result.current.isSuperAdmin).toBe(true);
+      });
     });
 
-    it('detects organisation roles', () => {
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'admin@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'user',
-        organisationRole: 'org_admin',
-        eventAppRole: 'participant',
-        hasPermission: vi.fn(() => true),
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: true,
-        error: null,
+    it('detects organisation admin role', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock org admin RPC response
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'organisation_access', role_name: 'org_admin' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
-      
-      expect(result.current.organisationRole).toBe('org_admin');
-      expect(result.current.isOrgAdmin).toBe(true);
+
+      await waitFor(() => {
+        expect(result.current.organisationRole).toBe('org_admin');
+        expect(result.current.isOrgAdmin).toBe(true);
+      });
     });
 
-    it('detects event app roles', () => {
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'planner@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'user',
-        organisationRole: 'member',
-        eventAppRole: 'planner',
-        hasPermission: vi.fn(() => true),
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: false,
-        error: null,
+    it('detects event admin role', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      mockUseEvents.mockReturnValue({
+        selectedEvent: mockEvent
+      });
+
+      // Mock event admin RPC response
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'event_app_access', role_name: 'event_admin' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
-      
-      expect(result.current.eventAppRole).toBe('planner');
+
+      await waitFor(() => {
+        expect(result.current.eventAppRole).toBe('event_admin');
+        expect(result.current.isEventAdmin).toBe(true);
+      });
     });
 
-    it('handles role hierarchy correctly', () => {
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'admin@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'super_admin',
-        organisationRole: 'org_admin',
-        eventAppRole: 'event_admin',
-        hasPermission: vi.fn(() => true),
-        hasGlobalPermission: vi.fn(() => true),
-        isSuperAdmin: true,
-        isOrgAdmin: true,
-        error: null,
+    it('handles role hierarchy correctly', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      mockUseEvents.mockReturnValue({
+        selectedEvent: mockEvent
+      });
+
+      // Mock super admin with all roles
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [
+              { permission_type: 'all_permissions', role_name: 'super_admin' },
+              { permission_type: 'organisation_access', role_name: 'org_admin' },
+              { permission_type: 'event_app_access', role_name: 'event_admin' }
+            ],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
-      
-      expect(result.current.isSuperAdmin).toBe(true);
-      expect(result.current.isOrgAdmin).toBe(true);
+
+      await waitFor(() => {
+        expect(result.current.globalRole).toBe('super_admin');
+        expect(result.current.organisationRole).toBe('org_admin');
+        expect(result.current.eventAppRole).toBe('event_admin');
+        expect(result.current.isSuperAdmin).toBe(true);
+        expect(result.current.isOrgAdmin).toBe(true);
+        expect(result.current.isEventAdmin).toBe(true);
+      });
     });
   });
 
   describe('Permission Checking', () => {
-    it('hasPermission returns true for super admin', () => {
-      const mockHasPermission = vi.fn(() => true);
-      
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'admin@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'super_admin',
-        organisationRole: 'org_admin',
-        eventAppRole: 'event_admin',
-        hasPermission: mockHasPermission,
-        hasGlobalPermission: vi.fn(() => true),
-        isSuperAdmin: true,
-        isOrgAdmin: true,
-        error: null,
+    it('hasPermission returns true for super admin', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock super admin RPC response
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'all_permissions', role_name: 'super_admin' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
-      
-      expect(result.current.isSuperAdmin).toBe(true);
-      
-      const canRead = result.current.hasPermission('read:users');
+
+      await waitFor(() => {
+        expect(result.current.isSuperAdmin).toBe(true);
+      });
+
+      // Test hasPermission function
+      const canRead = await result.current.hasPermission('read', 'users');
       expect(canRead).toBe(true);
-      expect(mockHasPermission).toHaveBeenCalledWith('read:users');
     });
 
-    it('hasPermission checks database for regular users', () => {
-      const mockHasPermission = vi.fn(() => false);
-      
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'user@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'user',
-        organisationRole: 'member',
-        eventAppRole: 'participant',
-        hasPermission: mockHasPermission,
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: false,
-        error: null,
+    it('hasPermission checks database for regular users', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock regular user RPC response
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'organisation_access', role_name: 'member' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
-      
-      expect(result.current.organisationRole).toBe('member');
-      
-      const canDelete = result.current.hasPermission('delete:users');
+
+      await waitFor(() => {
+        expect(result.current.organisationRole).toBe('member');
+      });
+
+      // Test hasPermission function
+      const canDelete = await result.current.hasPermission('delete', 'users');
       expect(canDelete).toBe(false);
-      expect(mockHasPermission).toHaveBeenCalledWith('delete:users');
     });
 
-    it('hasPermission handles errors gracefully', () => {
-      const mockHasPermission = vi.fn(() => false);
-      
-      mockUseRBAC.mockReturnValue({
-        user: { id: 'user-123', email: 'user@example.com' },
-        isAuthenticated: true,
-        isLoading: false,
-        globalRole: 'user',
-        organisationRole: 'member',
-        eventAppRole: 'participant',
-        hasPermission: mockHasPermission,
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: false,
-        error: new Error('Permission check failed'),
+    it('hasGlobalPermission works correctly', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock super admin RPC response
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'all_permissions', role_name: 'super_admin' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
       });
 
       const { result } = renderHook(() => useRBAC());
+
+      await waitFor(() => {
+        expect(result.current.globalRole).toBe('super_admin');
+      });
+
+      // Test hasGlobalPermission function
+      expect(result.current.hasGlobalPermission('super_admin')).toBe(true);
+      expect(result.current.hasGlobalPermission('org_admin')).toBe(true);
+      expect(result.current.hasGlobalPermission('invalid_permission')).toBe(true); // Super admin has all permissions
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('handles RPC errors gracefully', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock RPC error
+      mockSupabaseClient.rpc.mockRejectedValue(new Error('RPC Error'));
+
+      const { result } = renderHook(() => useRBAC());
+
+      await waitFor(() => {
+        expect(result.current.error).toBeDefined();
+        expect(result.current.isLoading).toBe(false);
+      });
+    });
+
+    it('handles missing EventProvider gracefully', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock EventProvider throwing error
+      mockUseEvents.mockImplementation(() => {
+        throw new Error('EventProvider not available');
+      });
+
+      // Mock successful RPC calls
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [{ permission_type: 'all_permissions', role_name: 'super_admin' }],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
+      });
+
+      const { result } = renderHook(() => useRBAC());
+
+      // Should not throw error and continue without event context
+      expect(result.current.user).toEqual(mockUser);
       
-      expect(result.current.organisationRole).toBe('member');
-      expect(result.current.error).toBeTruthy();
-      
-      const canRead = result.current.hasPermission('read:users');
-      expect(canRead).toBe(false);
+      await waitFor(() => {
+        expect(result.current.isLoading).toBe(false);
+      });
     });
   });
 
   describe('Hook Properties', () => {
     it('has all required properties', () => {
-      mockUseRBAC.mockReturnValue({
-        user: null,
-        isAuthenticated: false,
-        isLoading: false,
-        globalRole: null,
-        organisationRole: null,
-        eventAppRole: null,
-        hasPermission: vi.fn(() => false),
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: false,
-        error: null,
-      });
-
       const { result } = renderHook(() => useRBAC());
       
       expect(result.current).toHaveProperty('user');
-      expect(result.current).toHaveProperty('isAuthenticated');
-      expect(result.current).toHaveProperty('isLoading');
       expect(result.current).toHaveProperty('globalRole');
       expect(result.current).toHaveProperty('organisationRole');
       expect(result.current).toHaveProperty('eventAppRole');
@@ -268,28 +503,67 @@ describe('useRBAC Hook', () => {
       expect(result.current).toHaveProperty('hasGlobalPermission');
       expect(result.current).toHaveProperty('isSuperAdmin');
       expect(result.current).toHaveProperty('isOrgAdmin');
+      expect(result.current).toHaveProperty('isEventAdmin');
+      expect(result.current).toHaveProperty('canManageOrganisation');
+      expect(result.current).toHaveProperty('canManageEvent');
+      expect(result.current).toHaveProperty('isLoading');
       expect(result.current).toHaveProperty('error');
     });
 
     it('hasPermission is a function', () => {
-      mockUseRBAC.mockReturnValue({
-        user: null,
-        isAuthenticated: false,
-        isLoading: false,
-        globalRole: null,
-        organisationRole: null,
-        eventAppRole: null,
-        hasPermission: vi.fn(() => false),
-        hasGlobalPermission: vi.fn(() => false),
-        isSuperAdmin: false,
-        isOrgAdmin: false,
-        error: null,
-      });
-
       const { result } = renderHook(() => useRBAC());
       
       expect(typeof result.current.hasPermission).toBe('function');
       expect(typeof result.current.hasGlobalPermission).toBe('function');
     });
+
+    it('computed properties work correctly', async () => {
+      mockUseUnifiedAuth.mockReturnValue({
+        user: mockUser,
+        session: mockSession,
+        supabase: mockSupabaseClient,
+        appName: 'test-app'
+      });
+
+      mockUseOrganisations.mockReturnValue({
+        selectedOrganisation: mockOrganisation
+      });
+
+      // Mock super admin RPC response
+      mockSupabaseClient.rpc.mockImplementation((functionName: string) => {
+        if (functionName === 'util_app_resolve') {
+          return Promise.resolve({
+            data: [{ app_id: 'test-app-id', has_access: true }],
+            error: null
+          });
+        }
+        if (functionName === 'rbac_permissions_get') {
+          return Promise.resolve({
+            data: [
+              { permission_type: 'all_permissions', role_name: 'super_admin' },
+              { permission_type: 'organisation_access', role_name: 'org_admin' },
+              { permission_type: 'event_app_access', role_name: 'event_admin' }
+            ],
+            error: null
+          });
+        }
+        return Promise.resolve({ data: null, error: null });
+      });
+
+      const { result } = renderHook(() => useRBAC());
+
+      await waitFor(() => {
+        expect(result.current.globalRole).toBe('super_admin');
+        expect(result.current.organisationRole).toBe('org_admin');
+        expect(result.current.eventAppRole).toBe('event_admin');
+      });
+
+      // Test computed properties
+      expect(result.current.isSuperAdmin).toBe(true);
+      expect(result.current.isOrgAdmin).toBe(true);
+      expect(result.current.isEventAdmin).toBe(true);
+      expect(result.current.canManageOrganisation).toBe(true);
+      expect(result.current.canManageEvent).toBe(true);
+    });
   });
 });