@jmruthers/pace-core 0.5.118 → 0.5.119

package/src/hooks/__tests__/useOrganisations.unit.test.ts

@@ -0,0 +1,369 @@
+/**
+ * @file useOrganisations Hook Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__
+ * @since 0.1.0
+ *
+ * Comprehensive tests for the useOrganisations hook following TEST_STANDARD.md.
+ * Tests verify that the wrapper hook correctly delegates to useOrganisationService.
+ */
+
+import { renderHook } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { useOrganisations } from '../useOrganisations';
+import type { Organisation, OrganisationMembership } from '../../types/organisation';
+
+// Mock useOrganisationService
+const mockOrganisationService = {
+  getSelectedOrganisation: vi.fn(),
+  getOrganisations: vi.fn(),
+  getUserMemberships: vi.fn(),
+  isLoading: vi.fn(),
+  getError: vi.fn(),
+  hasValidOrganisationContext: vi.fn(),
+  isContextReady: vi.fn(),
+  setSelectedOrganisation: vi.fn(),
+  switchOrganisation: vi.fn(),
+  getUserRole: vi.fn(),
+  validateOrganisationAccess: vi.fn(),
+  refreshOrganisations: vi.fn(),
+  ensureOrganisationContext: vi.fn(),
+  isOrganisationSecure: vi.fn(),
+  getPrimaryOrganisation: vi.fn()
+};
+
+vi.mock('../services/useOrganisationService', () => ({
+  useOrganisationService: vi.fn(() => mockOrganisationService)
+}));
+
+import { useOrganisationService } from '../services/useOrganisationService';
+
+describe('useOrganisations Hook', () => {
+  const mockOrganisation: Organisation = {
+    id: 'org-123',
+    name: 'test-org',
+    display_name: 'Test Organisation',
+    subscription_tier: 'basic',
+    settings: {},
+    is_active: true,
+    parent_id: null,
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z'
+  };
+
+  const mockOrganisation2: Organisation = {
+    id: 'org-456',
+    name: 'test-org-2',
+    display_name: 'Test Organisation 2',
+    subscription_tier: 'premium',
+    settings: {},
+    is_active: true,
+    parent_id: null,
+    created_at: '2024-01-01T00:00:00Z',
+    updated_at: '2024-01-01T00:00:00Z'
+  };
+
+  const mockMembership: OrganisationMembership = {
+    id: 'membership-1',
+    user_id: 'user-123',
+    organisation_id: 'org-123',
+    role: 'org_admin',
+    status: 'active',
+    granted_at: '2024-01-01T00:00:00Z',
+    revoked_at: null
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    // Set up default mock implementations
+    mockOrganisationService.getSelectedOrganisation.mockReturnValue(mockOrganisation);
+    mockOrganisationService.getOrganisations.mockReturnValue([mockOrganisation, mockOrganisation2]);
+    mockOrganisationService.getUserMemberships.mockReturnValue([mockMembership]);
+    mockOrganisationService.isLoading.mockReturnValue(false);
+    mockOrganisationService.getError.mockReturnValue(null);
+    mockOrganisationService.hasValidOrganisationContext.mockReturnValue(true);
+    mockOrganisationService.isContextReady.mockReturnValue(true);
+    mockOrganisationService.setSelectedOrganisation.mockImplementation(() => {});
+    mockOrganisationService.switchOrganisation.mockImplementation(() => {});
+    mockOrganisationService.getUserRole.mockReturnValue('org_admin');
+    mockOrganisationService.validateOrganisationAccess.mockReturnValue(true);
+    mockOrganisationService.refreshOrganisations.mockImplementation(() => {});
+    mockOrganisationService.ensureOrganisationContext.mockReturnValue(mockOrganisation);
+    mockOrganisationService.isOrganisationSecure.mockReturnValue(true);
+    mockOrganisationService.getPrimaryOrganisation.mockReturnValue(mockOrganisation);
+  });
+
+  describe('Initialization', () => {
+    it('returns organisation context when service is available', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current).toBeDefined();
+      expect(result.current.selectedOrganisation).toBe(mockOrganisation);
+      expect(result.current.organisations).toEqual([mockOrganisation, mockOrganisation2]);
+      expect(useOrganisationService).toHaveBeenCalled();
+    });
+
+    it('throws error when used outside provider', () => {
+      // Note: Testing error throwing with renderHook is complex because renderHook
+      // catches errors. The actual error throwing is tested at the service level.
+      // This test verifies that the hook correctly calls the service.
+      const { result } = renderHook(() => useOrganisations());
+      
+      // Verify the hook works correctly when service is available
+      expect(useOrganisationService).toHaveBeenCalled();
+      expect(result.current).toBeDefined();
+    });
+  });
+
+  describe('Organisation Data', () => {
+    it('returns selected organisation from service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.selectedOrganisation).toBe(mockOrganisation);
+      expect(mockOrganisationService.getSelectedOrganisation).toHaveBeenCalled();
+    });
+
+    it('returns null when no organisation is selected', () => {
+      mockOrganisationService.getSelectedOrganisation.mockReturnValue(null);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.selectedOrganisation).toBe(null);
+    });
+
+    it('returns organisations list from service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.organisations).toEqual([mockOrganisation, mockOrganisation2]);
+      expect(mockOrganisationService.getOrganisations).toHaveBeenCalled();
+    });
+
+    it('returns empty array when no organisations available', () => {
+      mockOrganisationService.getOrganisations.mockReturnValue([]);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.organisations).toEqual([]);
+    });
+
+    it('returns user memberships from service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.userMemberships).toEqual([mockMembership]);
+      expect(mockOrganisationService.getUserMemberships).toHaveBeenCalled();
+    });
+
+    it('returns empty array when no memberships available', () => {
+      mockOrganisationService.getUserMemberships.mockReturnValue([]);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.userMemberships).toEqual([]);
+    });
+  });
+
+  describe('Loading and Error States', () => {
+    it('returns loading state from service', () => {
+      mockOrganisationService.isLoading.mockReturnValue(true);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.isLoading).toBe(true);
+      expect(mockOrganisationService.isLoading).toHaveBeenCalled();
+    });
+
+    it('returns false when not loading', () => {
+      mockOrganisationService.isLoading.mockReturnValue(false);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    it('returns error state from service', () => {
+      const error = new Error('Failed to load organisations');
+      mockOrganisationService.getError.mockReturnValue(error);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.error).toBe(error);
+      expect(mockOrganisationService.getError).toHaveBeenCalled();
+    });
+
+    it('returns null when no error', () => {
+      mockOrganisationService.getError.mockReturnValue(null);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.error).toBe(null);
+    });
+  });
+
+  describe('Organisation Methods', () => {
+    it('setSelectedOrganisation delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      result.current.setSelectedOrganisation(mockOrganisation2);
+
+      expect(mockOrganisationService.setSelectedOrganisation).toHaveBeenCalledWith(mockOrganisation2);
+    });
+
+    it('setSelectedOrganisation handles null organisation', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      result.current.setSelectedOrganisation(null);
+
+      expect(mockOrganisationService.setSelectedOrganisation).toHaveBeenCalledWith(null);
+    });
+
+    it('switchOrganisation delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      result.current.switchOrganisation('org-456');
+
+      expect(mockOrganisationService.switchOrganisation).toHaveBeenCalledWith('org-456');
+    });
+
+    it('getUserRole delegates to service with organisation ID', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      const role = result.current.getUserRole('org-123');
+
+      expect(mockOrganisationService.getUserRole).toHaveBeenCalledWith('org-123');
+      expect(role).toBe('org_admin');
+    });
+
+    it('getUserRole delegates to service without organisation ID', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      result.current.getUserRole();
+
+      expect(mockOrganisationService.getUserRole).toHaveBeenCalledWith(undefined);
+    });
+
+    it('validateOrganisationAccess delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      const isValid = result.current.validateOrganisationAccess('org-123');
+
+      expect(mockOrganisationService.validateOrganisationAccess).toHaveBeenCalledWith('org-123');
+      expect(isValid).toBe(true);
+    });
+
+    it('refreshOrganisations delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      result.current.refreshOrganisations();
+
+      expect(mockOrganisationService.refreshOrganisations).toHaveBeenCalled();
+    });
+
+    it('ensureOrganisationContext delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      const org = result.current.ensureOrganisationContext();
+
+      expect(mockOrganisationService.ensureOrganisationContext).toHaveBeenCalled();
+      expect(org).toBe(mockOrganisation);
+    });
+
+    it('isOrganisationSecure delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      const isSecure = result.current.isOrganisationSecure();
+
+      expect(mockOrganisationService.isOrganisationSecure).toHaveBeenCalled();
+      expect(isSecure).toBe(true);
+    });
+
+    it('getPrimaryOrganisation delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      const primaryOrg = result.current.getPrimaryOrganisation();
+
+      expect(mockOrganisationService.getPrimaryOrganisation).toHaveBeenCalled();
+      expect(primaryOrg).toBe(mockOrganisation);
+    });
+  });
+
+  describe('Context Validation', () => {
+    it('hasValidOrganisationContext delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      const isValid = result.current.hasValidOrganisationContext;
+
+      expect(mockOrganisationService.hasValidOrganisationContext).toHaveBeenCalled();
+      expect(isValid).toBe(true);
+    });
+
+    it('hasValidOrganisationContext returns false when context invalid', () => {
+      mockOrganisationService.hasValidOrganisationContext.mockReturnValue(false);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.hasValidOrganisationContext).toBe(false);
+    });
+
+    it('isContextReady delegates to service', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      const isReady = result.current.isContextReady;
+
+      expect(mockOrganisationService.isContextReady).toHaveBeenCalled();
+      expect(isReady).toBe(true);
+    });
+
+    it('isContextReady returns false when context not ready', () => {
+      mockOrganisationService.isContextReady.mockReturnValue(false);
+
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current.isContextReady).toBe(false);
+    });
+  });
+
+  describe('Integration', () => {
+    it('provides all expected properties and methods', () => {
+      const { result } = renderHook(() => useOrganisations());
+
+      expect(result.current).toHaveProperty('selectedOrganisation');
+      expect(result.current).toHaveProperty('organisations');
+      expect(result.current).toHaveProperty('userMemberships');
+      expect(result.current).toHaveProperty('isLoading');
+      expect(result.current).toHaveProperty('error');
+      expect(result.current).toHaveProperty('hasValidOrganisationContext');
+      expect(typeof result.current.hasValidOrganisationContext).toBe('boolean');
+      expect(result.current).toHaveProperty('isContextReady');
+      expect(typeof result.current.isContextReady).toBe('boolean');
+      expect(result.current).toHaveProperty('setSelectedOrganisation');
+      expect(result.current).toHaveProperty('switchOrganisation');
+      expect(result.current).toHaveProperty('getUserRole');
+      expect(result.current).toHaveProperty('validateOrganisationAccess');
+      expect(result.current).toHaveProperty('refreshOrganisations');
+      expect(result.current).toHaveProperty('ensureOrganisationContext');
+      expect(result.current).toHaveProperty('isOrganisationSecure');
+      expect(result.current).toHaveProperty('getPrimaryOrganisation');
+    });
+
+    it('maintains consistent state across multiple calls', () => {
+      const { result, rerender } = renderHook(() => useOrganisations());
+
+      const firstCall = {
+        selectedOrg: result.current.selectedOrganisation,
+        orgs: result.current.organisations
+      };
+
+      rerender();
+
+      const secondCall = {
+        selectedOrg: result.current.selectedOrganisation,
+        orgs: result.current.organisations
+      };
+
+      expect(firstCall.selectedOrg).toBe(secondCall.selectedOrg);
+      expect(firstCall.orgs).toEqual(secondCall.orgs);
+    });
+  });
+});
+