@jmruthers/pace-core 0.6.8 → 0.6.10

package/src/__tests__/index.test.ts

@@ -0,0 +1,532 @@
+/**
+ * @file Main Index Barrel File Tests
+ * @package @jmruthers/pace-core
+ * @module Core/__tests__
+ * @since 0.1.0
+ *
+ * Comprehensive tests for the main barrel file (src/index.ts) ensuring all expected
+ * exports are correctly exposed and accessible.
+ */
+
+import { describe, it, expect } from 'vitest';
+import * as MainExports from '../index';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+describe('Main Index Barrel File Exports', () => {
+  describe('Provider Exports', () => {
+    it('should export UnifiedAuthProvider', () => {
+      expect(MainExports.UnifiedAuthProvider).toBeDefined();
+      expect(typeof MainExports.UnifiedAuthProvider).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useUnifiedAuth hook', () => {
+      expect(MainExports.useUnifiedAuth).toBeDefined();
+      expect(typeof MainExports.useUnifiedAuth).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export EventServiceProvider', () => {
+      expect(MainExports.EventServiceProvider).toBeDefined();
+      expect(typeof MainExports.EventServiceProvider).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export OrganisationServiceProvider', () => {
+      expect(MainExports.OrganisationServiceProvider).toBeDefined();
+      expect(typeof MainExports.OrganisationServiceProvider).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export InactivityServiceProvider', () => {
+      expect(MainExports.InactivityServiceProvider).toBeDefined();
+      expect(typeof MainExports.InactivityServiceProvider).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export OrganisationProvider', () => {
+      expect(MainExports.OrganisationProvider).toBeDefined();
+      expect(typeof MainExports.OrganisationProvider).toBe('function');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Hook Exports', () => {
+    it('should export useEvents hook', () => {
+      expect(MainExports.useEvents).toBeDefined();
+      expect(typeof MainExports.useEvents).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useOrganisations hook', () => {
+      expect(MainExports.useOrganisations).toBeDefined();
+      expect(typeof MainExports.useOrganisations).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useEventService hook', () => {
+      expect(MainExports.useEventService).toBeDefined();
+      expect(typeof MainExports.useEventService).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useOrganisationService hook', () => {
+      expect(MainExports.useOrganisationService).toBeDefined();
+      expect(typeof MainExports.useOrganisationService).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useAuthService hook', () => {
+      expect(MainExports.useAuthService).toBeDefined();
+      expect(typeof MainExports.useAuthService).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useInactivityService hook', () => {
+      expect(MainExports.useInactivityService).toBeDefined();
+      expect(typeof MainExports.useInactivityService).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useSessionRestoration hook', () => {
+      expect(MainExports.useSessionRestoration).toBeDefined();
+      expect(typeof MainExports.useSessionRestoration).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useInactivityTracker hook', () => {
+      expect(MainExports.useInactivityTracker).toBeDefined();
+      expect(typeof MainExports.useInactivityTracker).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useSessionTracking hook', () => {
+      expect(MainExports.useSessionTracking).toBeDefined();
+      expect(typeof MainExports.useSessionTracking).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useToast hook', () => {
+      expect(MainExports.useToast).toBeDefined();
+      expect(typeof MainExports.useToast).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useAppConfig hook', () => {
+      expect(MainExports.useAppConfig).toBeDefined();
+      expect(typeof MainExports.useAppConfig).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useEventTheme hook', () => {
+      expect(MainExports.useEventTheme).toBeDefined();
+      expect(typeof MainExports.useEventTheme).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useZodForm hook', () => {
+      expect(MainExports.useZodForm).toBeDefined();
+      expect(typeof MainExports.useZodForm).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useFormDialog hook', () => {
+      expect(MainExports.useFormDialog).toBeDefined();
+      expect(typeof MainExports.useFormDialog).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useOrganisationPermissions hook', () => {
+      expect(MainExports.useOrganisationPermissions).toBeDefined();
+      expect(typeof MainExports.useOrganisationPermissions).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useOrganisationSecurity hook', () => {
+      expect(MainExports.useOrganisationSecurity).toBeDefined();
+      expect(typeof MainExports.useOrganisationSecurity).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export useFileReference hooks', () => {
+      expect(MainExports.useFileReference).toBeDefined();
+      expect(MainExports.useFileReferenceForRecord).toBeDefined();
+      expect(MainExports.useFileReferenceById).toBeDefined();
+      expect(MainExports.useFilesByCategory).toBeDefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Component Exports', () => {
+    it('should export Button component', () => {
+      expect(MainExports.Button).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Button);
+    }, TEST_TIMEOUT);
+
+    it('should export Card components', () => {
+      expect(MainExports.Card).toBeDefined();
+      expect(MainExports.CardHeader).toBeDefined();
+      expect(MainExports.CardFooter).toBeDefined();
+      expect(MainExports.CardTitle).toBeDefined();
+      expect(MainExports.CardDescription).toBeDefined();
+      expect(MainExports.CardContent).toBeDefined();
+      expect(MainExports.CardActions).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export Input component', () => {
+      expect(MainExports.Input).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Input);
+    }, TEST_TIMEOUT);
+
+    it('should export AddressField component', () => {
+      expect(MainExports.AddressField).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.AddressField);
+    }, TEST_TIMEOUT);
+
+    it('should export Label component', () => {
+      expect(MainExports.Label).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Label);
+    }, TEST_TIMEOUT);
+
+    it('should export Textarea component', () => {
+      expect(MainExports.Textarea).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Textarea);
+    }, TEST_TIMEOUT);
+
+    it('should export Alert components', () => {
+      expect(MainExports.Alert).toBeDefined();
+      expect(MainExports.AlertTitle).toBeDefined();
+      expect(MainExports.AlertDescription).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export Avatar component', () => {
+      expect(MainExports.Avatar).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Avatar);
+    }, TEST_TIMEOUT);
+
+    it('should export Badge component', () => {
+      expect(MainExports.Badge).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Badge);
+    }, TEST_TIMEOUT);
+
+    it('should export Checkbox component', () => {
+      expect(MainExports.Checkbox).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Checkbox);
+    }, TEST_TIMEOUT);
+
+    it('should export Switch component', () => {
+      expect(MainExports.Switch).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Switch);
+    }, TEST_TIMEOUT);
+
+    it('should export Progress component', () => {
+      expect(MainExports.Progress).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Progress);
+    }, TEST_TIMEOUT);
+
+    it('should export Dialog components', () => {
+      expect(MainExports.Dialog).toBeDefined();
+      expect(MainExports.DialogPortal).toBeDefined();
+      expect(MainExports.DialogTrigger).toBeDefined();
+      expect(MainExports.DialogClose).toBeDefined();
+      expect(MainExports.DialogContent).toBeDefined();
+      expect(MainExports.DialogHeader).toBeDefined();
+      expect(MainExports.DialogBody).toBeDefined();
+      expect(MainExports.DialogFooter).toBeDefined();
+      expect(MainExports.DialogTitle).toBeDefined();
+      expect(MainExports.DialogDescription).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export Select components', () => {
+      expect(MainExports.Select).toBeDefined();
+      expect(MainExports.SelectGroup).toBeDefined();
+      expect(MainExports.SelectValue).toBeDefined();
+      expect(MainExports.SelectTrigger).toBeDefined();
+      expect(MainExports.SelectContent).toBeDefined();
+      expect(MainExports.SelectLabel).toBeDefined();
+      expect(MainExports.SelectItem).toBeDefined();
+      expect(MainExports.SelectSeparator).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export Tabs components', () => {
+      expect(MainExports.Tabs).toBeDefined();
+      expect(MainExports.TabsList).toBeDefined();
+      expect(MainExports.TabsTrigger).toBeDefined();
+      expect(MainExports.TabsContent).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export Calendar component', () => {
+      expect(MainExports.Calendar).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Calendar);
+    }, TEST_TIMEOUT);
+
+    it('should export Toast components', () => {
+      expect(MainExports.Toast).toBeDefined();
+      expect(MainExports.Toaster).toBeDefined();
+      expect(MainExports.ToastAction).toBeDefined();
+      expect(MainExports.ToastProvider).toBeDefined();
+      expect(MainExports.ToastViewport).toBeDefined();
+      expect(MainExports.ToastTitle).toBeDefined();
+      expect(MainExports.ToastDescription).toBeDefined();
+      expect(MainExports.ToastClose).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export Tooltip components', () => {
+      expect(MainExports.Tooltip).toBeDefined();
+      expect(MainExports.TooltipTrigger).toBeDefined();
+      expect(MainExports.TooltipContent).toBeDefined();
+      expect(MainExports.TooltipProvider).toBeDefined();
+      expect(MainExports.TooltipRoot).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export DataTable component', () => {
+      expect(MainExports.DataTable).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.DataTable);
+    }, TEST_TIMEOUT);
+
+    it('should export Form components', () => {
+      expect(MainExports.Form).toBeDefined();
+      expect(MainExports.FormField).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export LoginForm component', () => {
+      expect(MainExports.LoginForm).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.LoginForm);
+    }, TEST_TIMEOUT);
+
+    it('should export Header component', () => {
+      expect(MainExports.Header).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Header);
+    }, TEST_TIMEOUT);
+
+    it('should export Footer component', () => {
+      expect(MainExports.Footer).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.Footer);
+    }, TEST_TIMEOUT);
+
+    it('should export NavigationMenu component', () => {
+      expect(MainExports.NavigationMenu).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.NavigationMenu);
+    }, TEST_TIMEOUT);
+
+    it('should export UserMenu component', () => {
+      expect(MainExports.UserMenu).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.UserMenu);
+    }, TEST_TIMEOUT);
+
+    it('should export PaceAppLayout component', () => {
+      expect(MainExports.PaceAppLayout).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.PaceAppLayout);
+    }, TEST_TIMEOUT);
+
+    it('should export PaceLoginPage component', () => {
+      expect(MainExports.PaceLoginPage).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.PaceLoginPage);
+    }, TEST_TIMEOUT);
+
+    it('should export ProtectedRoute component', () => {
+      expect(MainExports.ProtectedRoute).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.ProtectedRoute);
+    }, TEST_TIMEOUT);
+
+    it('should export ErrorBoundary components', () => {
+      expect(MainExports.ErrorBoundary).toBeDefined();
+      expect(MainExports.ErrorBoundaryProvider).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export LoadingSpinner component', () => {
+      expect(MainExports.LoadingSpinner).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.LoadingSpinner);
+    }, TEST_TIMEOUT);
+
+    it('should export SessionRestorationLoader component', () => {
+      expect(MainExports.SessionRestorationLoader).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.SessionRestorationLoader);
+    }, TEST_TIMEOUT);
+
+    it('should export ContextSelector component', () => {
+      expect(MainExports.ContextSelector).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.ContextSelector);
+    }, TEST_TIMEOUT);
+
+    it('should export PasswordChangeForm component', () => {
+      expect(MainExports.PasswordChangeForm).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.PasswordChangeForm);
+    }, TEST_TIMEOUT);
+
+    it('should export FileUpload component', () => {
+      expect(MainExports.FileUpload).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.FileUpload);
+    }, TEST_TIMEOUT);
+
+    it('should export FileDisplay component', () => {
+      expect(MainExports.FileDisplay).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.FileDisplay);
+    }, TEST_TIMEOUT);
+
+    it('should export InactivityWarningModal component', () => {
+      expect(MainExports.InactivityWarningModal).toBeDefined();
+      // React components can be functions or objects (memoized/forwardRef)
+      expect(['function', 'object']).toContain(typeof MainExports.InactivityWarningModal);
+    }, TEST_TIMEOUT);
+
+    it('should export Table components', () => {
+      expect(MainExports.Table).toBeDefined();
+      expect(MainExports.TableHeader).toBeDefined();
+      expect(MainExports.TableBody).toBeDefined();
+      expect(MainExports.TableCaption).toBeDefined();
+      expect(MainExports.TableCell).toBeDefined();
+      expect(MainExports.TableFooter).toBeDefined();
+      expect(MainExports.TableHead).toBeDefined();
+      expect(MainExports.TableRow).toBeDefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Utility Function Exports', () => {
+    it('should export cn utility', () => {
+      expect(MainExports.cn).toBeDefined();
+      expect(typeof MainExports.cn).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export app config utilities', () => {
+      expect(MainExports.setAppConfig).toBeDefined();
+      expect(MainExports.getAppConfig).toBeDefined();
+      expect(MainExports.getCurrentAppName).toBeDefined();
+      expect(MainExports.getCurrentAppId).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export createBaseClient utility', () => {
+      expect(MainExports.createBaseClient).toBeDefined();
+      expect(typeof MainExports.createBaseClient).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export logger utilities', () => {
+      expect(MainExports.Logger).toBeDefined();
+      expect(MainExports.logger).toBeDefined();
+      expect(MainExports.createLogger).toBeDefined();
+      expect(MainExports.LogLevel).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export formatting utilities', () => {
+      expect(MainExports.formatDate).toBeDefined();
+      expect(MainExports.formatTime).toBeDefined();
+      expect(MainExports.formatDateTime).toBeDefined();
+      expect(MainExports.formatCurrency).toBeDefined();
+      expect(MainExports.formatNumber).toBeDefined();
+      expect(MainExports.formatPercent).toBeDefined();
+      expect(MainExports.formatCompactNumber).toBeDefined();
+      expect(MainExports.formatFileSize).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export timezone utilities', () => {
+      expect(MainExports.formatInTimeZone).toBeDefined();
+      expect(MainExports.getTimezoneAbbreviation).toBeDefined();
+      expect(MainExports.formatTimeInTimeZone).toBeDefined();
+      expect(MainExports.getUserTimeZone).toBeDefined();
+      expect(MainExports.toZonedTime).toBeDefined();
+      expect(MainExports.fromZonedTime).toBeDefined();
+      expect(MainExports.roundToNearestMinutes).toBeDefined();
+      expect(MainExports.getTimeZoneDifference).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export validation schemas', () => {
+      expect(MainExports.emailSchema).toBeDefined();
+      expect(MainExports.nameSchema).toBeDefined();
+      expect(MainExports.phoneSchema).toBeDefined();
+      expect(MainExports.urlSchema).toBeDefined();
+      expect(MainExports.passwordSchema).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export sanitization utilities', () => {
+      expect(MainExports.sanitizeUserInput).toBeDefined();
+      expect(MainExports.sanitizeFormData).toBeDefined();
+      expect(MainExports.sanitizeHtml).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export DataTable utility functions', () => {
+      expect(MainExports.exportToCSV).toBeDefined();
+      expect(MainExports.exportToCSVWithTableRows).toBeDefined();
+      expect(MainExports.generateCSVContent).toBeDefined();
+      expect(MainExports.sum).toBeDefined();
+      expect(MainExports.average).toBeDefined();
+      expect(MainExports.count).toBeDefined();
+      expect(MainExports.min).toBeDefined();
+      expect(MainExports.max).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export ColumnFactory', () => {
+      expect(MainExports.ColumnFactory).toBeDefined();
+    }, TEST_TIMEOUT);
+
+    it('should export createSecureDataAccess utility', () => {
+      expect(MainExports.createSecureDataAccess).toBeDefined();
+      expect(typeof MainExports.createSecureDataAccess).toBe('function');
+    }, TEST_TIMEOUT);
+
+    it('should export theming utilities', () => {
+      expect(MainExports.parseAndNormalizeEventColours).toBeDefined();
+      expect(MainExports.applyPalette).toBeDefined();
+      expect(MainExports.clearPalette).toBeDefined();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Type Exports', () => {
+    it('should export type definitions', () => {
+      // Types are compile-time only, so we verify they exist in the type system
+      // by checking that the module exports them (they may be undefined at runtime)
+      const exports = Object.keys(MainExports);
+      expect(exports.length).toBeGreaterThan(0);
+    }, TEST_TIMEOUT);
+  });
+
+  describe('RBAC Exports', () => {
+    it('should export RBAC module', () => {
+      // RBAC is exported via export * from './rbac'
+      // Verify that some expected RBAC exports are present
+      // Note: Specific RBAC exports may vary, so we check for common ones
+      const exports = Object.keys(MainExports);
+      // RBAC exports should be present (exact exports depend on rbac/index.ts)
+      expect(exports.length).toBeGreaterThan(50); // Should have many exports including RBAC
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Zod Export', () => {
+    it('should export zod for schema creation', () => {
+      expect(MainExports.z).toBeDefined();
+      // zod is an object with many properties, not a function
+      expect(typeof MainExports.z).toBe('object');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Export Structure', () => {
+    it('should have a substantial number of exports', () => {
+      const exports = Object.keys(MainExports);
+      // Main index should export many items (components, hooks, utilities, types)
+      expect(exports.length).toBeGreaterThan(100);
+    }, TEST_TIMEOUT);
+
+    it('should export functions as functions', () => {
+      // Sample check: verify some key exports are functions
+      const functionExports = [
+        'Button',
+        'Input',
+        'useUnifiedAuth',
+        'cn',
+        'formatDate'
+      ];
+      
+      functionExports.forEach(exportName => {
+        if (MainExports[exportName as keyof typeof MainExports]) {
+          // React components can be functions or objects (memoized/forwardRef)
+          const exportType = typeof MainExports[exportName as keyof typeof MainExports];
+          expect(['function', 'object']).toContain(exportType);
+        }
+      });
+    }, TEST_TIMEOUT);
+  });
+});

package/src/__tests__/integration/UserProfile.test.tsx

@@ -27,7 +27,7 @@ const UserProfile = ({ userId }: { userId: string }) => {
         } else {
           setError('User not found');
         }
-      } catch (err) {
+      } catch (_err) {
         setError('Failed to fetch user');
       } finally {
         setLoading(false);

package/src/__tests__/rbac/PagePermissionGuard.test.tsx

@@ -16,7 +16,6 @@ import { render, screen, waitFor, act } from '@testing-library/react';
 import { vi } from 'vitest';
 import { PagePermissionGuard } from '../../rbac/components/PagePermissionGuard';
 import { useUnifiedAuth } from '../../providers';
-import { useCan } from '../../rbac/hooks';
 
 // Mock the hooks
 const mockUseUnifiedAuthFn = vi.fn();
@@ -24,12 +23,15 @@ vi.mock('../../providers/services/UnifiedAuthProvider', () => ({
   useUnifiedAuth: () => mockUseUnifiedAuthFn(),
   UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
-vi.mock('../../rbac/hooks', () => ({
-  useCan: vi.fn()
+// Mock individual hook file since barrel was removed
+// CRITICAL: Use hoisted mock so vi.mocked() works correctly
+const mockUseCanFn = vi.hoisted(() => vi.fn());
+vi.mock('../../rbac/hooks/usePermissions', () => ({
+  useCan: mockUseCanFn
 }));
 vi.mock('../../utils/appNameResolver');
 
-const mockUseCan = vi.mocked(useCan);
+// Use the hoisted mock function directly
 
 describe('PagePermissionGuard', () => {
   const mockUser = {
@@ -62,7 +64,7 @@ describe('PagePermissionGuard', () => {
       // Add other required properties
     } as any);
 
-    mockUseCan.mockReturnValue({
+    mockUseCanFn.mockReturnValue({
       can: false,
       isLoading: false,
       error: null,
@@ -90,7 +92,7 @@ describe('PagePermissionGuard', () => {
     });
 
     it('should show protected content when permission is granted', async () => {
-      mockUseCan.mockReturnValue({
+      mockUseCanFn.mockReturnValue({
         can: true,
         isLoading: false,
         error: null,
@@ -115,7 +117,7 @@ describe('PagePermissionGuard', () => {
 
   describe('Permission State Transitions', () => {
     it('should handle permission state changes', async () => {
-      mockUseCan.mockReturnValue({
+      mockUseCanFn.mockReturnValue({
         can: true,
         isLoading: false,
         error: null,
@@ -140,7 +142,7 @@ describe('PagePermissionGuard', () => {
 
   describe('Error Handling', () => {
     it('should handle errors gracefully', async () => {
-      mockUseCan.mockReturnValue({
+      mockUseCanFn.mockReturnValue({
         can: false,
         isLoading: false,
         error: new Error('Permission check failed'),

package/src/__tests__/rls-policies.test.ts

@@ -187,8 +187,9 @@ describe('RLS Policies - Organisations', () => {
       expect(error).toBeNull();
       expect(data).toBeDefined();
       // Use <= to account for minor timing variations in test environment
-      // Increase threshold slightly for CI/test environments which may be slower
-      const adjustedThreshold = PERFORMANCE_THRESHOLD * 1.5; // Allow 50% more time
+      // Increase threshold for CI/test environments which may be slower
+      // Allow 2x threshold for test environment variability
+      const adjustedThreshold = PERFORMANCE_THRESHOLD * 2; // Allow 100% more time for test environments
       expect(duration).toBeLessThanOrEqual(adjustedThreshold);
     }, TEST_TIMEOUT);