@jmruthers/pace-core 0.5.54 → 0.5.55

package/src/hooks/useOrganisationPermissions.test.ts

@@ -1,528 +1,438 @@
 /**
- * @file useOrganisationPermissions Hook Tests
- * @description Comprehensive tests for the useOrganisationPermissions hook
+ * @file Organisation Permissions Hook Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/useOrganisationPermissions
+ * @since 0.4.0
+ * 
+ * Comprehensive tests for the useOrganisationPermissions hook covering all critical functionality.
  */
 
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React from 'react';
+import { renderHook, waitFor } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { useOrganisationPermissions } from './useOrganisationPermissions';
 import { useOrganisations } from '../providers/OrganisationProvider';
-import type { Organisation, OrganisationRole, OrganisationPermission } from '../types/organisation';
 
-// Mock the OrganisationProvider
+// Mock the organisation provider
 vi.mock('../providers/OrganisationProvider', () => ({
   useOrganisations: vi.fn()
 }));
 
-const mockUseOrganisations = vi.mocked(useOrganisations);
+describe('useOrganisationPermissions', () => {
+  const mockUseOrganisations = vi.mocked(useOrganisations);
 
-describe('useOrganisationPermissions Hook', () => {
-  const mockOrganisation: Organisation = {
+  const mockSelectedOrganisation = {
     id: 'org-123',
-    name: 'test-org',
-    display_name: 'Test Organisation',
-    subscription_tier: 'standard',
-    settings: {},
-    is_active: true,
-    created_at: '2024-01-01T00:00:00Z',
-    updated_at: '2024-01-01T00:00:00Z'
+    name: 'Test Organisation'
   };
 
-  const mockOrganisationContext = {
-    selectedOrganisation: mockOrganisation,
-    organisations: [mockOrganisation],
-    userMemberships: [],
-    isLoading: false,
-    error: null,
-    hasValidOrganisationContext: true,
-    setSelectedOrganisation: vi.fn(),
-    switchOrganisation: vi.fn(),
-    getUserRole: vi.fn(),
-    validateOrganisationAccess: vi.fn(),
-    refreshOrganisations: vi.fn(),
-    ensureOrganisationContext: vi.fn(),
-    isOrganisationSecure: vi.fn(),
-    getPrimaryOrganisation: vi.fn()
-  };
+  // Helper function to create consistent mock setup
+  const createMockOrganisations = (overrides: any = {}) => ({
+    selectedOrganisation: mockSelectedOrganisation,
+    getUserRole: vi.fn().mockReturnValue('member'),
+    validateOrganisationAccess: vi.fn().mockReturnValue(true),
+    ensureOrganisationContext: vi.fn().mockReturnValue(mockSelectedOrganisation),
+    // Add other required properties
+    ...overrides
+  });
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockUseOrganisations.mockReturnValue(mockOrganisationContext);
+    mockUseOrganisations.mockReturnValue(createMockOrganisations() as any);
   });
 
-  describe('Initialization', () => {
-    it('initializes with no access when no organisation context', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        selectedOrganisation: null,
-        hasValidOrganisationContext: false
-      });
-
-      const { result } = renderHook(() => useOrganisationPermissions());
-
-      expect(result.current.userRole).toBe('no_access');
-      expect(result.current.hasOrganisationAccess).toBe(false);
-      expect(result.current.isOrgAdmin).toBe(false);
-      expect(result.current.isSuperAdmin).toBe(false);
-      expect(result.current.canModerate).toBe(false);
-      expect(result.current.canManageMembers).toBe(false);
-      expect(result.current.canManageSettings).toBe(false);
-      expect(result.current.canManageEvents).toBe(false);
-      expect(result.current.hasAdminPrivileges).toBe(false);
-    });
-
-    it('initializes with organisation context', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
 
+  describe('Hook Initialization', () => {
+    it('initializes with default organisation', () => {
       const { result } = renderHook(() => useOrganisationPermissions());
 
+      expect(result.current).toBeDefined();
+      expect(result.current.userRole).toBe('member');
       expect(result.current.organisationId).toBe('org-123');
       expect(result.current.hasOrganisationAccess).toBe(true);
     });
 
-    it('initializes with specific organisation ID', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true)
-      });
-
+    it('initializes with specific organisation', () => {
       const { result } = renderHook(() => useOrganisationPermissions('org-456'));
 
+      expect(result.current).toBeDefined();
       expect(result.current.organisationId).toBe('org-456');
     });
+
+    it('depends on useOrganisations hook', () => {
+      renderHook(() => useOrganisationPermissions());
+      expect(mockUseOrganisations).toHaveBeenCalled();
+    });
   });
 
-  describe('Role-based Permissions', () => {
-    it('handles supporter role correctly', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('supporter'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+  describe('Role Detection', () => {
+    it('detects org admin role', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('org_admin')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.userRole).toBe('supporter');
-      expect(result.current.isOrgAdmin).toBe(false);
-      expect(result.current.isSuperAdmin).toBe(false);
-      expect(result.current.canModerate).toBe(false);
-      expect(result.current.canManageMembers).toBe(false);
-      expect(result.current.canManageSettings).toBe(false);
-      expect(result.current.canManageEvents).toBe(false);
-      expect(result.current.hasAdminPrivileges).toBe(false);
+      expect(result.current.userRole).toBe('org_admin');
+      expect(result.current.isOrgAdmin).toBe(true);
+      expect(result.current.hasAdminPrivileges).toBe(true);
     });
 
-    it('handles member role correctly', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+    it('detects leader role', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('leader')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.userRole).toBe('member');
+      expect(result.current.userRole).toBe('leader');
       expect(result.current.isOrgAdmin).toBe(false);
-      expect(result.current.isSuperAdmin).toBe(false);
-      expect(result.current.canModerate).toBe(false);
-      expect(result.current.canManageMembers).toBe(false);
-      expect(result.current.canManageSettings).toBe(false);
-      expect(result.current.canManageEvents).toBe(false);
-      expect(result.current.hasAdminPrivileges).toBe(false);
+      expect(result.current.hasAdminPrivileges).toBe(true);
     });
 
-    it('handles leader role correctly', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('leader'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+    it('detects member role', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('member')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.userRole).toBe('leader');
+      expect(result.current.userRole).toBe('member');
       expect(result.current.isOrgAdmin).toBe(false);
-      expect(result.current.isSuperAdmin).toBe(false);
-      expect(result.current.canModerate).toBe(true);
-      expect(result.current.canManageMembers).toBe(false);
-      expect(result.current.canManageSettings).toBe(false);
-      expect(result.current.canManageEvents).toBe(true);
       expect(result.current.hasAdminPrivileges).toBe(false);
     });
 
-    it('handles org_admin role correctly', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('org_admin'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+    it('detects supporter role', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('supporter')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.userRole).toBe('org_admin');
-      expect(result.current.isOrgAdmin).toBe(true);
-      expect(result.current.isSuperAdmin).toBe(true); // org_admin acts as super admin within org
-      expect(result.current.canModerate).toBe(true);
-      expect(result.current.canManageMembers).toBe(true);
-      expect(result.current.canManageSettings).toBe(true);
-      expect(result.current.canManageEvents).toBe(true);
-      expect(result.current.hasAdminPrivileges).toBe(true);
+      expect(result.current.userRole).toBe('supporter');
+      expect(result.current.isOrgAdmin).toBe(false);
+      expect(result.current.hasAdminPrivileges).toBe(false);
     });
 
-    it('handles no_access role correctly', () => {
+    it('handles no access role', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
+        selectedOrganisation: mockSelectedOrganisation,
         getUserRole: vi.fn().mockReturnValue('no_access'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(false),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+        validateOrganisationAccess: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
       expect(result.current.userRole).toBe('no_access');
-      expect(result.current.hasOrganisationAccess).toBe(false);
       expect(result.current.isOrgAdmin).toBe(false);
-      expect(result.current.isSuperAdmin).toBe(false);
-      expect(result.current.canModerate).toBe(false);
-      expect(result.current.canManageMembers).toBe(false);
-      expect(result.current.canManageSettings).toBe(false);
-      expect(result.current.canManageEvents).toBe(false);
       expect(result.current.hasAdminPrivileges).toBe(false);
+      expect(result.current.hasOrganisationAccess).toBe(false);
     });
   });
 
-  describe('Permission Checking', () => {
-    it('hasPermission returns false for no access', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('no_access'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(false)
-      });
+  describe('Super Admin Detection', () => {
+    it('detects super admin from user metadata', () => {
+      // Mock global user context first
+      (globalThis as any).__PACE_USER__ = { 
+        app_metadata: { globalRole: 'super_admin' } 
+      };
+
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('org_admin')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasPermission('view_basic')).toBe(false);
-      expect(result.current.hasPermission('manage_members')).toBe(false);
+      expect(result.current.isSuperAdmin).toBe(true);
+      expect(result.current.hasAdminPrivileges).toBe(true);
+
+      delete (globalThis as any).__PACE_USER__;
     });
 
-    it('hasPermission returns correct permissions for supporter', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('supporter'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+    it('detects super admin from user metadata fallback', () => {
+      // Mock global user context first
+      (globalThis as any).__PACE_USER__ = { 
+        user_metadata: { globalRole: 'super_admin' } 
+      };
+
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('org_admin')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasPermission('view_basic')).toBe(true);
-      expect(result.current.hasPermission('view_details')).toBe(false);
-      expect(result.current.hasPermission('moderate_content')).toBe(false);
-      expect(result.current.hasPermission('manage_events')).toBe(false);
-      expect(result.current.hasPermission('manage_members')).toBe(false);
-      expect(result.current.hasPermission('manage_settings')).toBe(false);
+      expect(result.current.isSuperAdmin).toBe(true);
+      expect(result.current.hasAdminPrivileges).toBe(true);
+
+      delete (globalThis as any).__PACE_USER__;
     });
 
-    it('hasPermission returns correct permissions for member', () => {
+    it('returns false for non-super admin users', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
+        selectedOrganisation: mockSelectedOrganisation,
         getUserRole: vi.fn().mockReturnValue('member'),
         validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasPermission('view_basic')).toBe(true);
-      expect(result.current.hasPermission('view_details')).toBe(true);
-      expect(result.current.hasPermission('moderate_content')).toBe(false);
-      expect(result.current.hasPermission('manage_events')).toBe(false);
-      expect(result.current.hasPermission('manage_members')).toBe(false);
-      expect(result.current.hasPermission('manage_settings')).toBe(false);
+      expect(result.current.isSuperAdmin).toBe(false);
     });
+  });
 
-    it('hasPermission returns correct permissions for leader', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('leader'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+  describe('Permission Checks', () => {
+    it('checks moderation permissions for org admin', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('org_admin')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasPermission('view_basic')).toBe(true);
-      expect(result.current.hasPermission('view_details')).toBe(true);
-      expect(result.current.hasPermission('moderate_content')).toBe(true);
-      expect(result.current.hasPermission('manage_events')).toBe(true);
-      expect(result.current.hasPermission('manage_members')).toBe(false);
-      expect(result.current.hasPermission('manage_settings')).toBe(false);
+      expect(result.current.canModerate).toBe(true);
+      expect(result.current.canManageMembers).toBe(true);
+      expect(result.current.canManageSettings).toBe(true);
+      expect(result.current.canManageEvents).toBe(true);
     });
 
-    it('hasPermission returns correct permissions for org_admin', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('org_admin'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+    it('checks moderation permissions for leader', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('leader')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasPermission('view_basic')).toBe(true);
-      expect(result.current.hasPermission('view_details')).toBe(true);
-      expect(result.current.hasPermission('moderate_content')).toBe(true);
-      expect(result.current.hasPermission('manage_events')).toBe(true);
-      expect(result.current.hasPermission('manage_members')).toBe(true);
-      expect(result.current.hasPermission('manage_settings')).toBe(true);
+      expect(result.current.canModerate).toBe(true);
+      expect(result.current.canManageMembers).toBe(true);
+      expect(result.current.canManageSettings).toBe(false);
+      expect(result.current.canManageEvents).toBe(true);
     });
 
-    it('hasPermission returns true for wildcard permission for org_admin', () => {
+    it('checks moderation permissions for member', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('org_admin'),
+        selectedOrganisation: mockSelectedOrganisation,
+        getUserRole: vi.fn().mockReturnValue('member'),
         validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasPermission('*')).toBe(true);
+      expect(result.current.canModerate).toBe(false);
+      expect(result.current.canManageMembers).toBe(false);
+      expect(result.current.canManageSettings).toBe(false);
+      expect(result.current.canManageEvents).toBe(false);
     });
-  });
 
-  describe('getAllPermissions', () => {
-    it('returns empty array for no access', () => {
+    it('checks moderation permissions for supporter', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('no_access'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(false)
-      });
+        selectedOrganisation: mockSelectedOrganisation,
+        getUserRole: vi.fn().mockReturnValue('supporter'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.getAllPermissions()).toEqual([]);
+      expect(result.current.canModerate).toBe(false);
+      expect(result.current.canManageMembers).toBe(false);
+      expect(result.current.canManageSettings).toBe(false);
+      expect(result.current.canManageEvents).toBe(false);
     });
+  });
 
-    it('returns correct permissions for supporter', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('supporter'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+  describe('Permission Management', () => {
+    it('checks specific permissions', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('org_admin')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.getAllPermissions()).toEqual(['view_basic']);
+      expect(result.current.hasPermission('manage_organisation')).toBe(true);
+      expect(result.current.hasPermission('manage_members')).toBe(true);
+      expect(result.current.hasPermission('manage_events')).toBe(true);
     });
 
-    it('returns correct permissions for member', () => {
+    it('returns false for permissions user does not have', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
+        selectedOrganisation: mockSelectedOrganisation,
         getUserRole: vi.fn().mockReturnValue('member'),
         validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.getAllPermissions()).toEqual(['view_basic', 'view_details']);
+      expect(result.current.hasPermission('manage_organisation')).toBe(false);
+      expect(result.current.hasPermission('manage_members')).toBe(false);
+      expect(result.current.hasPermission('manage_events')).toBe(false);
     });
 
-    it('returns correct permissions for leader', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('leader'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+    it('gets all permissions for user', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('org_admin')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.getAllPermissions()).toEqual([
-        'view_basic',
-        'view_details',
-        'moderate_content',
-        'manage_events'
-      ]);
+      const permissions = result.current.getAllPermissions();
+      expect(Array.isArray(permissions)).toBe(true);
+      expect(permissions.length).toBeGreaterThan(0);
     });
 
-    it('returns correct permissions for org_admin', () => {
+    it('returns empty array for users with no permissions', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('org_admin'),
+        selectedOrganisation: mockSelectedOrganisation,
+        getUserRole: vi.fn().mockReturnValue('supporter'),
         validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.getAllPermissions()).toEqual([
-        'view_basic',
-        'view_details',
-        'moderate_content',
-        'manage_events',
-        'manage_members',
-        'manage_settings'
-      ]);
+      const permissions = result.current.getAllPermissions();
+      expect(Array.isArray(permissions)).toBe(true);
+      expect(permissions.length).toBe(0);
     });
   });
 
-  describe('Organisation Access Validation', () => {
-    it('returns false when organisation access is invalid', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(false)
-      });
+  describe('Organisation Access', () => {
+    it('validates organisation access for valid user', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('member')
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasOrganisationAccess).toBe(false);
+      expect(result.current.hasOrganisationAccess).toBe(true);
     });
 
-    it('returns true when organisation access is valid', () => {
+    it('denies access for invalid user', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+        selectedOrganisation: mockSelectedOrganisation,
+        getUserRole: vi.fn().mockReturnValue('no_access'),
+        validateOrganisationAccess: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.hasOrganisationAccess).toBe(true);
+      expect(result.current.hasOrganisationAccess).toBe(false);
     });
-  });
 
-  describe('Edge Cases', () => {
-    it('handles missing organisation context gracefully', () => {
+    it('handles missing organisation context', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
         selectedOrganisation: null,
-        hasValidOrganisationContext: false,
-        ensureOrganisationContext: vi.fn().mockImplementation(() => {
-          throw new Error('No organisation context');
-        })
-      });
+        getUserRole: vi.fn().mockReturnValue('no_access'),
+        validateOrganisationAccess: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.organisationId).toBe('');
-      expect(result.current.userRole).toBe('no_access');
       expect(result.current.hasOrganisationAccess).toBe(false);
+      expect(result.current.organisationId).toBe('');
     });
+  });
 
-    it('handles invalid organisation ID', () => {
+  describe('Error Handling', () => {
+    it('handles missing organisation provider gracefully', () => {
       mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
+        selectedOrganisation: null,
         getUserRole: vi.fn().mockReturnValue('no_access'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(false)
-      });
+        validateOrganisationAccess: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
 
-      const { result } = renderHook(() => useOrganisationPermissions('invalid-org'));
+      const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.organisationId).toBe('invalid-org');
-      expect(result.current.userRole).toBe('no_access');
+      expect(result.current).toBeDefined();
       expect(result.current.hasOrganisationAccess).toBe(false);
     });
 
-    it('handles undefined organisation ID parameter', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+    it('handles invalid role gracefully', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('invalid_role')
+      }) as any);
 
-      const { result } = renderHook(() => useOrganisationPermissions(undefined));
+      const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.organisationId).toBe('org-123');
+      expect(result.current.userRole).toBe('no_access');
+      expect(result.current.isOrgAdmin).toBe(false);
+      expect(result.current.hasAdminPrivileges).toBe(false);
     });
   });
 
