@jmruthers/pace-core 0.2.7 → 0.4.1

package/src/providers/__tests__/UnifiedAuthProvider.unit.test.tsx

@@ -1,683 +0,0 @@
-/**
- * @file UnifiedAuthProvider Unit Tests
- * @package @jmruthers/pace-core
- * @module Providers/UnifiedAuth
- * @since 0.1.0
- */
-
-import React from 'react';
-import { screen, waitFor, fireEvent } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import '@testing-library/jest-dom';
-import { createClient } from '@supabase/supabase-js';
-import { UnifiedAuthProvider, useUnifiedAuth } from '../UnifiedAuthProvider';
-import { renderWithProviders, createMockSupabaseClient, resetSharedSupabaseMock } from '../../__tests__/shared';
-import { AccessLevel } from '../../types/unified';
-
-// Mock Supabase client
-vi.mock('@supabase/supabase-js', () => ({
-  createClient: vi.fn(),
-}));
-
-describe('UnifiedAuthProvider', () => {
-  let mockSupabaseClient: any;
-
-  beforeEach(() => {
-    mockSupabaseClient = createMockSupabaseClient();
-    (createClient as any).mockReturnValue(mockSupabaseClient);
-    resetSharedSupabaseMock();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-    // Clean up any pending async operations
-    if (vi.isFakeTimers()) {
-      vi.runOnlyPendingTimers();
-      vi.useRealTimers();
-    }
-  });
-
-  const TestComponent = () => {
-    const { user, session, isAuthenticated, isLoading, error } = useUnifiedAuth();
-    
-    return (
-      <div>
-        <div data-testid="is-loading">{isLoading.toString()}</div>
-        <div data-testid="is-authenticated">{isAuthenticated.toString()}</div>
-        <div data-testid="user-id">{user?.id || 'no-user'}</div>
-        <div data-testid="error">{error || 'no-error'}</div>
-      </div>
-    );
-  };
-
-  describe('Provider Initialization', () => {
-    it('should render children and initialize auth state', async () => {
-      mockSupabaseClient.auth.onAuthStateChange.mockImplementation((callback: any) => {
-        setTimeout(() => {
-          callback('SIGNED_IN', { user: { id: 'test-user' }, session: {} });
-        }, 0);
-        return { data: { subscription: { unsubscribe: vi.fn() } } };
-      });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      expect(screen.getByTestId('is-loading')).toHaveTextContent('true');
-      
-      await waitFor(() => {
-        expect(screen.getByTestId('is-authenticated')).toHaveTextContent('true');
-      });
-    });
-
-    it('should handle authentication state changes', async () => {
-      let authCallback: any;
-      // Override the mock implementation for this specific test
-      vi.spyOn(mockSupabaseClient.auth, 'onAuthStateChange').mockImplementation((callback: any) => {
-        authCallback = callback;
-        return { data: { subscription: { unsubscribe: vi.fn() } } };
-      });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      // Simulate sign in
-      authCallback('SIGNED_IN', { user: { id: 'test-user' }, session: {} });
-      
-      await waitFor(() => {
-        expect(screen.getByTestId('is-authenticated')).toHaveTextContent('true');
-      });
-
-      // Simulate sign out
-      authCallback('SIGNED_OUT', null);
-      
-      await waitFor(() => {
-        expect(screen.getByTestId('is-authenticated')).toHaveTextContent('false');
-      });
-    });
-  });
-
-  describe('Authentication Methods', () => {
-    it('should provide sign in method', async () => {
-      const AuthTestComponent = () => {
-        const { signIn } = useUnifiedAuth();
-        const [result, setResult] = React.useState<string>('');
-
-        const handleSignIn = async () => {
-          try {
-            await signIn('test@example.com', 'password');
-            setResult('success');
-          } catch (error) {
-            setResult('error');
-          }
-        };
-
-        return (
-          <div>
-            <button data-testid="sign-in-btn" onClick={handleSignIn}>Sign In</button>
-            <div data-testid="result">{result}</div>
-          </div>
-        );
-      };
-
-      // The mock is already set up in the shared mock, but we can override it for this test
-      vi.spyOn(mockSupabaseClient.auth, 'signInWithPassword').mockResolvedValue({
-        data: { user: { id: 'test-user' }, session: {} },
-        error: null
-      });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <AuthTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      const signInBtn = screen.getByTestId('sign-in-btn');
-      signInBtn.click();
-
-      await waitFor(() => {
-        expect(screen.getByTestId('result')).toHaveTextContent('success');
-      });
-    });
-
-    it('should provide sign out method', async () => {
-      const AuthTestComponent = () => {
-        const { signOut } = useUnifiedAuth();
-        const [result, setResult] = React.useState<string>('');
-
-        const handleSignOut = async () => {
-          try {
-            await signOut();
-            setResult('success');
-          } catch (error) {
-            setResult('error');
-          }
-        };
-
-        return (
-          <div>
-            <button data-testid="sign-out-btn" onClick={handleSignOut}>Sign Out</button>
-            <div data-testid="result">{result}</div>
-          </div>
-        );
-      };
-
-      mockSupabaseClient.auth.signOut = vi.fn().mockResolvedValue({ error: null });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <AuthTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      const signOutBtn = screen.getByTestId('sign-out-btn');
-      signOutBtn.click();
-
-      await waitFor(() => {
-        expect(screen.getByTestId('result')).toHaveTextContent('success');
-      });
-    });
-  });
-
-  describe('Permission System', () => {
-    it('should provide permission checking methods', async () => {
-      const PermissionTestComponent = () => {
-        const { hasPermission, hasRole, hasAccessLevel } = useUnifiedAuth();
-        const [results, setResults] = React.useState<string[]>([]);
-
-        React.useEffect(() => {
-          const testResults = [];
-          testResults.push(`hasPermission: ${hasPermission('test:read')}`);
-          testResults.push(`hasRole: ${hasRole('admin')}`);
-          testResults.push(`hasAccessLevel: ${hasAccessLevel(AccessLevel.VIEWER)}`);
-          setResults(testResults);
-        }, [hasPermission, hasRole, hasAccessLevel]);
-
-        return (
-          <div>
-            <div data-testid="permission-results">{results.join(', ')}</div>
-          </div>
-        );
-      };
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <PermissionTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('permission-results')).toBeInTheDocument();
-      });
-    });
-  });
-
-  describe('useUnifiedAuth Hook', () => {
-    it('should throw error when used outside provider', () => {
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-      const TestComponent = () => {
-        useUnifiedAuth();
-        return <div>Test</div>;
-      };
-
-      expect(() => {
-        renderWithProviders(<TestComponent />);
-      }).toThrow('useUnifiedAuth must be used within a UnifiedAuthProvider');
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('Comprehensive Authentication Methods', () => {
-    it('should handle sign up with email and password', async () => {
-      const AuthTestComponent = () => {
-        const { signUp } = useUnifiedAuth();
-        const [result, setResult] = React.useState<string>('');
-
-        const handleSignUp = async () => {
-          try {
-            await signUp('test@example.com', 'password123');
-            setResult('success');
-          } catch (error) {
-            setResult('error');
-          }
-        };
-
-        return (
-          <div>
-            <button data-testid="sign-up-btn" onClick={handleSignUp}>Sign Up</button>
-            <div data-testid="result">{result}</div>
-          </div>
-        );
-      };
-
-      mockSupabaseClient.auth.signUp = vi.fn().mockResolvedValue({
-        data: { user: { id: 'test-user' }, session: {} },
-        error: null
-      });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <AuthTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      const signUpBtn = screen.getByTestId('sign-up-btn');
-      fireEvent.click(signUpBtn);
-
-      await waitFor(() => {
-        expect(screen.getByTestId('result')).toHaveTextContent('success');
-      });
-    });
-
-    it('should handle reset password', async () => {
-      const AuthTestComponent = () => {
-        const { resetPassword } = useUnifiedAuth();
-        const [result, setResult] = React.useState<string>('');
-
-        const handleResetPassword = async () => {
-          try {
-            await resetPassword('test@example.com');
-            setResult('success');
-          } catch (error) {
-            setResult('error');
-          }
-        };
-
-        return (
-          <div>
-            <button data-testid="reset-password-btn" onClick={handleResetPassword}>Reset Password</button>
-            <div data-testid="result">{result}</div>
-          </div>
-        );
-      };
-
-      mockSupabaseClient.auth.resetPasswordForEmail = vi.fn().mockResolvedValue({ error: null });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <AuthTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      const resetBtn = screen.getByTestId('reset-password-btn');
-      fireEvent.click(resetBtn);
-
-      await waitFor(() => {
-        expect(screen.getByTestId('result')).toHaveTextContent('success');
-      });
-    });
-
-    it('should handle update password', async () => {
-      const AuthTestComponent = () => {
-        const { updatePassword } = useUnifiedAuth();
-        const [result, setResult] = React.useState<string>('');
-
-        const handleUpdatePassword = async () => {
-          try {
-            await updatePassword('newpassword123');
-            setResult('success');
-          } catch (error) {
-            setResult('error');
-          }
-        };
-
-        return (
-          <div>
-            <button data-testid="update-password-btn" onClick={handleUpdatePassword}>Update Password</button>
-            <div data-testid="result">{result}</div>
-          </div>
-        );
-      };
-
-      mockSupabaseClient.auth.updateUser = vi.fn().mockResolvedValue({
-        data: { user: { id: 'test-user' } },
-        error: null
-      });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <AuthTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      const updateBtn = screen.getByTestId('update-password-btn');
-      fireEvent.click(updateBtn);
-
-      await waitFor(() => {
-        expect(screen.getByTestId('result')).toHaveTextContent('success');
-      });
-    });
-
-    it('should handle refresh session', async () => {
-      const AuthTestComponent = () => {
-        const { refreshSession } = useUnifiedAuth();
-        const [result, setResult] = React.useState<string>('');
-
-        const handleRefreshSession = async () => {
-          try {
-            await refreshSession();
-            setResult('success');
-          } catch (error) {
-            setResult('error');
-          }
-        };
-
-        return (
-          <div>
-            <button data-testid="refresh-session-btn" onClick={handleRefreshSession}>Refresh Session</button>
-            <div data-testid="result">{result}</div>
-          </div>
-        );
-      };
-
-      mockSupabaseClient.auth.refreshSession = vi.fn().mockResolvedValue({
-        data: { session: { access_token: 'new-token' } },
-        error: null
-      });
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <AuthTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      const refreshBtn = screen.getByTestId('refresh-session-btn');
-      fireEvent.click(refreshBtn);
-
-      await waitFor(() => {
-        expect(screen.getByTestId('result')).toHaveTextContent('success');
-      });
-    });
-  });
-
-  describe('Comprehensive Permission System', () => {
-    it('should handle all permission validation methods', async () => {
-      const PermissionTestComponent = () => {
-        const { 
-          hasPermission, 
-          hasAnyPermission, 
-          hasAllPermissions, 
-          hasRole, 
-          hasAccessLevel, 
-          canAccess,
-          validatePermission,
-          validateAccess
-        } = useUnifiedAuth();
-        const [results, setResults] = React.useState<string[]>([]);
-
-        React.useEffect(() => {
-          const testResults = [];
-          testResults.push(`hasPermission: ${hasPermission('test:read')}`);
-          testResults.push(`hasAnyPermission: ${hasAnyPermission(['test:read', 'test:write'])}`);
-          testResults.push(`hasAllPermissions: ${hasAllPermissions(['test:read', 'test:write'])}`);
-          testResults.push(`hasRole: ${hasRole('admin')}`);
-          testResults.push(`hasAccessLevel: ${hasAccessLevel(AccessLevel.VIEWER)}`);
-          testResults.push(`canAccess: ${canAccess('test', 'read')}`);
-          
-          // Test async methods
-          validatePermission('test:read').then(result => {
-            testResults.push(`validatePermission: ${result}`);
-            setResults([...testResults]);
-          });
-          
-          validateAccess('test', 'read').then(result => {
-            testResults.push(`validateAccess: ${result}`);
-            setResults([...testResults]);
-          });
-        }, [hasPermission, hasAnyPermission, hasAllPermissions, hasRole, hasAccessLevel, canAccess, validatePermission, validateAccess]);
-
-        return (
-          <div>
-            <div data-testid="permission-results">{results.join(', ')}</div>
-          </div>
-        );
-      };
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <PermissionTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('permission-results')).toBeInTheDocument();
-      });
-    });
-  });
-
-  describe('Organisation Context', () => {
-    it('should handle requireOrganisationContext when organisation is not available', async () => {
-      const OrgTestComponent = () => {
-        const { requireOrganisationContext } = useUnifiedAuth();
-        const [result, setResult] = React.useState<string>('');
-
-        React.useEffect(() => {
-          try {
-            const orgId = requireOrganisationContext();
-            setResult(`Organisation ID: ${orgId}`);
-          } catch (error) {
-            setResult(`Error: ${error instanceof Error ? error.message : 'unknown'}`);
-          }
-        }, [requireOrganisationContext]);
-
-        return (
-          <div>
-            <div data-testid="org-result">{result}</div>
-          </div>
-        );
-      };
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <OrgTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('org-result')).toHaveTextContent('Error: Organisation context is required but not available');
-      });
-    });
-  });
-
-  describe('RBAC State Management', () => {
-    it('should handle RBAC loading states', async () => {
-      const RBACTestComponent = () => {
-        const { rbacLoading, rbacError, permissions, roles, accessLevel } = useUnifiedAuth();
-        
-        return (
-          <div>
-            <div data-testid="rbac-loading">{rbacLoading.toString()}</div>
-            <div data-testid="rbac-error">{rbacError || 'no-error'}</div>
-            <div data-testid="permissions-count">{Object.keys(permissions).length}</div>
-            <div data-testid="roles-count">{Object.keys(roles).length}</div>
-            <div data-testid="access-level">{accessLevel || 'none'}</div>
-          </div>
-        );
-      };
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <RBACTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('rbac-loading')).toHaveTextContent('false');
-        expect(screen.getByTestId('rbac-error')).toHaveTextContent('no-error');
-      });
-    });
-  });
-
-  describe('Event Management', () => {
-    it('should handle event access management', async () => {
-      const EventTestComponent = () => {
-        const { 
-          selectedEventId, 
-          userEventAccess, 
-          eventAccessLoading,
-          refreshPermissions,
-          loadUserEventAccess,
-          getUserEventAccess
-        } = useUnifiedAuth();
-        
-        const [results, setResults] = React.useState<string[]>([]);
-
-        React.useEffect(() => {
-          const testResults = [];
-          testResults.push(`selectedEventId: ${selectedEventId || 'none'}`);
-          testResults.push(`eventAccessLoading: ${eventAccessLoading}`);
-          testResults.push(`userEventAccess: ${Object.keys(userEventAccess).length}`);
-          
-          // Test event access methods
-          const eventAccess = getUserEventAccess('test-event');
-          testResults.push(`getUserEventAccess: ${eventAccess ? 'found' : 'not-found'}`);
-          
-          setResults(testResults);
-        }, [selectedEventId, userEventAccess, eventAccessLoading, getUserEventAccess]);
-
-        const handleRefreshPermissions = async () => {
-          try {
-            await refreshPermissions('test-event');
-            setResults(prev => [...prev, 'refreshPermissions: success']);
-          } catch (error) {
-            setResults(prev => [...prev, 'refreshPermissions: error']);
-          }
-        };
-
-        const handleLoadUserEventAccess = async () => {
-          try {
-            await loadUserEventAccess();
-            setResults(prev => [...prev, 'loadUserEventAccess: success']);
-          } catch (error) {
-            setResults(prev => [...prev, 'loadUserEventAccess: error']);
-          }
-        };
-
-        return (
-          <div>
-            <div data-testid="event-results">{results.join(', ')}</div>
-            <button data-testid="refresh-permissions-btn" onClick={handleRefreshPermissions}>Refresh Permissions</button>
-            <button data-testid="load-event-access-btn" onClick={handleLoadUserEventAccess}>Load Event Access</button>
-          </div>
-        );
-      };
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <EventTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('event-results')).toBeInTheDocument();
-      });
-
-      const refreshBtn = screen.getByTestId('refresh-permissions-btn');
-      fireEvent.click(refreshBtn);
-
-      const loadBtn = screen.getByTestId('load-event-access-btn');
-      fireEvent.click(loadBtn);
-
-      await waitFor(() => {
-        expect(screen.getByTestId('event-results')).toHaveTextContent('refreshPermissions: success');
-        expect(screen.getByTestId('event-results')).toHaveTextContent('loadUserEventAccess: success');
-      });
-    });
-  });
-
-  describe('App Configuration', () => {
-    it('should handle app configuration loading', async () => {
-      const ConfigTestComponent = () => {
-        const { appConfig, appName } = useUnifiedAuth();
-        
-        return (
-          <div>
-            <div data-testid="app-name">{appName}</div>
-            <div data-testid="app-config">{appConfig ? 'loaded' : 'not-loaded'}</div>
-          </div>
-        );
-      };
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <ConfigTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('app-name')).toHaveTextContent('test-app');
-        expect(screen.getByTestId('app-config')).toHaveTextContent('not-loaded');
-      });
-    });
-  });
-
-  describe('Context Value', () => {
-    it('should provide all required context values', async () => {
-      const ContextTestComponent = () => {
-        const context = useUnifiedAuth();
-        const [contextKeys, setContextKeys] = React.useState<string[]>([]);
-
-        React.useEffect(() => {
-          const keys = Object.keys(context).sort();
-          setContextKeys(keys);
-        }, [context]);
-
-        return (
-          <div>
-            <div data-testid="context-keys">{contextKeys.join(', ')}</div>
-          </div>
-        );
-      };
-
-      renderWithProviders(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="test-app">
-          <ContextTestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      await waitFor(() => {
-        const contextKeys = screen.getByTestId('context-keys').textContent;
-        expect(contextKeys).toContain('user');
-        expect(contextKeys).toContain('session');
-        expect(contextKeys).toContain('isAuthenticated');
-        expect(contextKeys).toContain('authLoading');
-        expect(contextKeys).toContain('authError');
-        expect(contextKeys).toContain('error');
-        expect(contextKeys).toContain('supabase');
-        expect(contextKeys).toContain('appName');
-        expect(contextKeys).toContain('signIn');
-        expect(contextKeys).toContain('signUp');
-        expect(contextKeys).toContain('signOut');
-        expect(contextKeys).toContain('resetPassword');
-        expect(contextKeys).toContain('updatePassword');
-        expect(contextKeys).toContain('refreshSession');
-        expect(contextKeys).toContain('permissions');
-        expect(contextKeys).toContain('roles');
-        expect(contextKeys).toContain('accessLevel');
-        expect(contextKeys).toContain('rbacLoading');
-        expect(contextKeys).toContain('rbacError');
-        expect(contextKeys).toContain('selectedEventId');
-        expect(contextKeys).toContain('appConfig');
-        expect(contextKeys).toContain('userEventAccess');
-        expect(contextKeys).toContain('eventAccessLoading');
-        expect(contextKeys).toContain('selectedOrganisationId');
-        expect(contextKeys).toContain('requireOrganisationContext');
-        expect(contextKeys).toContain('hasPermission');
-        expect(contextKeys).toContain('hasAnyPermission');
-        expect(contextKeys).toContain('hasAllPermissions');
-        expect(contextKeys).toContain('hasRole');
-        expect(contextKeys).toContain('hasAccessLevel');
-        expect(contextKeys).toContain('canAccess');
-        expect(contextKeys).toContain('validatePermission');
-        expect(contextKeys).toContain('validateAccess');
-      });
-    });
-  });
-});