@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/utils/{__tests__/bundleAnalysis.unit.test.ts → bundleAnalysis.unit.test.ts}

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
 // Mock logger before importing bundleAnalysis
-vi.mock('../core/logger', () => {
+vi.mock('./core/logger', () => {
   const mockLogger = {
     debug: vi.fn(),
     info: vi.fn(),
@@ -25,7 +25,7 @@ describe('bundleAnalysis', () => {
 
       // Clear module cache and re-import
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
       const result = bundleAnalyzer.analyzeBundle();
 
       expect(result).toBeNull();
@@ -39,7 +39,7 @@ describe('bundleAnalysis', () => {
 
       // Clear module cache and re-import to pick up environment change
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
       const result = bundleAnalyzer.analyzeBundle();
 
       expect(result).toEqual({
@@ -58,8 +58,8 @@ describe('bundleAnalysis', () => {
 
       // Clear module cache and re-import to pick up environment change
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       bundleAnalyzer.analyzeBundle();
 
       expect(logger.debug).toHaveBeenCalledWith('BundleAnalyzer', 'Bundle analysis would run here in development');
@@ -78,8 +78,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'production');
 
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       bundleAnalyzer.checkTreeshaking();
 
       expect(logger.debug).not.toHaveBeenCalled();
@@ -93,8 +93,8 @@ describe('bundleAnalysis', () => {
 
       // Clear module cache and re-import to pick up environment change
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       bundleAnalyzer.checkTreeshaking();
 
       expect(logger.debug).toHaveBeenCalledWith('BundleAnalyzer', 'Tree-shaking Analysis');
@@ -113,8 +113,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'production');
 
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       bundleAnalyzer.validateExports();
 
       expect(logger.debug).not.toHaveBeenCalled();
@@ -128,8 +128,8 @@ describe('bundleAnalysis', () => {
 
       // Clear module cache and re-import to pick up environment change
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       bundleAnalyzer.validateExports();
 
       expect(logger.debug).toHaveBeenCalledWith('BundleAnalyzer', 'Export Validation');
@@ -145,7 +145,7 @@ describe('bundleAnalysis', () => {
   describe('bundleAnalyzer.generateReport', () => {
     it('should generate a comprehensive bundle analysis report', async () => {
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
       const report = bundleAnalyzer.generateReport();
 
       expect(report).toContain('# Bundle Analysis Report');
@@ -162,7 +162,7 @@ describe('bundleAnalysis', () => {
 
     it('should include specific recommendations', async () => {
       vi.resetModules();
-      const { bundleAnalyzer } = await import('../performance/bundleAnalysis');
+      const { bundleAnalyzer } = await import('./performance/bundleAnalysis');
       const report = bundleAnalyzer.generateReport();
 
       expect(report).toContain('Lazy load heavy UI components (charts, complex forms)');
@@ -178,8 +178,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'production');
 
       vi.resetModules();
-      const { validateImportPattern } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { validateImportPattern } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       validateImportPattern('lodash', ['debounce', 'throttle']);
 
       expect(logger.warn).not.toHaveBeenCalled();
@@ -192,8 +192,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { validateImportPattern } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { validateImportPattern } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       validateImportPattern('lodash', ['debounce', 'throttle', 'map', 'filter', 'reduce', 'forEach']);
 
       expect(logger.warn).toHaveBeenCalledWith(
@@ -209,8 +209,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { validateImportPattern } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { validateImportPattern } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       validateImportPattern('lodash', ['debounce', 'throttle']);
 
       expect(logger.warn).not.toHaveBeenCalled();
@@ -222,8 +222,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { validateImportPattern } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { validateImportPattern } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       validateImportPattern('small-module', ['func1', 'func2', 'func3', 'func4', 'func5', 'func6']);
 
       expect(logger.warn).not.toHaveBeenCalled();
@@ -236,8 +236,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { validateImportPattern } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { validateImportPattern } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       validateImportPattern('lodash-es', ['debounce', 'throttle', 'map', 'filter', 'reduce', 'forEach']);
 
       expect(logger.warn).toHaveBeenCalled();
@@ -250,8 +250,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { validateImportPattern } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { validateImportPattern } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       validateImportPattern('moment', ['format', 'parse', 'add', 'subtract', 'diff', 'isValid']);
 
       expect(logger.warn).toHaveBeenCalled();
@@ -264,8 +264,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { validateImportPattern } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { validateImportPattern } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       validateImportPattern('rxjs', ['Observable', 'Subject', 'BehaviorSubject', 'map', 'filter', 'switchMap']);
 
       expect(logger.warn).toHaveBeenCalled();
@@ -280,8 +280,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'production');
 
       vi.resetModules();
-      const { trackDynamicImport } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { trackDynamicImport } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       trackDynamicImport('some-module');
 
       expect(logger.debug).not.toHaveBeenCalled();
@@ -294,8 +294,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { trackDynamicImport } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { trackDynamicImport } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       trackDynamicImport('react-hook-form');
 
       expect(logger.debug).toHaveBeenCalledWith(
@@ -311,8 +311,8 @@ describe('bundleAnalysis', () => {
       vi.stubEnv('MODE', 'development');
 
       vi.resetModules();
-      const { trackDynamicImport } = await import('../performance/bundleAnalysis');
-      const { logger } = await import('../core/logger');
+      const { trackDynamicImport } = await import('./performance/bundleAnalysis');
+      const { logger } = await import('./core/logger');
       trackDynamicImport('date-fns');
 
       expect(logger.debug).toHaveBeenCalledWith(

package/src/utils/{__tests__/cn.unit.test.ts → cn.unit.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { cn } from '../core/cn';
+import { cn } from './core/cn';
 
 describe('cn utility', () => {
   it('should merge class names correctly', () => {

package/src/utils/context/organisationContext.test.ts

@@ -37,22 +37,26 @@ describe('Organisation Context', () => {
     describe('setOrganisationContext', () => {
     it('sets organisation context successfully (no-op)', async () => {
       // setOrganisationContext is now a no-op (deprecated)
-      // It should complete without calling rpc
-      await setOrganisationContext(mockSupabase, 'org-123');
-
-      // Should not call rpc since it's a no-op
+      const result = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeUndefined();
       expect(mockSupabase.rpc).not.toHaveBeenCalled();
     }, TEST_TIMEOUT);
 
     it('handles missing supabase client gracefully', async () => {
-      await expect(setOrganisationContext(null as any, 'org-123')).resolves.not.toThrow();
-      await expect(setOrganisationContext(undefined as any, 'org-123')).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(null as any, 'org-123');
+      const r2 = await setOrganisationContext(undefined as any, 'org-123');
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
     });
 
     it('handles missing organisation ID gracefully', async () => {
-      await expect(setOrganisationContext(mockSupabase, null as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, undefined as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, '')).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(mockSupabase, null as any);
+      const r2 = await setOrganisationContext(mockSupabase, undefined as any);
+      const r3 = await setOrganisationContext(mockSupabase, '');
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      expect(r3.ok).toBe(true);
     });
 
     it('handles database function errors gracefully', async () => {
@@ -61,25 +65,28 @@ describe('Organisation Context', () => {
         error: { message: 'Function not found' }
       });
 
-      // Should not throw error
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(result.ok).toBe(true); // no-op does not call rpc
     });
 
     it('handles RPC exceptions gracefully', async () => {
       mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
 
-      // Should not throw error
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(result.ok).toBe(true); // no-op does not call rpc
     });
 
     it('handles invalid organisation ID format', async () => {
-      await expect(setOrganisationContext(mockSupabase, 'invalid-id')).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(mockSupabase, 'invalid-id');
+      const r2 = await setOrganisationContext(mockSupabase, '123');
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
     });
 
     it('handles very long organisation ID', async () => {
       const longOrgId = 'a'.repeat(1000);
-      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, longOrgId);
+      expect(result.ok).toBe(true);
     });
   });
 
@@ -90,8 +97,9 @@ describe('Organisation Context', () => {
         error: null
       });
 
-      await clearOrganisationContext(mockSupabase);
-
+      const result = await clearOrganisationContext(mockSupabase);
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeUndefined();
       expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
         p_event_type: 'organisation_switched',
         p_metadata: { action: 'clear_context' }
@@ -99,8 +107,10 @@ describe('Organisation Context', () => {
     });
 
     it('handles missing supabase client gracefully', async () => {
-      await expect(clearOrganisationContext(null as any)).resolves.not.toThrow();
-      await expect(clearOrganisationContext(undefined as any)).resolves.not.toThrow();
+      const r1 = await clearOrganisationContext(null as any);
+      const r2 = await clearOrganisationContext(undefined as any);
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
     });
 
     it('handles database function errors gracefully', async () => {
@@ -109,61 +119,64 @@ describe('Organisation Context', () => {
         error: { message: 'Function not found' }
       });
 
-      // Should not throw error
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
+      const result = await clearOrganisationContext(mockSupabase);
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toBe('Function not found');
     });
 
     it('handles RPC exceptions gracefully', async () => {
       mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
 
-      // Should not throw error
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
+      const result = await clearOrganisationContext(mockSupabase);
+      expect(result.ok).toBe(false);
+      expect(result.error.message).toContain('Network error');
     });
   });
 
   describe('getOrganisationContext', () => {
     it('gets organisation context successfully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('returns null when no context is set', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles missing supabase client gracefully', async () => {
       const result1 = await getOrganisationContext(null as any);
       const result2 = await getOrganisationContext(undefined as any);
-
-      expect(result1).toBeNull();
-      expect(result2).toBeNull();
+      expect(result1.ok).toBe(true);
+      expect(result1.data).toBeNull();
+      expect(result2.ok).toBe(true);
+      expect(result2.data).toBeNull();
     });
 
     it('handles database function errors gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles RPC exceptions gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles invalid data format gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles empty string data', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
   });
 
@@ -177,39 +190,34 @@ describe('Organisation Context', () => {
       };
 
       const result = await getOrganisationContext(mockClient as any);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles complete workflow', async () => {
-      // setOrganisationContext is now a no-op, so it won't call rpc
-      await setOrganisationContext(mockSupabase, 'org-123');
+      const setResult = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(setResult.ok).toBe(true);
 
-      // getOrganisationContext always returns null (deprecated)
-      const result = await getOrganisationContext(mockSupabase);
-      expect(result).toBeNull();
+      const getResult = await getOrganisationContext(mockSupabase);
+      expect(getResult.ok).toBe(true);
+      expect(getResult.data).toBeNull();
 
-      // clearOrganisationContext still calls rpc
       mockSupabase.rpc.mockResolvedValueOnce({
         data: null,
         error: null
       });
 
-      await clearOrganisationContext(mockSupabase);
-
-      // Only clearOrganisationContext should call rpc (once)
+      const clearResult = await clearOrganisationContext(mockSupabase);
+      expect(clearResult.ok).toBe(true);
       expect(mockSupabase.rpc).toHaveBeenCalledTimes(1);
     });
 
     it('handles multiple organisation switches', async () => {
       const organisations = ['org-123', 'org-456', 'org-789'];
-
-      // setOrganisationContext is now a no-op, so it won't call rpc
       for (const orgId of organisations) {
-        await setOrganisationContext(mockSupabase, orgId);
+        const result = await setOrganisationContext(mockSupabase, orgId);
+        expect(result.ok).toBe(true);
       }
-
-      // setOrganisationContext is deprecated and doesn't call rpc anymore
       expect(mockSupabase.rpc).not.toHaveBeenCalled();
     }, TEST_TIMEOUT);
   });
@@ -218,96 +226,102 @@ describe('Organisation Context', () => {
     it('handles network timeouts gracefully', async () => {
       mockSupabase.rpc.mockRejectedValue(new Error('Request timeout'));
 
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
-      await expect(getOrganisationContext(mockSupabase)).resolves.toBeNull();
+      const setResult = await setOrganisationContext(mockSupabase, 'org-123');
+      expect(setResult.ok).toBe(true);
+      const clearResult = await clearOrganisationContext(mockSupabase);
+      expect(clearResult.ok).toBe(false);
+      expect(clearResult.error.message).toContain('Request timeout');
+      const getResult = await getOrganisationContext(mockSupabase);
+      expect(getResult.ok).toBe(true);
+      expect(getResult.data).toBeNull();
     });
 
     it('handles malformed responses gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles null responses gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles undefined responses gracefully', async () => {
       const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
   });
 
   describe('Performance', () => {
     it('handles rapid context changes efficiently', async () => {
       const startTime = Date.now();
-
-      // Rapidly switch contexts
       for (let i = 0; i < 100; i++) {
-        mockSupabase.rpc.mockResolvedValue({
-          data: null,
-          error: null
-        });
-
-        await setOrganisationContext(mockSupabase, `org-${i}`);
+        const result = await setOrganisationContext(mockSupabase, `org-${i}`);
+        expect(result.ok).toBe(true);
       }
-
       const endTime = Date.now();
-
-      expect(endTime - startTime).toBeLessThan(1000); // Should complete within 1 second
+      expect(endTime - startTime).toBeLessThan(1000);
     });
 
     it('handles concurrent operations gracefully', async () => {
-      const operations = [
+      mockSupabase.rpc.mockResolvedValue({ data: null, error: null });
+      const [r1, r2, r3, r4] = await Promise.all([
         setOrganisationContext(mockSupabase, 'org-1'),
         setOrganisationContext(mockSupabase, 'org-2'),
         clearOrganisationContext(mockSupabase),
         getOrganisationContext(mockSupabase)
-      ];
-
-      await expect(Promise.all(operations)).resolves.not.toThrow();
+      ]);
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      expect(r3.ok).toBe(true);
+      expect(r4.ok).toBe(true);
     });
   });
 
   describe('Edge Cases', () => {
     it('handles special characters in organisation ID', async () => {
-      const specialOrgId = 'org-123@domain.com';
-      await expect(setOrganisationContext(mockSupabase, specialOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-123@domain.com');
+      expect(result.ok).toBe(true);
     });
 
     it('handles unicode characters in organisation ID', async () => {
-      const unicodeOrgId = 'org-用户-123';
-      await expect(setOrganisationContext(mockSupabase, unicodeOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'org-用户-123');
+      expect(result.ok).toBe(true);
     });
 
     it('handles very long organisation ID', async () => {
-      const longOrgId = 'a'.repeat(10000);
-      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'a'.repeat(10000));
+      expect(result.ok).toBe(true);
     });
 
     it('handles numeric organisation ID', async () => {
-      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, '123');
+      expect(result.ok).toBe(true);
     });
 
     it('handles boolean organisation ID', async () => {
-      await expect(setOrganisationContext(mockSupabase, 'true' as any)).resolves.not.toThrow();
+      const result = await setOrganisationContext(mockSupabase, 'true' as any);
+      expect(result.ok).toBe(true);
     });
   });
 
   describe('Type Safety', () => {
     it('maintains type safety with TypeScript', async () => {
       const result = await getOrganisationContext(mockSupabase);
-      expect(result).toBeNull();
+      expect(result.ok).toBe(true);
+      expect(result.data).toBeNull();
     });
 
     it('handles mixed input types gracefully', async () => {
-      await expect(setOrganisationContext(mockSupabase, 123 as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, true as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, {} as any)).resolves.not.toThrow();
+      const r1 = await setOrganisationContext(mockSupabase, 123 as any);
+      const r2 = await setOrganisationContext(mockSupabase, true as any);
+      const r3 = await setOrganisationContext(mockSupabase, {} as any);
+      expect(r1.ok).toBe(true);
+      expect(r2.ok).toBe(true);
+      expect(r3.ok).toBe(true);
     });
   });
 });