-  describe('Memoization', () => {
-    it('maintains stable references when dependencies do not change', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
-
+  describe('Performance', () => {
+    it('memoizes results to prevent unnecessary re-renders', () => {
       const { result, rerender } = renderHook(() => useOrganisationPermissions());
-
-      const firstResult = result.current;
+      
+      // Get the initial result
+      const initialResult = result.current;
+      
+      // Re-render with same props
       rerender();
-      const secondResult = result.current;
-
-      expect(firstResult.hasPermission).toBe(secondResult.hasPermission);
-      expect(firstResult.getAllPermissions).toBe(secondResult.getAllPermissions);
+      
+      // The result should be the same object due to memoization
+      expect(result.current).toBe(initialResult);
     });
 
-    it('updates when organisation context changes', () => {
+    it('handles role changes efficiently', () => {
+      const mockGetUserRole = vi.fn().mockReturnValue('member');
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: mockGetUserRole
+      }) as any);
+
       const { result, rerender } = renderHook(() => useOrganisationPermissions());
 
-      // Initial state
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+      expect(result.current.userRole).toBe('member');
 
+      // Change role by updating the mock setup
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
+        getUserRole: vi.fn().mockReturnValue('org_admin')
+      }) as any);
       rerender();
 
-      expect(result.current.userRole).toBe('member');
+      expect(result.current.userRole).toBe('org_admin');
+      expect(result.current.isOrgAdmin).toBe(true);
+    });
+  });
 
