@jmruthers/pace-core 0.5.118 → 0.5.119

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

@@ -657,4 +657,375 @@ describe('OrganisationService', () => {
       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/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/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
+      );
+
+      serviceWithoutClient.setSelectedOrganisation(mockOrganisation);
+
+      // Should handle gracefully
+      await new Promise(resolve => setTimeout(resolve, 100));
+      expect(serviceWithoutClient.isContextReady()).toBe(false);
+    });
+
+    it('should handle missing session when setting context', async () => {
+      const serviceWithoutSession = new OrganisationService(
+        mockSupabase as any,
+        mockUser,
+        null
+      );
+
+      serviceWithoutSession.setSelectedOrganisation(mockOrganisation);
+
+      // Should handle gracefully
+      await new Promise(resolve => setTimeout(resolve, 100));
+      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 === '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 () => {
+      mockSupabase.rpc.mockResolvedValue({
+        data: [{ ...mockMembership, organisation_id: '' }], // Empty ID
+        error: null
+      });
+
+      mockSupabase.from.mockImplementation((table: string) => {
+        if (table === 'organisations') {
+          return {
+            select: vi.fn().mockResolvedValue({
+              data: [],
+              error: null
+            })
+          };
+        }
+        return {
+          select: vi.fn().mockResolvedValue({ data: [], error: null })
+        };
+      });
+
+      await organisationService.initialize();
+
+      expect(organisationService.getError()).toBeDefined();
+      expect(organisationService.getError()?.message).toContain('No valid organisation IDs');
+    });
+
+    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 === '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 === '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 === '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);
+    });
+  });
 });