@jmruthers/pace-core 0.5.68 → 0.5.69

package/src/__tests__/helpers/test-providers.tsx

@@ -0,0 +1,329 @@
+/**
+ * @file Test Provider Utilities
+ * @package @jmruthers/pace-core
+ * @module TestHelpers
+ * @since 0.1.0
+ *
+ * Utilities for providing test contexts and mocking services in tests.
+ */
+
+import React, { createContext, useContext } from 'react';
+import { render, RenderOptions } from '@testing-library/react';
+import { createMockSupabaseClient } from './supabaseMock';
+
+// Mock context type
+interface MockUnifiedAuthContextType {
+  // Auth state
+  user: any | null;
+  session: any | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+  error: any | null;
+
+  // Auth methods
+  signIn: (email: string, password?: string) => Promise<{ error: any | null }>;
+  signUp: (email: string, password: string) => Promise<{ error: any | null }>;
+  signOut: () => Promise<{ error: any | null }>;
+  resetPassword: (email: string) => Promise<{ error: any | null }>;
+  updatePassword: (password: string) => Promise<{ error: any | null }>;
+  refreshSession: () => Promise<{ error: any | null }>;
+
+  // RBAC state
+  permissions: Record<string, boolean>;
+  roles: string[];
+  accessLevel: any;
+  appConfig: any | null;
+  selectedEventId: string | null;
+  userEventAccess: any[];
+  eventAccessLoading: boolean;
+  selectedOrganisationId: string | null;
+
+  // RBAC methods
+  hasPermission: (permission: string, orgId?: string) => boolean;
+  hasAnyPermission: (permissions: string[], orgId?: string) => boolean;
+  hasAllPermissions: (permissions: string[], orgId?: string) => boolean;
+  hasRole: (role: string) => boolean;
+  hasAccessLevel: (level: any) => boolean;
+  canAccess: (resource: string, action: string, orgId?: string) => boolean;
+  validatePermission: (permission: string, orgId?: string) => Promise<boolean>;
+  validateAccess: (resource: string, action: string, orgId?: string) => Promise<boolean>;
+  refreshPermissions: (eventId?: string, orgId?: string) => Promise<void>;
+  setSelectedEventId: (eventId: string | null) => void;
+  loadUserEventAccess: (orgId?: string) => Promise<void>;
+  getUserEventAccess: () => any[];
+  getUserEventAccessById: (eventId: string) => any | undefined;
+  requireOrganisationContext: () => string;
+
+  // Organisation state
+  organisations: any[];
+  selectedOrganisation: any | null;
+  organisationLoading: boolean;
+  organisationError: any | null;
+
+  // Organisation methods
+  loadUserOrganisations: () => Promise<void>;
+  selectOrganisation: (orgId: string) => void;
+  validateOrganisationAccess: (orgId: string) => Promise<boolean>;
+  getUserRole: (orgId?: string) => string;
+  ensureOrganisationContext: () => Promise<void>;
+  switchOrganisation: (orgId: string) => Promise<void>;
+
+  // Event state
+  events: any[];
+  selectedEvent: any | null;
+  eventLoading: boolean;
+  eventError: any | null;
+
+  // Event methods
+  loadUserEvents: () => Promise<void>;
+  selectEvent: (eventId: string) => void;
+  refreshEvents: () => Promise<void>;
+  createEvent: (eventData: any) => Promise<any>;
+  updateEvent: (eventId: string, eventData: any) => Promise<any>;
+  deleteEvent: (eventId: string) => Promise<void>;
+
+  // Inactivity state
+  isTracking: boolean;
+  timeRemaining: number;
+  showInactivityWarning: boolean;
+  inactivityLoading: boolean;
+  inactivityError: any | null;
+
+  // Inactivity methods
+  startTracking: () => void;
+  stopTracking: () => void;
+  resetTimer: () => void;
+  setShowInactivityWarning: (show: boolean) => void;
+  handleUserActivity: () => void;
+
+  // Dependencies
+  supabase: any;
+  appName: string;
+}
+
+// Mock Supabase client for tests
+const mockSupabaseClient = createMockSupabaseClient();
+
+// Default mock auth state
+const defaultMockAuth: MockUnifiedAuthContextType = {
+  // Auth state
+  user: {
+    id: 'test-user-id',
+    email: 'test@example.com',
+    user_metadata: {},
+    app_metadata: {},
+    aud: 'authenticated',
+    created_at: '2023-01-01T00:00:00Z',
+    updated_at: '2023-01-01T00:00:00Z'
+  },
+  session: {
+    access_token: 'test-access-token',
+    refresh_token: 'test-refresh-token',
+    expires_in: 3600,
+    expires_at: Date.now() + 3600000,
+    token_type: 'bearer',
+    user: {
+      id: 'test-user-id',
+      email: 'test@example.com',
+      user_metadata: {},
+      app_metadata: {},
+      aud: 'authenticated',
+      created_at: '2023-01-01T00:00:00Z',
+      updated_at: '2023-01-01T00:00:00Z'
+    }
+  },
+  isAuthenticated: true,
+  isLoading: false,
+  error: null,
+
+  // Auth methods
+  signIn: vi.fn(() => Promise.resolve({ error: null })),
+  signOut: vi.fn(() => Promise.resolve({ error: null })),
+  signUp: vi.fn(() => Promise.resolve({ error: null })),
+  resetPassword: vi.fn(() => Promise.resolve({ error: null })),
+  updatePassword: vi.fn(() => Promise.resolve({ error: null })),
+  refreshSession: vi.fn(() => Promise.resolve({ error: null })),
+
+  // RBAC state
+  permissions: {},
+  roles: ['user'],
+  accessLevel: 'read',
+  appConfig: {
+    supports_direct_access: true,
+    requires_event: false
+  },
+  selectedEventId: null,
+  userEventAccess: [],
+  eventAccessLoading: false,
+  selectedOrganisationId: 'test-org-id',
+
+  // RBAC methods
+  hasPermission: vi.fn(() => true),
+  hasAnyPermission: vi.fn(() => true),
+  hasAllPermissions: vi.fn(() => true),
+  hasRole: vi.fn(() => true),
+  hasAccessLevel: vi.fn(() => true),
+  canAccess: vi.fn(() => true),
+  validatePermission: vi.fn(() => Promise.resolve(true)),
+  validateAccess: vi.fn(() => Promise.resolve(true)),
+  refreshPermissions: vi.fn(() => Promise.resolve()),
+  setSelectedEventId: vi.fn(),
+  loadUserEventAccess: vi.fn(() => Promise.resolve()),
+  getUserEventAccess: vi.fn(() => []),
+  getUserEventAccessById: vi.fn(() => undefined),
+  requireOrganisationContext: vi.fn(() => 'test-org-id'),
+
+  // Organisation state
+  organisations: [
+    {
+      id: 'test-org-id',
+      name: 'Test Organisation',
+      slug: 'test-org',
+      created_at: '2023-01-01T00:00:00Z',
+      updated_at: '2023-01-01T00:00:00Z'
+    }
+  ],
+  selectedOrganisation: {
+    id: 'test-org-id',
+    name: 'Test Organisation',
+    slug: 'test-org',
+    created_at: '2023-01-01T00:00:00Z',
+    updated_at: '2023-01-01T00:00:00Z'
+  },
+  organisationLoading: false,
+  organisationError: null,
+
+  // Organisation methods
+  loadUserOrganisations: vi.fn(() => Promise.resolve()),
+  selectOrganisation: vi.fn(),
+  validateOrganisationAccess: vi.fn(() => Promise.resolve(true)),
+  getUserRole: vi.fn(() => 'user'),
+  ensureOrganisationContext: vi.fn(() => Promise.resolve()),
+  switchOrganisation: vi.fn(() => Promise.resolve()),
+
+  // Event state
+  events: [
+    {
+      id: 'test-event-id',
+      name: 'Test Event',
+      description: 'Test event description',
+      start_date: '2023-01-01T00:00:00Z',
+      end_date: '2023-01-02T00:00:00Z',
+      status: 'active',
+      organisation_id: 'test-org-id',
+      created_at: '2023-01-01T00:00:00Z',
+      updated_at: '2023-01-01T00:00:00Z'
+    }
+  ],
+  selectedEvent: {
+    id: 'test-event-id',
+    name: 'Test Event',
+    description: 'Test event description',
+    start_date: '2023-01-01T00:00:00Z',
+    end_date: '2023-01-02T00:00:00Z',
+    status: 'active',
+    organisation_id: 'test-org-id',
+    created_at: '2023-01-01T00:00:00Z',
+    updated_at: '2023-01-01T00:00:00Z'
+  },
+  eventLoading: false,
+  eventError: null,
+
+  // Event methods
+  loadUserEvents: vi.fn(() => Promise.resolve()),
+  selectEvent: vi.fn(),
+  refreshEvents: vi.fn(() => Promise.resolve()),
+  createEvent: vi.fn(() => Promise.resolve()),
+  updateEvent: vi.fn(() => Promise.resolve()),
+  deleteEvent: vi.fn(() => Promise.resolve()),
+
+  // Inactivity state
+  isTracking: true,
+  timeRemaining: 300000, // 5 minutes
+  showInactivityWarning: false,
+  inactivityLoading: false,
+  inactivityError: null,
+
+  // Inactivity methods
+  startTracking: vi.fn(),
+  stopTracking: vi.fn(),
+  resetTimer: vi.fn(),
+  setShowInactivityWarning: vi.fn(),
+  handleUserActivity: vi.fn(),
+
+  // Dependencies
+  supabase: mockSupabaseClient,
+  appName: 'TEST'
+};
+
+// Create mock context
+const MockUnifiedAuthContext = createContext<MockUnifiedAuthContextType | undefined>(undefined);
+
+// Mock hook that matches the real useUnifiedAuth interface
+export const useUnifiedAuth = () => {
+  const context = useContext(MockUnifiedAuthContext);
+  if (!context) {
+    throw new Error('useUnifiedAuth must be used within a TestProviderWrapper');
+  }
+  return context;
+};
+
+// Test provider wrapper component
+interface TestProviderWrapperProps {
+  children: React.ReactNode;
+  mockAuth?: Partial<MockUnifiedAuthContextType>;
+}
+
+export function TestProviderWrapper({
+  children,
+  mockAuth = {}
+}: TestProviderWrapperProps) {
+  const contextValue = {
+    ...defaultMockAuth,
+    ...mockAuth
+  };
+
+  return (
+    <MockUnifiedAuthContext.Provider value={contextValue}>
+      {children}
+    </MockUnifiedAuthContext.Provider>
+  );
+}
+
+// Custom render function with provider wrapper
+interface CustomRenderOptions extends Omit<RenderOptions, 'wrapper'> {
+  mockAuth?: Partial<MockUnifiedAuthContextType>;
+}
+
+export function renderWithProviders(
+  ui: React.ReactElement,
+  options: CustomRenderOptions = {}
+) {
+  const {
+    mockAuth = {},
+    ...renderOptions
+  } = options;
+
+  const Wrapper = ({ children }: { children: React.ReactNode }) => (
+    <TestProviderWrapper mockAuth={mockAuth}>
+      {children}
+    </TestProviderWrapper>
+  );
+
+  return render(ui, { wrapper: Wrapper, ...renderOptions });
+}
+
+// Mock hook utilities
+export function createMockUseUnifiedAuth(overrides: Partial<MockUnifiedAuthContextType> = {}) {
+  return {
+    ...defaultMockAuth,
+    ...overrides
+  };
+}
+
+// Export default mock auth for easy access
+export { defaultMockAuth };
+
+// Re-export everything a test might need
+export * from '@testing-library/react';
+export { renderWithProviders as render };

