@jmruthers/pace-core 0.6.9 → 0.6.11

package/src/services/OrganisationService.edge-cases.test.ts

@@ -0,0 +1,633 @@
+/**
+ * @file OrganisationService Edge Cases and Complex Scenarios Tests
+ * @package @jmruthers/pace-core
+ * @module Services
+ * @since 0.1.0
+ *
+ * Comprehensive edge case and complex scenario tests for OrganisationService.
+ * These tests focus on:
+ * - Security validation edge cases
+ * - Context ready state transitions
+ * - Retry logic
+ * - Hierarchy building
+ * - Multiple instance handling
+ * - State management edge cases
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { OrganisationService } from './OrganisationService';
+import { Organisation, OrganisationMembership } from '../types/organisation';
+import { Logger } from '../utils/core/logger';
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  from: vi.fn(() => ({
+    select: vi.fn().mockReturnThis(),
+    eq: vi.fn().mockReturnThis(),
+    in: vi.fn().mockReturnThis(),
+    single: vi.fn(),
+  })),
+  rpc: vi.fn(),
+});
+
+const mockUser = {
+  id: 'user-123',
+  email: 'test@example.com',
+  user_metadata: {},
+  app_metadata: {}
+};
+
+const mockSession = {
+  access_token: 'token',
+  refresh_token: 'refresh',
+  user: mockUser
+};
+
+const mockOrganisation: Organisation = {
+  id: 'org-123',
+  name: 'test-org',
+  display_name: 'Test Organisation',
+  subscription_tier: 'basic',
+  settings: {},
+  is_active: true,
+  created_at: '2023-01-01T00:00:00Z',
+  updated_at: '2023-01-01T00:00:00Z'
+};
+
+const mockMembership: OrganisationMembership = {
+  id: 'membership-123',
+  user_id: 'user-123',
+  organisation_id: 'org-123',
+  role: 'org_admin',
+  granted_at: '2023-01-01T00:00:00Z',
+  status: 'active',
+  created_at: '2023-01-01T00:00:00Z',
+  updated_at: '2023-01-01T00:00:00Z',
+  revoked_at: null
+};
+
+describe('OrganisationService Edge Cases and Complex Scenarios', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+  let organisationService: OrganisationService;
+  let mockLoggerFunctions: {
+    debug: ReturnType<typeof vi.spyOn>;
+    error: ReturnType<typeof vi.spyOn>;
+    warn: ReturnType<typeof vi.spyOn>;
+    info: ReturnType<typeof vi.spyOn>;
+  };
+
+  beforeEach(() => {
+    // Spy on Logger methods
+    mockLoggerFunctions = {
+      debug: vi.spyOn(Logger, 'debug'),
+      error: vi.spyOn(Logger, 'error'),
+      warn: vi.spyOn(Logger, 'warn'),
+      info: vi.spyOn(Logger, 'info'),
+    };
+    
+    mockSupabase = createMockSupabaseClient();
+    organisationService = new OrganisationService(
+      mockSupabase as any,
+      mockUser as any,
+      mockSession as any
+    );
+    
+    // Clear localStorage before each test
+    if (typeof window !== 'undefined' && window.localStorage) {
+      localStorage.clear();
+    }
+  });
+
+  afterEach(() => {
+    organisationService.cleanup();
+    mockLoggerFunctions.debug.mockRestore();
+    mockLoggerFunctions.error.mockRestore();
+    mockLoggerFunctions.warn.mockRestore();
+    mockLoggerFunctions.info.mockRestore();
+    vi.clearAllMocks();
+    
+    // Clear localStorage after each test
+    if (typeof window !== 'undefined' && window.localStorage) {
+      localStorage.clear();
+    }
+  });
+
+  describe('Security Validation Edge Cases', () => {
+    it('prevents setting invalid organisation when organisations are loaded', () => {
+      // Set up service with loaded organisations
+      (organisationService as any)._organisations = [mockOrganisation];
+      (organisationService as any)._userMemberships = [mockMembership];
+      (organisationService as any)._isSuperAdmin = false;
+
+      const invalidOrganisation: Organisation = {
+        ...mockOrganisation,
+        id: 'invalid-org-id',
+        name: 'invalid-org'
+      };
+
+      organisationService.setSelectedOrganisation(invalidOrganisation);
+
+      expect(organisationService.getSelectedOrganisation()).toBeNull();
+      expect(mockLoggerFunctions.warn).toHaveBeenCalledWith(
+        'OrganisationService',
+        'Attempted to set invalid organisation - not in user\'s accessible organisations',
+        expect.any(Object)
+      );
+    });
+
+    it('allows super admin to set any organisation', () => {
+      (organisationService as any)._organisations = [mockOrganisation];
+      (organisationService as any)._isSuperAdmin = true;
+
+      const otherOrganisation: Organisation = {
+        ...mockOrganisation,
+        id: 'other-org-id',
+        name: 'other-org'
+      };
+
+      organisationService.setSelectedOrganisation(otherOrganisation);
+
+      expect(organisationService.getSelectedOrganisation()).toEqual(otherOrganisation);
+    });
+
+    it('allows setting organisation when organisations are not loaded yet', () => {
+      // No organisations loaded
+      (organisationService as any)._organisations = [];
+      (organisationService as any)._isSuperAdmin = false;
+
+      organisationService.setSelectedOrganisation(mockOrganisation);
+
+      // Should allow setting (validation happens in loadUserOrganisations)
+      expect(organisationService.getSelectedOrganisation()).toEqual(mockOrganisation);
+    });
+
+    it('handles setting null organisation', () => {
+      organisationService.setSelectedOrganisation(mockOrganisation);
+      expect(organisationService.getSelectedOrganisation()).toEqual(mockOrganisation);
+
+      organisationService.setSelectedOrganisation(null);
+
+      expect(organisationService.getSelectedOrganisation()).toBeNull();
+      expect(organisationService.isContextReady()).toBe(false);
+      expect(localStorage.getItem('pace-core-selected-organisation')).toBeNull();
+    });
+  });
+
+  describe('Context Ready State Transitions', () => {
+    it('sets context ready when organisation is set', () => {
+      expect(organisationService.isContextReady()).toBe(false);
+
+      organisationService.setSelectedOrganisation(mockOrganisation);
+
+      expect(organisationService.isContextReady()).toBe(true);
+    });
+
+    it('clears context ready when organisation is cleared', () => {
+      organisationService.setSelectedOrganisation(mockOrganisation);
+      expect(organisationService.isContextReady()).toBe(true);
+
+      organisationService.setSelectedOrganisation(null);
+
+      expect(organisationService.isContextReady()).toBe(false);
+    });
+
+    it('maintains context ready state during loading', () => {
+      organisationService.setSelectedOrganisation(mockOrganisation);
+      expect(organisationService.isContextReady()).toBe(true);
+
+      (organisationService as any)._isLoading = true;
+      (organisationService as any).notify();
+
+      // Context should still be ready if organisation is set
+      expect(organisationService.hasValidOrganisationContext()).toBe(false); // Because loading
+      expect(organisationService.isContextReady()).toBe(true); // But context is ready
+    });
+  });
+
+  describe('Retry Logic Edge Cases', () => {
+    it('prevents rapid retries within 2 second window', async () => {
+      vi.useFakeTimers();
+      
+      (organisationService as any)._organisations = [mockOrganisation];
+      (organisationService as any).lastLoadTimeRef = Date.now();
+
+      // Fast-forward 1 second (less than 2 second minimum)
+      vi.advanceTimersByTime(1000);
+
+      // Attempt to load again
+      await organisationService.refreshOrganisations();
+
+      // Should not trigger another load
+      expect((organisationService as any).isLoadingRef).toBe(false);
+
+      vi.useRealTimers();
+    });
+
+    it('allows retry after 2 second window', async () => {
+      (organisationService as any)._organisations = [mockOrganisation];
+      (organisationService as any).lastLoadTimeRef = Date.now() - 3000; // 3 seconds ago
+      (organisationService as any).user = mockUser;
+      (organisationService as any).session = mockSession;
+      (organisationService as any).supabaseClient = mockSupabase;
+      (organisationService as any).isLoadingRef = false;
+
+      // Mock loadUserOrganisations to complete immediately
+      const originalLoadUserOrganisations = (organisationService as any).loadUserOrganisations;
+      (organisationService as any).loadUserOrganisations = vi.fn().mockResolvedValue(undefined);
+
+      // Attempt to load again (should be allowed after 2 second window)
+      await organisationService.refreshOrganisations();
+
+      // refreshOrganisations sets _isLoading to true and calls loadUserOrganisations
+      // After loadUserOrganisations completes, _isLoading becomes false
+      // But we verify that loadUserOrganisations was called (retry was allowed)
+      expect((organisationService as any).loadUserOrganisations).toHaveBeenCalled();
+      
+      // Restore original method
+      (organisationService as any).loadUserOrganisations = originalLoadUserOrganisations;
+    });
+
+    it('allows immediate load when no organisations are loaded', async () => {
+      (organisationService as any)._organisations = [];
+      (organisationService as any).lastLoadTimeRef = Date.now();
+      (organisationService as any).user = mockUser;
+      (organisationService as any).session = mockSession;
+      (organisationService as any).supabaseClient = mockSupabase;
+
+      // Should allow immediate load when no orgs are loaded
+      await organisationService.refreshOrganisations();
+
+      // Loading should be triggered (even if it completes quickly)
+      // The actual loading state depends on the async operation
+      expect(typeof (organisationService as any)._isLoading).toBe('boolean');
+    });
+  });
+
+  describe('Hierarchy Building Edge Cases', () => {
+    it('handles empty organisations array', () => {
+      const hierarchy = organisationService.buildOrganisationHierarchy([]);
+
+      expect(hierarchy).toEqual([]);
+    });
+
+    it('handles organisations with no parent (all roots)', () => {
+      const org1: Organisation = { ...mockOrganisation, id: 'org-1', parent_id: null };
+      const org2: Organisation = { ...mockOrganisation, id: 'org-2', parent_id: null };
+      const org3: Organisation = { ...mockOrganisation, id: 'org-3', parent_id: null };
+
+      const hierarchy = organisationService.buildOrganisationHierarchy([org1, org2, org3]);
+
+      expect(hierarchy).toHaveLength(3);
+      expect(hierarchy[0].organisation.id).toBe('org-1');
+      expect(hierarchy[1].organisation.id).toBe('org-2');
+      expect(hierarchy[2].organisation.id).toBe('org-3');
+    });
+
+    it('handles organisations with parent references', () => {
+      const parentOrg: Organisation = { ...mockOrganisation, id: 'parent-org', parent_id: null };
+      const childOrg: Organisation = { ...mockOrganisation, id: 'child-org', parent_id: 'parent-org' };
+
+      const hierarchy = organisationService.buildOrganisationHierarchy([parentOrg, childOrg]);
+
+      // Should return only root organisations (flat structure for now)
+      expect(hierarchy).toHaveLength(1);
+      expect(hierarchy[0].organisation.id).toBe('parent-org');
+    });
+  });
+
+  describe('Primary Organisation Edge Cases', () => {
+    it('returns null when no memberships exist', () => {
+      (organisationService as any)._userMemberships = [];
+      (organisationService as any)._organisations = [];
+
+      const primary = organisationService.getPrimaryOrganisation();
+
+      expect(primary).toBeNull();
+    });
+
+    it('prioritizes org_admin role', () => {
+      const org1: Organisation = { ...mockOrganisation, id: 'org-1' };
+      const org2: Organisation = { ...mockOrganisation, id: 'org-2' };
+      
+      const membership1: OrganisationMembership = {
+        ...mockMembership,
+        organisation_id: 'org-1',
+        role: 'member'
+      };
+      const membership2: OrganisationMembership = {
+        ...mockMembership,
+        id: 'membership-2',
+        organisation_id: 'org-2',
+        role: 'org_admin'
+      };
+
+      (organisationService as any)._organisations = [org1, org2];
+      (organisationService as any)._userMemberships = [membership1, membership2];
+
+      const primary = organisationService.getPrimaryOrganisation();
+
+      expect(primary?.id).toBe('org-2'); // Should prioritize org_admin
+    });
+
+    it('prioritizes leader role over member', () => {
+      const org1: Organisation = { ...mockOrganisation, id: 'org-1' };
+      const org2: Organisation = { ...mockOrganisation, id: 'org-2' };
+      
+      const membership1: OrganisationMembership = {
+        ...mockMembership,
+        organisation_id: 'org-1',
+        role: 'member'
+      };
+      const membership2: OrganisationMembership = {
+        ...mockMembership,
+        id: 'membership-2',
+        organisation_id: 'org-2',
+        role: 'leader'
+      };
+
+      (organisationService as any)._organisations = [org1, org2];
+      (organisationService as any)._userMemberships = [membership1, membership2];
+
+      const primary = organisationService.getPrimaryOrganisation();
+
+      expect(primary?.id).toBe('org-2'); // Should prioritize leader
+    });
+
+    it('returns null when organisation not found for membership', () => {
+      const membership: OrganisationMembership = {
+        ...mockMembership,
+        organisation_id: 'non-existent-org',
+        role: 'org_admin'
+      };
+
+      (organisationService as any)._organisations = [mockOrganisation];
+      (organisationService as any)._userMemberships = [membership];
+
+      const primary = organisationService.getPrimaryOrganisation();
+
+      expect(primary).toBeNull();
+    });
+  });
+
+  describe('Access Validation Edge Cases', () => {
+    it('returns false for null organisation ID', () => {
+      (organisationService as any)._userMemberships = [mockMembership];
+
+      const isValid = organisationService.validateOrganisationAccess(null as any);
+
+      expect(isValid).toBe(false);
+    });
+
+    it('returns false for empty string organisation ID', () => {
+      (organisationService as any)._userMemberships = [mockMembership];
+
+      const isValid = organisationService.validateOrganisationAccess('');
+
+      expect(isValid).toBe(false);
+    });
+
+    it('returns false for revoked membership', () => {
+      const revokedMembership: OrganisationMembership = {
+        ...mockMembership,
+        revoked_at: '2023-01-02T00:00:00Z'
+      };
+
+      (organisationService as any)._userMemberships = [revokedMembership];
+
+      const isValid = organisationService.validateOrganisationAccess('org-123');
+
+      expect(isValid).toBe(false);
+    });
+
+    it('returns false for inactive membership', () => {
+      const inactiveMembership: OrganisationMembership = {
+        ...mockMembership,
+        status: 'inactive'
+      };
+
+      (organisationService as any)._userMemberships = [inactiveMembership];
+
+      const isValid = organisationService.validateOrganisationAccess('org-123');
+
+      expect(isValid).toBe(false);
+    });
+
+    it('returns true for active, non-revoked membership', () => {
+      (organisationService as any)._userMemberships = [mockMembership];
+
+      const isValid = organisationService.validateOrganisationAccess('org-123');
+
+      expect(isValid).toBe(true);
+    });
+  });
+
+  describe('Initialization Edge Cases', () => {
+    it('skips initialization when user is null', async () => {
+      const serviceWithoutUser = new OrganisationService(
+        mockSupabase as any,
+        null,
+        null
+      );
+
+      await serviceWithoutUser.initialize();
+
+      expect(serviceWithoutUser.getOrganisations()).toEqual([]);
+      expect(serviceWithoutUser.getSelectedOrganisation()).toBeNull();
+
+      serviceWithoutUser.cleanup();
+    });
+
+    it('prevents duplicate loads during rapid auth events', async () => {
+      (organisationService as any).isLoadingRef = true;
+
+      await organisationService.initialize();
+
+      // Should not trigger another load
+      expect((organisationService as any).isLoadingRef).toBe(true);
+    });
+
+    it('handles initialization when already initialized', async () => {
+      (organisationService as any).user = mockUser;
+      (organisationService as any).session = mockSession;
+      (organisationService as any).supabaseClient = mockSupabase;
+      
+      await organisationService.initialize();
+      const _initialLoadTime = (organisationService as any).lastLoadTimeRef;
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      // Initialize again
+      await organisationService.initialize();
+
+      // Should not reload if already initialized (BaseService prevents duplicate init)
+      // The loadTime might change slightly due to timing, so we just verify it doesn't cause issues
+      expect(typeof (organisationService as any).lastLoadTimeRef).toBe('number');
+    });
+  });
+
+  describe('Cleanup Edge Cases', () => {
+    it('clears all state on cleanup', () => {
+      (organisationService as any)._selectedOrganisation = mockOrganisation;
+      (organisationService as any)._organisations = [mockOrganisation];
+      (organisationService as any)._userMemberships = [mockMembership];
+      (organisationService as any)._isLoading = true;
+      (organisationService as any)._error = new Error('Test error');
+      (organisationService as any)._isContextReady = true;
+
+      organisationService.cleanup();
+
+      expect(organisationService.getSelectedOrganisation()).toBeNull();
+      expect(organisationService.getOrganisations()).toEqual([]);
+      expect(organisationService.getUserMemberships()).toEqual([]);
+      expect(organisationService.isLoading()).toBe(false);
+      expect(organisationService.getError()).toBeNull();
+      expect(organisationService.isContextReady()).toBe(false);
+    });
+
+    it('handles cleanup when abortController exists', () => {
+      (organisationService as any).abortControllerRef = new AbortController();
+
+      // Should not throw
+      expect(() => {
+        organisationService.cleanup();
+      }).not.toThrow();
+
+      expect((organisationService as any).abortControllerRef).toBeNull();
+    });
+  });
+
+  describe('Multiple Instance Handling', () => {
+    it('assigns unique instance IDs to multiple instances', () => {
+      const service1 = new OrganisationService(
+        mockSupabase as any,
+        mockUser as any,
+        mockSession as any
+      );
+      const id1 = service1.getInstanceId();
+      
+      const service2 = new OrganisationService(
+        mockSupabase as any,
+        mockUser as any,
+        mockSession as any
+      );
+      const id2 = service2.getInstanceId();
+      
+      const service3 = new OrganisationService(
+        mockSupabase as any,
+        mockUser as any,
+        mockSession as any
+      );
+      const id3 = service3.getInstanceId();
+
+      // IDs should be unique and sequential
+      expect(id2).toBeGreaterThan(id1);
+      expect(id3).toBeGreaterThan(id2);
+      expect(id1).not.toBe(id2);
+      expect(id2).not.toBe(id3);
+      expect(id1).not.toBe(id3);
+
+      service1.cleanup();
+      service2.cleanup();
+      service3.cleanup();
+    });
+
+    it('maintains separate state for multiple instances', () => {
+      const service1 = new OrganisationService(
+        mockSupabase as any,
+        mockUser as any,
+        mockSession as any
+      );
+      const service2 = new OrganisationService(
+        mockSupabase as any,
+        mockUser as any,
+        mockSession as any
+      );
+
+      const org1: Organisation = { ...mockOrganisation, id: 'org-1' };
+      const org2: Organisation = { ...mockOrganisation, id: 'org-2' };
+
+      service1.setSelectedOrganisation(org1);
+      service2.setSelectedOrganisation(org2);
+
+      expect(service1.getSelectedOrganisation()?.id).toBe('org-1');
+      expect(service2.getSelectedOrganisation()?.id).toBe('org-2');
+
+      service1.cleanup();
+      service2.cleanup();
+    });
+  });
+
+  describe('Ensure Organisation Context Edge Cases', () => {
+    it('throws error when organisation context is not available', () => {
+      expect(() => {
+        organisationService.ensureOrganisationContext();
+      }).toThrow('Organisation context is required but not available');
+    });
+
+    it('returns organisation when context is available', () => {
+      organisationService.setSelectedOrganisation(mockOrganisation);
+
+      const org = organisationService.ensureOrganisationContext();
+
+      expect(org).toEqual(mockOrganisation);
+    });
+  });
+
+  describe('Organisation Security Edge Cases', () => {
+    it('returns false when organisation is set but user is null', () => {
+      (organisationService as any)._selectedOrganisation = mockOrganisation;
+      (organisationService as any).user = null;
+
+      expect(organisationService.isOrganisationSecure()).toBe(false);
+    });
+
+    it('returns false when user is set but organisation is null', () => {
+      (organisationService as any)._selectedOrganisation = null;
+      (organisationService as any).user = mockUser;
+
+      expect(organisationService.isOrganisationSecure()).toBe(false);
+    });
+
+    it('returns true when both organisation and user are set', () => {
+      (organisationService as any)._selectedOrganisation = mockOrganisation;
+      (organisationService as any).user = mockUser;
+
+      expect(organisationService.isOrganisationSecure()).toBe(true);
+    });
+  });
+
+  describe('Load User Organisations Edge Cases', () => {
+    it('clears state when user is null', async () => {
+      (organisationService as any).user = null;
+      (organisationService as any)._selectedOrganisation = mockOrganisation;
+      (organisationService as any)._organisations = [mockOrganisation];
+
+      await (organisationService as any).loadUserOrganisations();
+
+      expect(organisationService.getSelectedOrganisation()).toBeNull();
+      expect(organisationService.getOrganisations()).toEqual([]);
+      expect(organisationService.isLoading()).toBe(false);
+    });
+
+    it('clears state when session is null', async () => {
+      (organisationService as any).session = null;
+      (organisationService as any)._selectedOrganisation = mockOrganisation;
+
+      await (organisationService as any).loadUserOrganisations();
+
+      expect(organisationService.getSelectedOrganisation()).toBeNull();
+      expect(organisationService.getOrganisations()).toEqual([]);
+    });
+
+    it('clears state when Supabase client is null', async () => {
+      (organisationService as any).supabaseClient = null;
+      (organisationService as any)._selectedOrganisation = mockOrganisation;
+
+      await (organisationService as any).loadUserOrganisations();
+
+      expect(organisationService.getSelectedOrganisation()).toBeNull();
+      expect(organisationService.getOrganisations()).toEqual([]);
+    });
+  });
+});