@jmruthers/pace-core 0.5.74 → 0.5.75

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

@@ -1,166 +0,0 @@
-/**
- * @file UnifiedAuthProvider Tests - Simple Working Version
- * @description Basic functionality tests for UnifiedAuthProvider component
- */
-
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { UnifiedAuthProvider, useUnifiedAuth } from '../UnifiedAuthProvider';
-import { TEST_FIXTURES } from '../../__tests__/fixtures/test-data';
-
-// Mock the debug logger
-vi.mock('../../utils/debugLogger', () => ({
-  DebugLogger: {
-    log: vi.fn(),
-  },
-}));
-
-// Create mock Supabase client
-const createMockSupabaseClient = () => ({
-  auth: {
-    getSession: vi.fn(),
-    onAuthStateChange: vi.fn(),
-    signInWithPassword: vi.fn(),
-    signUp: vi.fn(),
-    signOut: vi.fn(),
-    resetPasswordForEmail: vi.fn(),
-    updateUser: vi.fn(),
-    refreshSession: vi.fn(),
-  },
-});
-
-// Test component that uses the unified auth context
-const TestComponent = () => {
-  const auth = useUnifiedAuth();
-  
-  return (
-    <div data-testid="test-component">
-      <div data-testid="user">{auth.user?.email || 'No user'}</div>
-      <div data-testid="isAuthenticated">{auth.isAuthenticated ? 'true' : 'false'}</div>
-      <div data-testid="isLoading">{auth.isLoading ? 'true' : 'false'}</div>
-      <div data-testid="hasErrors">{auth.hasErrors ? 'true' : 'false'}</div>
-      <div data-testid="appName">{auth.appName || 'No app name'}</div>
-      <div data-testid="hasSignIn">{typeof auth.signIn === 'function' ? 'true' : 'false'}</div>
-      <div data-testid="hasSignOut">{typeof auth.signOut === 'function' ? 'true' : 'false'}</div>
-      <div data-testid="hasPermission">{typeof auth.hasPermission === 'function' ? 'true' : 'false'}</div>
-      <div data-testid="hasRole">{typeof auth.hasRole === 'function' ? 'true' : 'false'}</div>
-    </div>
-  );
-};
-
-describe('UnifiedAuthProvider - Simple Tests', () => {
-  let mockSupabaseClient: ReturnType<typeof createMockSupabaseClient>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockSupabaseClient = createMockSupabaseClient();
-    
-    // Setup default mock responses
-    mockSupabaseClient.auth.getSession.mockResolvedValue({
-      data: { session: null, user: null },
-      error: null
-    });
-    
-    mockSupabaseClient.auth.onAuthStateChange.mockReturnValue({
-      data: { subscription: { unsubscribe: vi.fn() } }
-    });
-  });
-
-  describe('Basic Rendering', () => {
-    it('renders without crashing', () => {
-      render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      expect(screen.getByTestId('user')).toHaveTextContent('No user');
-      expect(screen.getByTestId('isAuthenticated')).toHaveTextContent('false');
-      expect(screen.getByTestId('isLoading')).toHaveTextContent('false');
-      expect(screen.getByTestId('hasErrors')).toHaveTextContent('false');
-    });
-
-    it('renders with custom app name', () => {
-      render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Custom App">
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      expect(screen.getByTestId('appName')).toHaveTextContent('Custom App');
-    });
-
-    it('renders without supabase client', () => {
-      render(
-        <UnifiedAuthProvider supabaseClient={null}>
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('Context Values', () => {
-    it('provides all required context values', () => {
-      render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      expect(screen.getByTestId('hasSignIn')).toHaveTextContent('true');
-      expect(screen.getByTestId('hasSignOut')).toHaveTextContent('true');
-      expect(screen.getByTestId('hasPermission')).toHaveTextContent('true');
-      expect(screen.getByTestId('hasRole')).toHaveTextContent('true');
-      expect(screen.getByTestId('appName')).toHaveTextContent('pace-core');
-    });
-  });
-
-  describe('Hook Usage', () => {
-    it('throws error when used outside provider', () => {
-      const TestOutsideProvider = () => {
-        try {
-          useUnifiedAuth();
-          return <div data-testid="no-error">No error</div>;
-        } catch (error) {
-          return <div data-testid="error">{error.message}</div>;
-        }
-      };
-
-      render(<TestOutsideProvider />);
-      // The hook might not throw an error in this test environment
-      // Just verify the component renders
-      expect(screen.getByTestId('no-error')).toBeInTheDocument();
-    });
-  });
-
-  describe('Configuration Options', () => {
-    it('handles custom configuration', () => {
-      render(
-        <UnifiedAuthProvider 
-          supabaseClient={mockSupabaseClient}
-          appName="Test App"
-          enableRBAC={true}
-          enableInactivity={true}
-        >
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      expect(screen.getByTestId('appName')).toHaveTextContent('Test App');
-    });
-
-    it('uses default configuration', () => {
-      render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
-          <TestComponent />
-        </UnifiedAuthProvider>
-      );
-
-      expect(screen.getByTestId('appName')).toHaveTextContent('pace-core');
-    });
-  });
-});

package/src/rbac/cli/__tests__/policy-manager.test.ts

@@ -1,339 +0,0 @@
-/**
- * @file RBAC Policy Manager CLI Tests
- * @package @jmruthers/pace-core
- * @module RBAC/CLI/__tests__
- * @since 1.0.0
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// Mock external dependencies
-vi.mock('@supabase/supabase-js', () => ({
-  createClient: vi.fn(() => ({
-    from: vi.fn(() => ({
-      select: vi.fn(() => ({
-        eq: vi.fn(() => ({
-          order: vi.fn(() => ({
-            data: [],
-            error: null
-          }))
-        }))
-      })),
-      insert: vi.fn(() => ({
-        data: [],
-        error: null
-      })),
-      update: vi.fn(() => ({
-        eq: vi.fn(() => ({
-          data: [],
-          error: null
-        }))
-      })),
-      delete: vi.fn(() => ({
-        eq: vi.fn(() => ({
-          data: [],
-          error: null
-        }))
-      }))
-    })),
-    rpc: vi.fn(() => ({
-      data: null,
-      error: null
-    }))
-  }))
-}));
-
-vi.mock('commander', () => ({
-  Command: vi.fn(() => ({
-    name: vi.fn().mockReturnThis(),
-    description: vi.fn().mockReturnThis(),
-    version: vi.fn().mockReturnThis(),
-    option: vi.fn().mockReturnThis(),
-    command: vi.fn().mockReturnThis(),
-    argument: vi.fn().mockReturnThis(),
-    action: vi.fn().mockReturnThis(),
-    parse: vi.fn().mockReturnThis()
-  }))
-}));
-
-vi.mock('chalk', () => ({
-  default: {
-    red: vi.fn((text) => text),
-    green: vi.fn((text) => text),
-    yellow: vi.fn((text) => text),
-    blue: vi.fn((text) => text),
-    bold: vi.fn((text) => text)
-  }
-}));
-
-vi.mock('ora', () => ({
-  default: vi.fn(() => ({
-    start: vi.fn().mockReturnThis(),
-    succeed: vi.fn().mockReturnThis(),
-    fail: vi.fn().mockReturnThis(),
-    stop: vi.fn().mockReturnThis()
-  }))
-}));
-
-vi.mock('cli-table3', () => ({
-  default: vi.fn(() => ({
-    push: vi.fn(),
-    toString: vi.fn(() => 'Mock table output')
-  }))
-}));
-
-// Mock console methods
-const originalConsole = console;
-beforeEach(() => {
-  console.log = vi.fn();
-  console.error = vi.fn();
-});
-
-afterEach(() => {
-  console.log = originalConsole.log;
-  console.error = originalConsole.error;
-});
-
-describe('[cli] PolicyManager', () => {
-  describe('Class Instantiation', () => {
-    it('creates instance with valid parameters', async () => {
-      // Import the mocked createClient
-      const { createClient } = await import('@supabase/supabase-js');
-      
-      // Test that the class can be instantiated
-      const { PolicyManager } = await import('../policy-manager');
-      const manager = new PolicyManager('https://test.supabase.co', 'test-key');
-      
-      expect(manager).toBeDefined();
-      expect(createClient).toHaveBeenCalledWith('https://test.supabase.co', 'test-key');
-    });
-
-    it('handles invalid Supabase URL', async () => {
-      expect(async () => {
-        const { PolicyManager } = await import('../policy-manager');
-        new PolicyManager('', 'test-key');
-      }).not.toThrow();
-    });
-
-    it('handles invalid Supabase key', async () => {
-      expect(async () => {
-        const { PolicyManager } = await import('../policy-manager');
-        new PolicyManager('https://test.supabase.co', '');
-      }).not.toThrow();
-    });
-  });
-
-  describe('Interface Definitions', () => {
-    it('has correct PolicyConfig interface structure', () => {
-      // Test that the interface is properly defined by checking the mock data structure
-      const mockPolicyConfig = {
-        table_name: 'test_table',
-        page_name: 'test_page',
-        app_name: 'TEST_APP',
-        organisation_column: 'organisation_id',
-        event_column: 'event_id',
-        operations: ['read', 'create', 'update', 'delete'],
-        is_active: true
-      };
-
-      expect(mockPolicyConfig).toHaveProperty('table_name');
-      expect(mockPolicyConfig).toHaveProperty('page_name');
-      expect(mockPolicyConfig).toHaveProperty('app_name');
-      expect(mockPolicyConfig).toHaveProperty('organisation_column');
-      expect(mockPolicyConfig).toHaveProperty('event_column');
-      expect(mockPolicyConfig).toHaveProperty('operations');
-      expect(mockPolicyConfig).toHaveProperty('is_active');
-    });
-
-    it('has correct PolicyAudit interface structure', () => {
-      const mockPolicyAudit = {
-        table_name: 'test_table',
-        policy_name: 'test_policy',
-        operation: 'read',
-        action: 'created',
-        changed_at: '2024-01-01T00:00:00Z',
-        success: true,
-        error_message: undefined
-      };
-
-      expect(mockPolicyAudit).toHaveProperty('table_name');
-      expect(mockPolicyAudit).toHaveProperty('policy_name');
-      expect(mockPolicyAudit).toHaveProperty('operation');
-      expect(mockPolicyAudit).toHaveProperty('action');
-      expect(mockPolicyAudit).toHaveProperty('changed_at');
-      expect(mockPolicyAudit).toHaveProperty('success');
-      expect(mockPolicyAudit).toHaveProperty('error_message');
-    });
-
-    it('has correct HealthCheck interface structure', () => {
-      const mockHealthCheck = {
-        table_name: 'test_table',
-        policy_name: 'test_policy',
-        operation: 'read',
-        is_healthy: true,
-        issues: []
-      };
-
-      expect(mockHealthCheck).toHaveProperty('table_name');
-      expect(mockHealthCheck).toHaveProperty('policy_name');
-      expect(mockHealthCheck).toHaveProperty('operation');
-      expect(mockHealthCheck).toHaveProperty('is_healthy');
-      expect(mockHealthCheck).toHaveProperty('issues');
-    });
-  });
-
-  describe('CLI Command Structure', () => {
-    it('has proper command setup', () => {
-      const { Command } = require('commander');
-      
-      // Test that Command is a function (mocked)
-      expect(Command).toBeInstanceOf(Function);
-    });
-
-    it('handles command line arguments', () => {
-      // Mock process.argv
-      const originalArgv = process.argv;
-      process.argv = ['node', 'policy-manager.js', 'list'];
-      
-      // Test that the CLI can handle arguments
-      expect(process.argv).toContain('list');
-      
-      // Restore original argv
-      process.argv = originalArgv;
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('handles Supabase connection errors gracefully', async () => {
-      const { createClient } = await import('@supabase/supabase-js');
-      const mockedCreateClient = vi.mocked(createClient);
-      
-      // Mock a connection error
-      mockedCreateClient.mockImplementationOnce(() => {
-        throw new Error('Connection failed');
-      });
-
-      await expect(async () => {
-        const { PolicyManager } = await import('../policy-manager');
-        new PolicyManager('https://invalid.supabase.co', 'invalid-key');
-      }).rejects.toThrow('Connection failed');
-    });
-
-    it('handles missing environment variables', () => {
-      const originalEnv = process.env;
-      
-      // Test with missing SUPABASE_URL
-      delete process.env.SUPABASE_URL;
-      delete process.env.SUPABASE_SERVICE_ROLE_KEY;
-      
-      // The CLI should handle missing env vars gracefully
-      expect(process.env.SUPABASE_URL).toBeUndefined();
-      expect(process.env.SUPABASE_SERVICE_ROLE_KEY).toBeUndefined();
-      
-      // Restore original env
-      process.env = originalEnv;
-    });
-  });
-
-  describe('Utility Functions', () => {
-    it('validates table names', () => {
-      const validTableNames = ['users', 'events', 'organisations', 'cake_meal'];
-      const invalidTableNames = ['', '123invalid', 'table with spaces', 'table-with-dashes'];
-      
-      validTableNames.forEach(name => {
-        expect(name).toMatch(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
-      });
-      
-      invalidTableNames.forEach(name => {
-        expect(name).not.toMatch(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
-      });
-    });
-
-    it('validates app names', () => {
-      const validAppNames = ['CAKE', 'PACE', 'TRAC', 'TEST_APP'];
-      const invalidAppNames = ['', 'invalid app', 'app-with-dashes', '123APP'];
-      
-      validAppNames.forEach(name => {
-        expect(name).toMatch(/^[A-Z_][A-Z0-9_]*$/);
-      });
-      
-      invalidAppNames.forEach(name => {
-        expect(name).not.toMatch(/^[A-Z_][A-Z0-9_]*$/);
-      });
-    });
-
-    it('validates operation names', () => {
-      const validOperations = ['read', 'create', 'update', 'delete', 'manage'];
-      const invalidOperations = ['', 'READ', 'invalid', 'read-create'];
-      
-      validOperations.forEach(op => {
-        expect(op).toMatch(/^(read|create|update|delete|manage)$/);
-      });
-      
-      invalidOperations.forEach(op => {
-        expect(op).not.toMatch(/^(read|create|update|delete|manage)$/);
-      });
-    });
-  });
-
-  describe('Mock Data Validation', () => {
-    it('validates mock policy config data', () => {
-      const mockData = {
-        table_name: 'cake_meal',
-        page_name: 'meals',
-        app_name: 'CAKE',
-        organisation_column: 'organisation_id',
-        event_column: 'meal_event_id',
-        operations: ['read', 'create', 'update', 'delete'],
-        is_active: true
-      };
-
-      expect(mockData.table_name).toBe('cake_meal');
-      expect(mockData.page_name).toBe('meals');
-      expect(mockData.app_name).toBe('CAKE');
-      expect(mockData.organisation_column).toBe('organisation_id');
-      expect(mockData.event_column).toBe('meal_event_id');
-      expect(Array.isArray(mockData.operations)).toBe(true);
-      expect(mockData.operations).toContain('read');
-      expect(mockData.operations).toContain('create');
-      expect(mockData.operations).toContain('update');
-      expect(mockData.operations).toContain('delete');
-      expect(typeof mockData.is_active).toBe('boolean');
-    });
-
-    it('validates mock audit data', () => {
-      const mockAudit = {
-        table_name: 'cake_meal',
-        policy_name: 'rbac_read_meals',
-        operation: 'read',
-        action: 'created',
-        changed_at: '2024-01-01T00:00:00Z',
-        success: true
-      };
-
-      expect(mockAudit.table_name).toBe('cake_meal');
-      expect(mockAudit.policy_name).toBe('rbac_read_meals');
-      expect(mockAudit.operation).toBe('read');
-      expect(mockAudit.action).toBe('created');
-      expect(mockAudit.changed_at).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/);
-      expect(typeof mockAudit.success).toBe('boolean');
-    });
-  });
-
-  describe('CLI Integration', () => {
-    it('can be imported without errors', async () => {
-      expect(async () => {
-        const { PolicyManager } = await import('../policy-manager');
-        // Just check that the module can be imported
-        expect(PolicyManager).toBeDefined();
-      }).not.toThrow();
-    });
-
-    it('exports expected interfaces', async () => {
-      const { PolicyManager } = await import('../policy-manager');
-      
-      // The module should be importable
-      expect(PolicyManager).toBeDefined();
-    });
-  });
-});