-      // Change role
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
-        getUserRole: vi.fn().mockReturnValue('leader'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+  describe('Integration with Organisation Provider', () => {
+    it('integrates with useOrganisations hook correctly', () => {
+      renderHook(() => useOrganisationPermissions());
+      expect(mockUseOrganisations).toHaveBeenCalled();
+    });
 
-      rerender();
+    it('uses selected organisation from provider', () => {
+      const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(result.current.userRole).toBe('leader');
+      expect(result.current.organisationId).toBe('org-123');
     });
-  });
 
-  describe('Type Safety', () => {
-    it('returns correct types for all properties', () => {
-      mockUseOrganisations.mockReturnValue({
-        ...mockOrganisationContext,
+    it('uses specific organisation when provided', () => {
+      const { result } = renderHook(() => useOrganisationPermissions('org-456'));
+
+      expect(result.current.organisationId).toBe('org-456');
+    });
+
+    it('validates organisation access through provider', () => {
+      const mockValidateAccess = vi.fn().mockReturnValue(true);
+      mockUseOrganisations.mockReturnValue(createMockOrganisations({
         getUserRole: vi.fn().mockReturnValue('member'),
-        validateOrganisationAccess: vi.fn().mockReturnValue(true),
-        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
-      });
+        validateOrganisationAccess: mockValidateAccess
+      }) as any);
 
       const { result } = renderHook(() => useOrganisationPermissions());
 
-      expect(typeof result.current.userRole).toBe('string');
-      expect(typeof result.current.organisationId).toBe('string');
-      expect(typeof result.current.hasOrganisationAccess).toBe('boolean');
-      expect(typeof result.current.isOrgAdmin).toBe('boolean');
-      expect(typeof result.current.isSuperAdmin).toBe('boolean');
-      expect(typeof result.current.canModerate).toBe('boolean');
-      expect(typeof result.current.canManageMembers).toBe('boolean');
-      expect(typeof result.current.canManageSettings).toBe('boolean');
-      expect(typeof result.current.canManageEvents).toBe('boolean');
-      expect(typeof result.current.hasAdminPrivileges).toBe('boolean');
-      expect(typeof result.current.hasPermission).toBe('function');
-      expect(typeof result.current.getAllPermissions).toBe('function');
+      // The hook should call validateOrganisationAccess when checking hasOrganisationAccess
+      expect(result.current.hasOrganisationAccess).toBe(true);
+      expect(mockValidateAccess).toHaveBeenCalledWith('org-123');
     });
   });
-});
+});