package/src/__tests__/helpers/test-utils.tsx

@@ -9,19 +9,26 @@ import userEvent from '@testing-library/user-event';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { vi } from 'vitest';
 
-// Mock providers for testing
-const createTestQueryClient = () =>
-  new QueryClient({
-    defaultOptions: {
-      queries: {
-        retry: false,
-        gcTime: 0,
-      },
-      mutations: {
-        retry: false,
+// Mock providers for testing - optimized for performance
+let sharedQueryClient: QueryClient | null = null;
+
+const createTestQueryClient = () => {
+  if (!sharedQueryClient) {
+    sharedQueryClient = new QueryClient({
+      defaultOptions: {
+        queries: {
+          retry: false,
+          gcTime: 0,
+          staleTime: Infinity, // Prevent unnecessary refetches
+        },
+        mutations: {
+          retry: false,
+        },
       },
-    },
-  });
+    });
+  }
+  return sharedQueryClient;
+};
 
 // Custom render function with providers
 interface CustomRenderOptions extends Omit<RenderOptions, 'wrapper'> {
@@ -57,36 +64,28 @@ export function renderWithProviders(
 export * from '@testing-library/react';
 export { userEvent };
 
-// Mock data generators
+// Import shared fixtures for better performance
+import { TEST_FIXTURES, createFixture } from '../fixtures/test-data';
+
+// Optimized mock data generators using shared fixtures
 export const mockData = {
-  user: (overrides = {}) => ({
-    id: '1',
-    email: 'test@example.com',
-    name: 'Test User',
-    ...overrides,
-  }),
+  user: (overrides = {}) => createFixture(TEST_FIXTURES.users.basic, overrides),
   
   button: (overrides = {}) => ({
     children: 'Click me',
-    onClick: vi.fn(),
+    onClick: TEST_FIXTURES.mockFunctions.onClick,
     ...overrides,
   }),
   
   form: (overrides = {}) => ({
-    onSubmit: vi.fn(),
+    onSubmit: TEST_FIXTURES.mockFunctions.onSubmit,
     ...overrides,
   }),
 };
 
-// Test data generators for various data types
+// Optimized test data generators using shared fixtures
 export const testDataGenerators = {
-  user: (overrides = {}) => ({
-    id: 'test-user-id',
-    email: 'test@example.com',
-    name: 'Test User',
-    created_at: '2023-01-01T00:00:00Z',
-    ...overrides,
-  }),
+  user: (overrides = {}) => createFixture(TEST_FIXTURES.users.basic, overrides),
   
   createUser: (count = 1, overrides = {}) => {
     if (count === 1) {
@@ -184,33 +183,45 @@ export const testDataGenerators = {
 };
 
 // Mock Supabase client
-export const createMockSupabaseClient = () => {
-  const mockRpc = vi.fn(() => Promise.resolve({ data: null, error: null }));
-  
-  // Create a chainable mock for the query builder
-  const createQueryBuilder = () => {
-    const queryBuilder = {
-      select: vi.fn(() => queryBuilder),
-      eq: vi.fn(() => queryBuilder),
+// Optimized Supabase mock with shared instances
+let sharedQueryBuilder: any = null;
+let sharedAuthMock: any = null;
+
+const createQueryBuilder = () => {
+  if (!sharedQueryBuilder) {
+    sharedQueryBuilder = {
+      select: vi.fn(() => sharedQueryBuilder),
+      eq: vi.fn(() => sharedQueryBuilder),
       single: vi.fn(() => Promise.resolve({ data: { id: 'test-app-id' }, error: null })),
       maybeSingle: vi.fn(() => Promise.resolve({ data: null, error: null })),
-      order: vi.fn(() => queryBuilder),
+      order: vi.fn(() => sharedQueryBuilder),
       limit: vi.fn(() => Promise.resolve({ data: [], error: null })),
       insert: vi.fn(() => Promise.resolve({ data: null, error: null })),
       update: vi.fn(() => Promise.resolve({ data: null, error: null })),
       delete: vi.fn(() => Promise.resolve({ data: null, error: null })),
     };
-    return queryBuilder;
-  };
-  
-  return {
-    from: vi.fn(() => createQueryBuilder()),
-    auth: {
+  }
+  return sharedQueryBuilder;
+};
+
+const createAuthMock = () => {
+  if (!sharedAuthMock) {
+    sharedAuthMock = {
       getUser: vi.fn(() => Promise.resolve({ data: { user: null }, error: null })),
       getSession: vi.fn(() => Promise.resolve({ data: { session: null }, error: null })),
       signIn: vi.fn(() => Promise.resolve({ data: null, error: null })),
       signOut: vi.fn(() => Promise.resolve({ data: null, error: null })),
-    },
+    };
+  }
+  return sharedAuthMock;
+};
+
+export const createMockSupabaseClient = () => {
+  const mockRpc = vi.fn(() => Promise.resolve({ data: null, error: null }));
+  
+  return {
+    from: vi.fn(() => createQueryBuilder()),
+    auth: createAuthMock(),
     rpc: mockRpc,
   };
 };
@@ -261,3 +272,38 @@ export const testHelpers = {
     });
   },
 };
+
+// Standard test setup utilities
+export const setupTest = () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+};
+
+// Standard describe block structure for components
+export const createComponentTestStructure = (componentName: string) => {
+  return {
+    describe: (testFn: () => void) => {
+      describe(componentName, () => {
+        setupTest();
+        testFn();
+      });
+    },
+  };
+};
+
+// Standard describe block structure for hooks
+export const createHookTestStructure = (hookName: string) => {
+  return {
+    describe: (testFn: () => void) => {
+      describe(hookName, () => {
+        setupTest();
+        testFn();
+      });
+    },
+  };
+};

package/src/__tests__/helpers/timer-utils.ts

@@ -0,0 +1,71 @@
+/**
+ * @file Timer Utilities for Tests
+ * @description Optimized utilities for time-dependent tests
+ */
+
+import { vi } from 'vitest';
+
+/**
+ * Fast-forward time for tests that use delays/timeouts
+ * This is much faster than waiting for real time
+ */
+export const fastForwardTime = (ms: number) => {
+  vi.advanceTimersByTime(ms);
+};
+
+/**
+ * Fast-forward to the next timer
+ */
+export const fastForwardToNextTimer = () => {
+  // Advance time to trigger the next scheduled timer
+  // We advance by a reasonable amount (1000ms) to trigger the next pending timer
+  vi.advanceTimersByTime(1000);
+};
+
+/**
+ * Run all pending timers
+ */
+export const runAllTimers = () => {
+  // Advance time to trigger all pending one-shot timers
+  // Note: This does NOT run intervals to avoid infinite loops
+  vi.advanceTimersByTime(1000000);
+};
+
+/**
+ * Mock setTimeout to return immediately for faster tests
+ */
+export const mockImmediateTimeout = () => {
+  vi.spyOn(global, 'setTimeout').mockImplementation((callback: Function) => {
+    callback();
+    return 1 as any;
+  });
+};
+
+/**
+ * Mock setInterval to return immediately for faster tests
+ */
+export const mockImmediateInterval = () => {
+  vi.spyOn(global, 'setInterval').mockImplementation((callback: Function) => {
+    callback();
+    return 1 as any;
+  });
+};
+
+/**
+ * Setup optimized timers for a test
+ */
+export const setupFastTimers = () => {
+  vi.useFakeTimers();
+  mockImmediateTimeout();
+  mockImmediateInterval();
+};
+
+/**
+ * Cleanup timers after test
+ */
+export const cleanupTimers = () => {
+  // Use real timers first to ensure setTimeout/setInterval are available
+  // Then restore mocks to clean up any spy implementations
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+};

package/src/__tests__/hooks/usePermissions.test.ts

@@ -35,11 +35,7 @@ describe('usePermissions Hook Stability', () => {
     appId: 'app-123'
   };
 
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('usePermissions', () => {
+    describe('usePermissions', () => {
     it('should return stable references when data hasn\'t changed', async () => {
       const mockPermissions = {
         'read:users': true,

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

@@ -53,11 +53,7 @@ const UserProfile = ({ userId }: { userId: string }) => {
 };
 
 describe('User Profile Integration Tests', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Data Loading', () => {
+    describe('Data Loading', () => {
     it('loads and displays user data', async () => {
       renderWithProviders(<UserProfile userId="1" />);