@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/services/__tests__/OrganisationService.test.ts

@@ -1,1176 +0,0 @@
-/**
- * @file OrganisationService Unit Tests
- * @package @jmruthers/pace-core
- * @module Services/__tests__
- * @since 0.1.0
- *
- * Unit tests for OrganisationService class.
- * Tests organisation management, selection, and context operations.
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { OrganisationService } from '../OrganisationService';
-import { Organisation, OrganisationMembership } from '../../types/organisation';
-
-// Mock Supabase client
-const createMockSupabaseClient = () => ({
-  rpc: vi.fn(),
-  from: vi.fn(),
-});
-
-// Mock user and session
-const mockUser = {
-  id: 'user-1',
-  email: 'test@example.com'
-};
-
-const mockSession = {
-  access_token: 'token',
-  user: mockUser
-};
-
-const mockOrganisation: Organisation = {
-  id: 'org-1',
-  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-2',
-  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-1',
-  organisation_id: 'org-1',
-  role: 'org_admin',
-  status: 'active',
-  granted_at: '2024-01-01T00:00:00Z',
-  revoked_at: null
-};
-
-const mockMembership2: OrganisationMembership = {
-  id: 'membership-2',
-  user_id: 'user-1',
-  organisation_id: 'org-2',
-  role: 'member',
-  status: 'active',
-  granted_at: '2024-01-01T00:00:00Z',
-  revoked_at: null
-};
-
-// Mock the organisationContext utility
-vi.mock('../../utils/context/organisationContext', () => ({
-  setOrganisationContext: vi.fn().mockResolvedValue(undefined)
-}));
-
-describe('OrganisationService', () => {
-  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
-  let organisationService: OrganisationService;
-
-  beforeEach(() => {
-    mockSupabase = createMockSupabaseClient();
-    
-    // Set up default mocks
-    mockSupabase.rpc.mockResolvedValue({
-      data: [mockMembership, mockMembership2],
-      error: null
-    });
-
-    // Mock the from().select() chain to return organisations
-    // The select() method should return a promise that resolves to { data, error }
-    mockSupabase.from.mockImplementation((table: string) => {
-      if (table === 'core_organisations') {
-        return {
-          select: vi.fn().mockResolvedValue({
-            data: [mockOrganisation, mockOrganisation2],
-            error: null
-          })
-        };
-      }
-      return {
-        select: vi.fn().mockResolvedValue({ data: [], error: null })
-      };
-    });
-
-    organisationService = new OrganisationService(
-      mockSupabase as any,
-      mockUser,
-      mockSession
-    );
-  });
-
-  afterEach(() => {
-    organisationService.cleanup();
-    vi.clearAllMocks();
-    // Clear localStorage
-    localStorage.clear();
-  });
-
-  describe('Initialization', () => {
-    it('should initialize with default state', () => {
-      expect(organisationService.getSelectedOrganisation()).toBeNull();
-      expect(organisationService.getOrganisations()).toEqual([]);
-      expect(organisationService.getUserMemberships()).toEqual([]);
-      expect(organisationService.isLoading()).toBe(false);
-      expect(organisationService.getError()).toBeNull();
-      expect(organisationService.hasValidOrganisationContext()).toBe(false);
-    });
-
-    it('should load user organisations on initialization', async () => {
-      // Mock the direct query to rbac_organisation_roles with join
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockResolvedValue({
-          data: [{
-            id: mockMembership.id,
-            user_id: mockUser.id,
-            organisation_id: mockOrganisation.id,
-            role: mockMembership.role,
-            status: mockMembership.status,
-            granted_at: mockMembership.granted_at,
-            revoked_at: mockMembership.revoked_at,
-            core_organisations: mockOrganisation
-          }],
-          error: null
-        })
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(mockSupabase.from).toHaveBeenCalledWith('rbac_organisation_roles');
-      expect(mockQueryBuilder.eq).toHaveBeenCalledWith('user_id', mockUser.id);
-      expect(mockQueryBuilder.eq).toHaveBeenCalledWith('status', 'active');
-      expect(mockQueryBuilder.is).toHaveBeenCalledWith('revoked_at', null);
-    });
-
-    it('should handle missing dependencies gracefully', async () => {
-      const serviceWithoutUser = new OrganisationService(
-        mockSupabase as any,
-        null,
-        null
-      );
-
-      await serviceWithoutUser.initialize();
-
-      expect(serviceWithoutUser.getOrganisations()).toEqual([]);
-      expect(serviceWithoutUser.isLoading()).toBe(false);
-    });
-  });
-
-  describe('Organisation Operations', () => {
-    beforeEach(() => {
-      // Manually set up test state
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      roleMap.set('org-2', 'member');
-      
-      organisationService.setTestState(
-        [mockOrganisation, mockOrganisation2],
-        [mockMembership, mockMembership2],
-        roleMap,
-        mockOrganisation
-      );
-    });
-
-    it('should set selected organisation', () => {
-      organisationService.setSelectedOrganisation(mockOrganisation);
-
-      expect(organisationService.getSelectedOrganisation()).toEqual(mockOrganisation);
-      expect(localStorage.getItem('pace-core-selected-organisation')).toBe(
-        JSON.stringify(mockOrganisation)
-      );
-    });
-
-    it('should clear selected organisation', () => {
-      organisationService.setSelectedOrganisation(mockOrganisation);
-      expect(organisationService.getSelectedOrganisation()).toEqual(mockOrganisation);
-
-      organisationService.setSelectedOrganisation(null);
-
-      expect(organisationService.getSelectedOrganisation()).toBeNull();
-      expect(localStorage.getItem('pace-core-selected-organisation')).toBeNull();
-    });
-
-    it('should refresh organisations', async () => {
-      // First initialize the service to set up the basic state
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockResolvedValue({
-          data: [{
-            id: mockMembership.id,
-            user_id: mockUser.id,
-            organisation_id: mockOrganisation.id,
-            role: mockMembership.role,
-            status: mockMembership.status,
-            granted_at: mockMembership.granted_at,
-            revoked_at: mockMembership.revoked_at,
-            core_organisations: mockOrganisation
-          }],
-          error: null
-        })
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-      
-      const newMembership: OrganisationMembership = {
-        ...mockMembership,
-        id: 'membership-3',
-        organisation_id: 'org-3'
-      };
-
-      const newOrg: Organisation = {
-        id: 'org-3',
-        name: 'test-org-3',
-        display_name: 'Test Organisation 3',
-        subscription_tier: 'basic',
-        settings: {},
-        is_active: true,
-        parent_id: null,
-        created_at: '2024-01-01T00:00:00Z',
-        updated_at: '2024-01-01T00:00:00Z'
-      };
-
-      // Update mock for refresh
-      mockQueryBuilder.is.mockResolvedValue({
-        data: [
-          {
-            id: mockMembership.id,
-            user_id: mockUser.id,
-            organisation_id: mockOrganisation.id,
-            role: mockMembership.role,
-            status: mockMembership.status,
-            granted_at: mockMembership.granted_at,
-            revoked_at: mockMembership.revoked_at,
-            core_organisations: mockOrganisation
-          },
-          {
-            id: mockMembership2.id,
-            user_id: mockUser.id,
-            organisation_id: mockOrganisation2.id,
-            role: mockMembership2.role,
-            status: mockMembership2.status,
-            granted_at: mockMembership2.granted_at,
-            revoked_at: mockMembership2.revoked_at,
-            core_organisations: mockOrganisation2
-          },
-          {
-            id: newMembership.id,
-            user_id: mockUser.id,
-            organisation_id: newOrg.id,
-            role: newMembership.role,
-            status: newMembership.status,
-            granted_at: newMembership.granted_at,
-            revoked_at: newMembership.revoked_at,
-            core_organisations: newOrg
-          }
-        ],
-        error: null
-      });
-
-      await organisationService.refreshOrganisations();
-
-      expect(mockSupabase.from).toHaveBeenCalledWith('rbac_organisation_roles');
-      
-      // Verify the refresh was called and state was updated
-      expect(organisationService.getOrganisations().length).toBeGreaterThanOrEqual(1);
-    });
-
-    it('should ensure organisation context', () => {
-      organisationService.setSelectedOrganisation(mockOrganisation);
-
-      const context = organisationService.ensureOrganisationContext();
-      expect(context).toEqual(mockOrganisation);
-    });
-
-    it('should throw error when ensuring context without organisation', () => {
-      // Clear the selected organisation first
-      organisationService.setSelectedOrganisation(null);
-      
-      expect(() => {
-        organisationService.ensureOrganisationContext();
-      }).toThrow('Organisation context is required but not available');
-    });
-  });
-
-  describe('User Role Management', () => {
-    beforeEach(() => {
-      // Manually set up test state instead of relying on initialize()
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      roleMap.set('org-2', 'member');
-      
-      organisationService.setTestState(
-        [mockOrganisation, mockOrganisation2],
-        [mockMembership, mockMembership2],
-        roleMap,
-        mockOrganisation
-      );
-    });
-
-    it('should get user role for selected organisation', () => {
-      const role = organisationService.getUserRole();
-      expect(role).toBe('org_admin');
-    });
-
-    it('should get user role for specific organisation', () => {
-      const role = organisationService.getUserRole('org-2');
-      expect(role).toBe('member');
-    });
-
-    it('should return no_access for unknown organisation', () => {
-      const role = organisationService.getUserRole('unknown-org');
-      expect(role).toBe('no_access');
-    });
-
-    it('should validate organisation access', () => {
-      expect(organisationService.validateOrganisationAccess('org-1')).toBe(true);
-      expect(organisationService.validateOrganisationAccess('org-2')).toBe(true);
-      expect(organisationService.validateOrganisationAccess('unknown-org')).toBe(false);
-    });
-  });
-
-  describe('Organisation Switching', () => {
-    beforeEach(() => {
-      // Manually set up test state instead of relying on initialize()
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      roleMap.set('org-2', 'member');
-      
-      organisationService.setTestState(
-        [mockOrganisation, mockOrganisation2],
-        [mockMembership, mockMembership2],
-        roleMap,
-        mockOrganisation
-      );
-    });
-
-    it('should switch to valid organisation', async () => {
-      await organisationService.switchOrganisation('org-2');
-
-      expect(organisationService.getSelectedOrganisation()).toEqual(mockOrganisation2);
-    });
-
-    it('should throw error when switching to invalid organisation', async () => {
-      await expect(organisationService.switchOrganisation('unknown-org')).rejects.toThrow(
-        'User does not have access to organisation unknown-org'
-      );
-    });
-
-    it('should throw error when switching to non-existent organisation', async () => {
-      // Create a membership for org-999 but don't include the organisation in the organisations list
-      const membershipForNonExistentOrg: OrganisationMembership = {
-        id: 'membership-999',
-        user_id: 'user-1',
-        organisation_id: 'org-999',
-        role: 'member',
-        status: 'active',
-        granted_at: '2024-01-01T00:00:00Z',
-        revoked_at: null
-      };
-      
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      roleMap.set('org-2', 'member');
-      roleMap.set('org-999', 'member');
-      
-      organisationService.setTestState(
-        [mockOrganisation, mockOrganisation2], // Only include org-1 and org-2, not org-999
-        [mockMembership, mockMembership2, membershipForNonExistentOrg],
-        roleMap,
-        mockOrganisation
-      );
-      
-      await expect(organisationService.switchOrganisation('org-999')).rejects.toThrow(
-        'Organisation org-999 not found in user\'s organisations'
-      );
-    });
-  });
-
-  describe('Organisation Security', () => {
-    beforeEach(() => {
-      // Manually set up test state instead of relying on initialize()
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      roleMap.set('org-2', 'member');
-      
-      organisationService.setTestState(
-        [mockOrganisation, mockOrganisation2],
-        [mockMembership, mockMembership2],
-        roleMap,
-        mockOrganisation
-      );
-    });
-
-    it('should check if organisation is secure', () => {
-      organisationService.setSelectedOrganisation(mockOrganisation);
-
-      expect(organisationService.isOrganisationSecure()).toBe(true);
-    });
-
-    it('should return false when no organisation selected', () => {
-      organisationService.setSelectedOrganisation(null);
-      expect(organisationService.isOrganisationSecure()).toBe(false);
-    });
-
-    it('should get primary organisation by role priority', () => {
-      const primaryOrg = organisationService.getPrimaryOrganisation();
-      expect(primaryOrg).toEqual(mockOrganisation); // Should be org_admin role
-    });
-
-    it('should return null when no memberships', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: [],
-        error: null
-      });
-
-      const service = new OrganisationService(
-        mockSupabase as any,
-        mockUser,
-        mockSession
-      );
-
-      await service.initialize();
-
-      expect(service.getPrimaryOrganisation()).toBeNull();
-    });
-  });
-
-  describe('Persistence', () => {
-    it('should persist selected organisation', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: [mockMembership],
-        error: null
-      });
-
-      mockSupabase.from.mockReturnValue({
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        single: vi.fn().mockResolvedValue({
-          data: [mockOrganisation],
-          error: null
-        })
-      });
-
-      await organisationService.initialize();
-
-      organisationService.setSelectedOrganisation(mockOrganisation);
-
-      expect(localStorage.getItem('pace-core-selected-organisation')).toBe(
-        JSON.stringify(mockOrganisation)
-      );
-    });
-
-    it('should restore persisted organisation on initialization', async () => {
-      // Set up persisted organisation
-      localStorage.setItem('pace-core-selected-organisation', JSON.stringify(mockOrganisation));
-
-      const service = new OrganisationService(
-        mockSupabase as any,
-        mockUser,
-        mockSession
-      );
-
-      // Set up the test state manually instead of relying on complex mocks
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      
-      service.setTestState(
-        [mockOrganisation],
-        [mockMembership],
-        roleMap,
-        mockOrganisation // This should be restored from localStorage
-      );
-
-      // Don't call initialize() since it's not working with mocks
-      // Just verify that the setTestState method works correctly
-      expect(service.getSelectedOrganisation()).toEqual(mockOrganisation);
-    });
-
-    it('should handle invalid persisted organisation', async () => {
-      // Set up invalid persisted organisation
-      localStorage.setItem('pace-core-selected-organisation', 'invalid-json');
-
-      const service = new OrganisationService(
-        mockSupabase as any,
-        mockUser,
-        mockSession
-      );
-
-      // Set up the test state manually instead of relying on complex mocks
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      
-      service.setTestState(
-        [mockOrganisation],
-        [mockMembership],
-        roleMap,
-        mockOrganisation // Should fall back to first available organisation
-      );
-
-      // Don't call initialize() since it's not working with mocks
-      // Just verify that the setTestState method works correctly
-      expect(service.getSelectedOrganisation()).toEqual(mockOrganisation);
-    });
-  });
-
-  describe('State Management', () => {
-    it('should notify subscribers when state changes', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: [mockMembership],
-        error: null
-      });
-
-      mockSupabase.from.mockReturnValue({
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        single: vi.fn().mockResolvedValue({
-          data: [mockOrganisation],
-          error: null
-        })
-      });
-
-      const subscriber = vi.fn();
-      const unsubscribe = organisationService.subscribe(subscriber);
-
-      await organisationService.initialize();
-
-      expect(subscriber).toHaveBeenCalled();
-
-      unsubscribe();
-    });
-
-    it('should cleanup subscriptions on cleanup', () => {
-      const subscriber = vi.fn();
-      organisationService.subscribe(subscriber);
-
-      organisationService.cleanup();
-
-      // After cleanup, new state changes shouldn't notify subscribers
-      organisationService.setSelectedOrganisation(mockOrganisation);
-
-      expect(subscriber).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle RPC errors gracefully', async () => {
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockResolvedValue({
-          data: null,
-          error: { message: 'RPC error', code: 'PGRST_ERROR' }
-        })
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(organisationService.getError()).toBeDefined();
-      // The error object is thrown, so check the message property
-      const error = organisationService.getError();
-      expect(error).toBeDefined();
-      if (error && typeof error === 'object' && 'message' in error) {
-        expect((error as any).message).toBe('RPC error');
-      } else {
-        expect(String(error)).toContain('RPC error');
-      }
-      expect(organisationService.getOrganisations()).toEqual([]);
-    });
-
-    it('should handle network errors', async () => {
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockRejectedValue(new Error('Network error'))
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(organisationService.getError()).toBeDefined();
-      expect(organisationService.getError()?.message).toBe('Network error');
-    });
-
-    it('should handle no memberships error', async () => {
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockResolvedValue({
-          data: [],
-          error: null
-        })
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(organisationService.getError()).toBeDefined();
-      expect(organisationService.getError()?.message).toBe('User has no active organisation memberships');
-    });
-
-    it('should handle invalid organisation IDs', async () => {
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockResolvedValue({
-          data: [{
-            id: mockMembership.id,
-            user_id: mockUser.id,
-            organisation_id: 'invalid-id', // Invalid UUID
-            role: mockMembership.role,
-            status: mockMembership.status,
-            granted_at: mockMembership.granted_at,
-            revoked_at: mockMembership.revoked_at,
-            core_organisations: null // No organisation data due to invalid ID
-          }],
-          error: null
-        })
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(organisationService.getError()).toBeDefined();
-      // The service will throw "No organisations found in role data" when organisations array is empty
-      expect(organisationService.getError()?.message).toContain('No organisations found');
-    });
-
-    it('should handle no active organisations', async () => {
-      const inactiveOrg = { ...mockOrganisation, is_active: false };
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockResolvedValue({
-          data: [{
-            id: mockMembership.id,
-            user_id: mockUser.id,
-            organisation_id: mockOrganisation.id,
-            role: mockMembership.role,
-            status: mockMembership.status,
-            granted_at: mockMembership.granted_at,
-            revoked_at: mockMembership.revoked_at,
-            core_organisations: inactiveOrg
-          }],
-          error: null
-        })
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(organisationService.getError()).toBeDefined();
-      expect(organisationService.getError()?.message).toBe('User has no access to active organisations');
-    });
-  });
-
-  describe('Auto-selection', () => {
-    it('should auto-select admin organisation when available', async () => {
-      // Set up test state manually instead of relying on complex mocks
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'org_admin');
-      roleMap.set('org-2', 'member');
-      
-      organisationService.setTestState(
-        [mockOrganisation, mockOrganisation2],
-        [mockMembership, mockMembership2],
-        roleMap,
-        mockOrganisation // Should auto-select the admin organisation
-      );
-
-      // Should auto-select the admin organisation
-      expect(organisationService.getSelectedOrganisation()).toEqual(mockOrganisation);
-    });
-
-    it('should fall back to first organisation when no admin', async () => {
-      const memberMembership = { ...mockMembership, role: 'member' };
-      
-      // Set up test state manually instead of relying on complex mocks
-      const roleMap = new Map<string, string>();
-      roleMap.set('org-1', 'member');
-      
-      organisationService.setTestState(
-        [mockOrganisation],
-        [memberMembership],
-        roleMap,
-        mockOrganisation // Should fall back to first available organisation
-      );
-
-      // Should fall back to first available organisation
-      expect(organisationService.getSelectedOrganisation()).toEqual(mockOrganisation);
-    });
-  });
-
-  describe('Dependency Updates', () => {
-    it('should update dependencies when user changes', () => {
-      const newUser = { id: 'user-2', email: 'new@example.com' };
-      const newSession = { access_token: 'new-token', user: newUser };
-
-      organisationService.updateDependencies(newUser, newSession);
-
-      const deps = organisationService.getDependencies();
-      expect(deps.user).toEqual(newUser);
-      expect(deps.session).toEqual(newSession);
-    });
-
-    it('should reset initialization state when user logs out', () => {
-      // Set up authenticated state
-      organisationService.updateDependencies(mockUser, mockSession);
-
-      // Log out
-      organisationService.updateDependencies(null, null);
-
-      // Should allow re-initialization when user logs back in
-      const deps = organisationService.getDependencies();
-      expect(deps.user).toBeNull();
-      expect(deps.session).toBeNull();
-    });
-  });
-
-  describe('Organisation Hierarchy', () => {
-    it('should build organisation hierarchy', () => {
-      const orgs = [mockOrganisation, mockOrganisation2];
-      const hierarchy = organisationService.buildOrganisationHierarchy(orgs);
-
-      expect(hierarchy).toBeDefined();
-      expect(Array.isArray(hierarchy)).toBe(true);
-      // Should return root organisations (those without parent_id)
-      expect(hierarchy.length).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should handle empty organisation list in hierarchy', () => {
-      const hierarchy = organisationService.buildOrganisationHierarchy([]);
-
-      expect(hierarchy).toEqual([]);
-    });
-  });
-
-  describe('Database Context', () => {
-    it('should handle database context setting timeout', async () => {
-      vi.useFakeTimers();
-      
-      const { setOrganisationContext } = await import('../../utils/context/organisationContext');
-      vi.mocked(setOrganisationContext).mockImplementation(() => {
-        return new Promise(() => {
-          // Never resolves, will timeout after 5 seconds
-        });
-      });
-
-      organisationService.setSelectedOrganisation(mockOrganisation);
-
-      // Advance timers past the 5 second timeout
-      await vi.advanceTimersByTimeAsync(6000);
-
-      // Wait a bit for async operations to complete
-      await vi.runAllTimersAsync();
-      
-      // Context ready should be set even on timeout (non-critical operation)
-      // The service sets _isContextReady to true even on error
-      expect(organisationService.isContextReady()).toBe(true);
-      
-      vi.useRealTimers();
-    });
-
-    it('should handle database context setting error', async () => {
-      const { setOrganisationContext } = await import('../../utils/context/organisationContext');
-      vi.mocked(setOrganisationContext).mockRejectedValue(new Error('Database error'));
-
-      organisationService.setSelectedOrganisation(mockOrganisation);
-
-      // Should handle error gracefully
-      await new Promise(resolve => setTimeout(resolve, 100));
-      
-      // Context ready should be set even on error
-      expect(organisationService.isContextReady()).toBe(true);
-    });
-
-    it('should handle missing Supabase client when setting context', async () => {
-      const serviceWithoutClient = new OrganisationService(
-        null as any,
-        mockUser,
-        mockSession
-      );
-
-      // Initially context is not ready
-      expect(serviceWithoutClient.isContextReady()).toBe(false);
-      
-      // setSelectedOrganisation requires a valid organisation in the organisations list
-      // Since we don't have a client, we can't load organisations, so this will throw
-      // or the organisation won't be in the list. The context ready state should remain false.
-      try {
-        await serviceWithoutClient.switchOrganisation(mockOrganisation.id);
-      } catch {
-        // Expected to fail
-      }
-      
-      // Context should still be false since organisation switch failed
-      expect(serviceWithoutClient.isContextReady()).toBe(false);
-    });
-
-    it('should handle missing session when setting context', async () => {
-      const serviceWithoutSession = new OrganisationService(
-        mockSupabase as any,
-        mockUser,
-        null
-      );
-
-      // Initially context is not ready
-      expect(serviceWithoutSession.isContextReady()).toBe(false);
-      
-      // Without a session, loadUserOrganisations will return early and not load organisations
-      // So setSelectedOrganisation will fail because the organisation isn't in the list
-      // The context ready state should remain false
-      try {
-        await serviceWithoutSession.switchOrganisation(mockOrganisation.id);
-      } catch {
-        // Expected to fail
-      }
-      
-      // Context should still be false since organisation switch failed
-      expect(serviceWithoutSession.isContextReady()).toBe(false);
-    });
-  });
-
-  describe('Load User Organisations Edge Cases', () => {
-    it('should handle RPC timeout with fallback query', async () => {
-      // Mock RPC to timeout
-      mockSupabase.rpc.mockImplementation(() => {
-        return new Promise((_, reject) => {
-          setTimeout(() => reject(new Error('RPC call timeout after 10 seconds')), 100);
-        });
-      });
-
-      // Mock fallback query
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return {
-            select: vi.fn().mockReturnValue({
-              eq: vi.fn().mockReturnValue({
-                eq: vi.fn().mockReturnValue({
-                  is: vi.fn().mockReturnValue({
-                    in: vi.fn().mockResolvedValue({
-                      data: [mockMembership],
-                      error: null
-                    })
-                  })
-                })
-              })
-            })
-          };
-        }
-        if (table === 'core_organisations') {
-          return {
-            select: vi.fn().mockResolvedValue({
-              data: [mockOrganisation],
-              error: null
-            })
-          };
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      // Should handle timeout and use fallback
-      expect(mockSupabase.from).toHaveBeenCalled();
-    });
-
-    it('should handle abort signal during RPC call', async () => {
-      const abortController = new AbortController();
-      abortController.abort();
-
-      mockSupabase.rpc.mockImplementation(() => {
-        return Promise.reject(new Error('Request aborted'));
-      });
-
-      await organisationService.initialize();
-
-      // Should handle abort gracefully
-      expect(organisationService.getError() || organisationService.getOrganisations()).toBeDefined();
-    });
-
-    it('should prevent duplicate loads when already loading', async () => {
-      // Set loading state
-      (organisationService as any).isLoadingRef = true;
-
-      // Call refreshOrganisations which internally calls loadUserOrganisations
-      await organisationService.refreshOrganisations();
-
-      // Should handle duplicate load prevention
-      expect(organisationService.isLoading()).toBeDefined();
-    });
-
-    it('should prevent rapid retries', async () => {
-      (organisationService as any).lastLoadTimeRef = Date.now();
-
-      // Call refreshOrganisations which internally calls loadUserOrganisations
-      await organisationService.refreshOrganisations();
-
-      // Should skip if too soon since last load
-      expect(organisationService.isLoading()).toBeDefined();
-    });
-
-    it('should handle invalid organisation IDs in memberships', async () => {
-      const mockQueryBuilder = {
-        select: vi.fn().mockReturnThis(),
-        eq: vi.fn().mockReturnThis(),
-        is: vi.fn().mockResolvedValue({
-          data: [{
-            id: mockMembership.id,
-            user_id: mockUser.id,
-            organisation_id: '', // Empty/invalid ID
-            role: mockMembership.role,
-            status: mockMembership.status,
-            granted_at: mockMembership.granted_at,
-            revoked_at: mockMembership.revoked_at,
-            core_organisations: null // No organisation data due to invalid ID
-          }],
-          error: null
-        })
-      };
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return mockQueryBuilder;
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(organisationService.getError()).toBeDefined();
-      // The service throws "No organisations found in role data" when organisations array is empty
-      expect(organisationService.getError()?.message).toContain('No organisations found');
-    });
-
-    it('should handle non-UUID organisation IDs', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: [{ ...mockMembership, organisation_id: 'invalid-id' }],
-        error: null
-      });
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'core_organisations') {
-          return {
-            select: vi.fn().mockResolvedValue({
-              data: [],
-              error: null
-            })
-          };
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      expect(organisationService.getError()).toBeDefined();
-    });
-
-    it('should clear cached data on error', async () => {
-      mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
-
-      localStorage.setItem('pace-core-selected-organisation', JSON.stringify(mockOrganisation));
-      localStorage.setItem('pace-core-organisation-context', 'test');
-
-      await organisationService.initialize();
-
-      // Should clear cached data
-      expect(localStorage.getItem('pace-core-selected-organisation')).toBeNull();
-      expect(localStorage.getItem('pace-core-organisation-context')).toBeNull();
-    });
-
-    it('should handle fallback query failure', async () => {
-      // Mock RPC to timeout
-      mockSupabase.rpc.mockImplementation(() => {
-        return Promise.reject(new Error('RPC call timeout after 10 seconds'));
-      });
-
-      // Mock fallback query to also fail
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'rbac_organisation_roles') {
-          return {
-            select: vi.fn().mockReturnValue({
-              eq: vi.fn().mockReturnValue({
-                eq: vi.fn().mockReturnValue({
-                  is: vi.fn().mockReturnValue({
-                    in: vi.fn().mockRejectedValue(new Error('Fallback query failed'))
-                  })
-                })
-              })
-            })
-          };
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      // Should handle fallback failure
-      expect(organisationService.getError()).toBeDefined();
-    });
-
-    it('should handle invalid persisted organisation ID format', async () => {
-      // Set invalid persisted organisation
-      localStorage.setItem('pace-core-selected-organisation', JSON.stringify({ id: '' }));
-
-      mockSupabase.rpc.mockResolvedValue({
-        data: [mockMembership],
-        error: null
-      });
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'core_organisations') {
-          return {
-            select: vi.fn().mockResolvedValue({
-              data: [mockOrganisation],
-              error: null
-            })
-          };
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      // Should clear invalid persisted org
-      expect(localStorage.getItem('pace-core-selected-organisation')).toBeNull();
-    });
-
-    it('should handle corrupted persisted organisation JSON', async () => {
-      localStorage.setItem('pace-core-selected-organisation', 'invalid-json');
-
-      mockSupabase.rpc.mockResolvedValue({
-        data: [mockMembership],
-        error: null
-      });
-
-      mockSupabase.from.mockImplementation((table: string) => {
-        if (table === 'core_organisations') {
-          return {
-            select: vi.fn().mockResolvedValue({
-              data: [mockOrganisation],
-              error: null
-            })
-          };
-        }
-        return {
-          select: vi.fn().mockResolvedValue({ data: [], error: null })
-        };
-      });
-
-      await organisationService.initialize();
-
-      // Should clear corrupted JSON
-      expect(localStorage.getItem('pace-core-selected-organisation')).toBeNull();
-    });
-  });
-
-  describe('Context Ready State', () => {
-    it('should return false when context is not ready', () => {
-      expect(organisationService.isContextReady()).toBe(false);
-    });
-
-    it('should return false when organisation is not selected', () => {
-      expect(organisationService.hasValidOrganisationContext()).toBe(false);
-    });
-
-    it('should return false when loading', () => {
-      organisationService.setSelectedOrganisation(mockOrganisation);
-      (organisationService as any)._isLoading = true;
-
-      expect(organisationService.hasValidOrganisationContext()).toBe(false);
-    });
-
-    it('should return false when error exists', () => {
-      organisationService.setSelectedOrganisation(mockOrganisation);
-      (organisationService as any)._error = new Error('Test error');
-
-      expect(organisationService.hasValidOrganisationContext()).toBe(false);
-    });
-  });
-});