@jmruthers/pace-core 0.5.1 → 0.5.3

package/src/hooks/useOrganisationPermissions.test.ts

@@ -0,0 +1,528 @@
+/**
+ * @file useOrganisationPermissions Hook Tests
+ * @description Comprehensive tests for the useOrganisationPermissions hook
+ */
+
+import { renderHook, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { useOrganisationPermissions } from './useOrganisationPermissions';
+import { useOrganisations } from '../providers/OrganisationProvider';
+import type { Organisation, OrganisationRole, OrganisationPermission } from '../types/organisation';
+
+// Mock the OrganisationProvider
+vi.mock('../providers/OrganisationProvider', () => ({
+  useOrganisations: vi.fn()
+}));
+
+const mockUseOrganisations = vi.mocked(useOrganisations);
+
+describe('useOrganisationPermissions Hook', () => {
+  const mockOrganisation: Organisation = {
+    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'
+  };
+
+  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()
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseOrganisations.mockReturnValue(mockOrganisationContext);
+  });
+
+  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)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      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)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions('org-456'));
+
+      expect(result.current.organisationId).toBe('org-456');
+    });
+  });
+
+  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)
+      });
+
+      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);
+    });
+
+    it('handles member role correctly', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('member'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.userRole).toBe('member');
+      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('handles leader role correctly', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('leader'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.userRole).toBe('leader');
+      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)
+      });
+
+      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);
+    });
+
+    it('handles no_access role correctly', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('no_access'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(false),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      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);
+    });
+  });
+
+  describe('Permission Checking', () => {
+    it('hasPermission returns false for no access', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('no_access'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(false)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('view_basic')).toBe(false);
+      expect(result.current.hasPermission('manage_members')).toBe(false);
+    });
+
+    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)
+      });
+
+      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);
+    });
+
+    it('hasPermission returns correct permissions for member', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('member'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      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);
+    });
+
+    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)
+      });
+
+      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);
+    });
+
+    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)
+      });
+
+      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);
+    });
+
+    it('hasPermission returns true for wildcard permission for org_admin', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('org_admin'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasPermission('*')).toBe(true);
+    });
+  });
+
+  describe('getAllPermissions', () => {
+    it('returns empty array for no access', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('no_access'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(false)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual([]);
+    });
+
+    it('returns correct permissions for supporter', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('supporter'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual(['view_basic']);
+    });
+
+    it('returns correct permissions for member', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('member'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual(['view_basic', 'view_details']);
+    });
+
+    it('returns correct permissions for leader', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('leader'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual([
+        'view_basic',
+        'view_details',
+        'moderate_content',
+        'manage_events'
+      ]);
+    });
+
+    it('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)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.getAllPermissions()).toEqual([
+        'view_basic',
+        'view_details',
+        'moderate_content',
+        'manage_events',
+        'manage_members',
+        'manage_settings'
+      ]);
+    });
+  });
+
+  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)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasOrganisationAccess).toBe(false);
+    });
+
+    it('returns true when organisation access is valid', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('member'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.hasOrganisationAccess).toBe(true);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles missing organisation context gracefully', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        selectedOrganisation: null,
+        hasValidOrganisationContext: false,
+        ensureOrganisationContext: vi.fn().mockImplementation(() => {
+          throw new Error('No organisation context');
+        })
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions());
+
+      expect(result.current.organisationId).toBe('');
+      expect(result.current.userRole).toBe('no_access');
+      expect(result.current.hasOrganisationAccess).toBe(false);
+    });
+
+    it('handles invalid organisation ID', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('no_access'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(false)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions('invalid-org'));
+
+      expect(result.current.organisationId).toBe('invalid-org');
+      expect(result.current.userRole).toBe('no_access');
+      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)
+      });
+
+      const { result } = renderHook(() => useOrganisationPermissions(undefined));
+
+      expect(result.current.organisationId).toBe('org-123');
+    });
+  });
+
+  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)
+      });
+
+      const { result, rerender } = renderHook(() => useOrganisationPermissions());
+
+      const firstResult = result.current;
+      rerender();
+      const secondResult = result.current;
+
+      expect(firstResult.hasPermission).toBe(secondResult.hasPermission);
+      expect(firstResult.getAllPermissions).toBe(secondResult.getAllPermissions);
+    });
+
+    it('updates when organisation context changes', () => {
+      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)
+      });
+
+      rerender();
+
+      expect(result.current.userRole).toBe('member');
+
+      // Change role
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('leader'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      rerender();
+
+      expect(result.current.userRole).toBe('leader');
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('returns correct types for all properties', () => {
+      mockUseOrganisations.mockReturnValue({
+        ...mockOrganisationContext,
+        getUserRole: vi.fn().mockReturnValue('member'),
+        validateOrganisationAccess: vi.fn().mockReturnValue(true),
+        ensureOrganisationContext: vi.fn().mockReturnValue(mockOrganisation)
+      });
+
+      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');
+    });
+  });
+});