@jmruthers/pace-core 0.6.4 → 0.6.6

package/src/rbac/components/__tests__/SecureDataProvider.fixed.test.tsx

@@ -1,645 +0,0 @@
-/**
- * @file Secure Data Provider Component Tests (Fixed)
- * @package @jmruthers/pace-core
- * @module RBAC/Components/SecureDataProvider
- * @since 2.0.0
- *
- * Comprehensive test suite for the SecureDataProvider component.
- * Tests cover all functionality including data access control, audit logging,
- * strict mode enforcement, context management, and error scenarios.
- */
-
-import React from 'react';
-import { render, screen, waitFor, act } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { renderWithProviders } from '../../../__tests__/helpers';
-
-// Mock the RBAC logger - define inside factory to avoid hoisting issues
-const mockLogger = {
-  debug: vi.fn(),
-  error: vi.fn(),
-  warn: vi.fn(),
-  info: vi.fn(),
-};
-
-vi.mock('../../config', () => ({
-  getRBACLogger: vi.fn(() => mockLogger),
-  getRBACConfig: vi.fn(() => ({
-    debug: true,
-    logLevel: 'debug',
-    developmentMode: true,
-    audit: {
-      enabled: true,
-      logLevel: 'debug'
-    }
-  })),
-  isDebugMode: vi.fn(() => true),
-  isDevelopmentMode: vi.fn(() => true),
-}));
-
-import { 
-  SecureDataProvider, 
-  SecureDataProviderProps, 
-  useSecureData,
-  DataAccessRecord 
-} from '../SecureDataProvider';
-import { useUnifiedAuth } from '../../../providers/services/UnifiedAuthProvider';
-
-// Mock the UnifiedAuthProvider
-const mockUseUnifiedAuthFn = vi.fn();
-vi.mock('../../../providers/services/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
-  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <div data-testid="auth-provider">{children}</div>
-}));
-
-// useSecureDataAccess has been removed - SecureDataProvider now uses useSecureSupabase internally
-// No mock needed as SecureDataProvider handles validation internally
-
-// Mock useOrganisations to prevent provider requirement
-vi.mock('../../../hooks/useOrganisations', () => ({
-  useOrganisations: vi.fn(() => ({
-    organisations: [],
-    isLoading: false,
-    error: null,
-    refetch: vi.fn(),
-    selectedOrganisation: {
-      id: 'org-456',
-      name: 'Test Org',
-      display_name: 'Test Organisation',
-      description: 'Test',
-      subscription_tier: 'basic',
-      settings: {},
-      is_active: true,
-      created_at: '2023-01-01T00:00:00Z',
-      updated_at: '2023-01-01T00:00:00Z'
-    }
-  }))
-}));
-
-// Mock useEvents
-vi.mock('../../../hooks/useEvents', () => ({
-  useEvents: vi.fn(() => ({
-    events: [],
-    isLoading: false,
-    error: null,
-    refetch: vi.fn(),
-    selectedEvent: {
-      id: 'event-789',
-      event_id: 'event-789',
-      event_name: 'Test Event',
-      event_date: '2023-01-01T00:00:00Z',
-      event_venue: 'Test Venue',
-      event_participants: 100,
-      event_colours: '#FF0000',
-      event_logo: '',
-      organisation_id: 'org-456' as any,
-      is_visible: true,
-      created_at: '2023-01-01T00:00:00Z',
-      updated_at: '2023-01-01T00:00:00Z'
-    },
-    eventLoading: false
-  }))
-}));
-
-// Mock useOrganisationSecurity
-vi.mock('../../../hooks/useOrganisationSecurity', () => ({
-  useOrganisationSecurity: vi.fn(() => ({
-    superAdminContext: {
-      isSuperAdmin: false,
-      isLoading: false
-    },
-    organisationSecurity: {
-      canAccessOrganisation: vi.fn(() => true),
-      canAccessEvent: vi.fn(() => true)
-    }
-  }))
-}));
-
-// Mock useResolvedScope
-const mockUseResolvedScopeFn = vi.fn();
-vi.mock('../../hooks/useResolvedScope', () => ({
-  useResolvedScope: vi.fn(() => mockUseResolvedScopeFn()),
-}));
-
-// Mock supabase client
-const mockSupabase = {
-  from: vi.fn(() => ({
-    select: vi.fn().mockReturnThis(),
-    insert: vi.fn().mockReturnThis(),
-    update: vi.fn().mockReturnThis(),
-    delete: vi.fn().mockReturnThis(),
-    eq: vi.fn().mockReturnThis(),
-    then: vi.fn((resolve) => resolve({ data: [], error: null }))
-  }))
-} as any;
-
-// Test data
-const mockUser = {
-  user: {
-    id: 'user-123',
-    email: 'test@example.com',
-  },
-  supabase: mockSupabase,
-  selectedOrganisation: {
-    id: 'org-456',
-    name: 'Test Org',
-    display_name: 'Test Organisation',
-    description: 'Test',
-    subscription_tier: 'basic',
-    settings: {},
-    is_active: true,
-    created_at: '2023-01-01T00:00:00Z',
-    updated_at: '2023-01-01T00:00:00Z'
-  },
-  selectedEvent: {
-    id: 'event-789',
-    event_id: 'event-789',
-    event_name: 'Test Event',
-    event_date: '2023-01-01T00:00:00Z',
-    event_venue: 'Test Venue',
-    event_participants: 100,
-    event_colours: '#FF0000',
-    event_logo: '',
-    organisation_id: 'org-456' as any,
-    is_visible: true,
-    created_at: '2023-01-01T00:00:00Z',
-    updated_at: '2023-01-01T00:00:00Z'
-  }
-};
-
-const mockScope = {
-  organisationId: 'org-456',
-  eventId: 'event-789',
-  appId: undefined
-};
-
-// Test component that uses the context
-const TestComponent: React.FC<{ testId?: string }> = ({ testId = 'test-component' }) => {
-  const context = useSecureData();
-  
-  return (
-    <div data-testid={testId}>
-      <div data-testid="is-enabled">{context.isEnabled.toString()}</div>
-      <div data-testid="is-strict-mode">{context.isStrictMode.toString()}</div>
-      <div data-testid="is-audit-log-enabled">{context.isAuditLogEnabled.toString()}</div>
-      <div data-testid="data-access-allowed">
-        {context.isDataAccessAllowed('test_table', 'read').toString()}
-      </div>
-      <div data-testid="permissions">
-        {JSON.stringify(context.getDataAccessPermissions())}
-      </div>
-      <div data-testid="history-length">
-        {context.getDataAccessHistory().length}
-      </div>
-    </div>
-  );
-};
-
-// Test wrapper component
-const TestWrapper: React.FC<{ 
-  children: React.ReactNode; 
-  providerProps?: Partial<SecureDataProviderProps> 
-}> = ({ children, providerProps = {} }) => {
-  const queryClient = new QueryClient({
-    defaultOptions: {
-      queries: { retry: false },
-      mutations: { retry: false }
-    }
-  });
-
-  return (
-    <QueryClientProvider client={queryClient}>
-      <SecureDataProvider {...providerProps}>
-        {children}
-      </SecureDataProvider>
-    </QueryClientProvider>
-  );
-};
-
-describe('SecureDataProvider', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    
-    mockUseUnifiedAuthFn.mockReturnValue(mockUser);
-    mockUseResolvedScopeFn.mockReturnValue({
-      resolvedScope: {
-        organisationId: 'org-456',
-        eventId: 'event-789',
-        appId: undefined
-      }
-    });
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Basic Functionality', () => {
-    it('should render children correctly', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <div data-testid="simple-test">Test Content</div>
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('simple-test')).toBeInTheDocument();
-    });
-
-    it('should provide context values with defaults', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('is-enabled')).toHaveTextContent('true');
-      expect(screen.getByTestId('is-strict-mode')).toHaveTextContent('true');
-      expect(screen.getByTestId('is-audit-log-enabled')).toHaveTextContent('true');
-    });
-
-    it('should allow data access when enabled', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // isDataAccessAllowed currently returns true when enabled and user is authenticated
-      // The actual permission checking happens asynchronously via RBAC
-      expect(screen.getByTestId('data-access-allowed')).toHaveTextContent('true');
-    });
-
-    it('should return empty permissions initially', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('permissions')).toHaveTextContent('{}');
-    });
-
-    it('should return empty history initially', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('history-length')).toHaveTextContent('0');
-    });
-  });
-
-  describe('Configuration Options', () => {
-    it('should respect strictMode prop', () => {
-      renderWithProviders(
-        <TestWrapper providerProps={{ strictMode: true }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('is-strict-mode')).toHaveTextContent('true');
-    });
-
-    it('should respect auditLog prop', () => {
-      renderWithProviders(
-        <TestWrapper providerProps={{ auditLog: true }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('is-audit-log-enabled')).toHaveTextContent('true');
-    });
-
-    it('should respect maxHistorySize prop', () => {
-      const onDataAccess = vi.fn();
-      
-      renderWithProviders(
-        <TestWrapper providerProps={{ maxHistorySize: 50, onDataAccess }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('should respect enforceRLS prop', () => {
-      renderWithProviders(
-        <TestWrapper providerProps={{ enforceRLS: true }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('Data Access Control', () => {
-    it('should allow data access when user is authenticated', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // When user is authenticated and scope is available, isDataAccessAllowed returns true
-      expect(screen.getByTestId('data-access-allowed')).toHaveTextContent('true');
-    });
-
-    it('should deny data access when user is not authenticated', () => {
-      mockUseUnifiedAuthFn.mockReturnValue({ 
-        ...mockUser, 
-        user: { ...mockUser.user, id: null as any }
-      });
-      
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // When user is not authenticated, isDataAccessAllowed returns false
-      expect(screen.getByTestId('data-access-allowed')).toHaveTextContent('false');
-    });
-
-    it('should deny data access when organisation context is missing', () => {
-      // Mock resolvedScope to return null organisationId
-      mockUseResolvedScopeFn.mockReturnValue({
-        resolvedScope: null
-      });
-      
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // When scope is null/undefined, isDataAccessAllowed should return false
-      // However, current implementation returns true - this test verifies component renders
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('should allow data access when disabled', () => {
-      // Note: SecureDataProvider doesn't have an isEnabled prop - it's internal state
-      // When disabled internally, isDataAccessAllowed returns true (bypass mode)
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // When enabled is false, isDataAccessAllowed returns true (bypass)
-      // This test verifies the component renders correctly
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('Context Validation', () => {
-    it('should validate context successfully', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // The component should render without errors
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('should handle context validation errors', () => {
-      // Context validation is handled internally by SecureDataProvider
-      // We can't directly mock it anymore, so we'll test the error through the component behavior
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // Component should render without errors
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('Audit Logging', () => {
-    it('should log strict mode status when enabled', async () => {
-      renderWithProviders(
-        <TestWrapper providerProps={{ strictMode: true, auditLog: true }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockLogger.debug).toHaveBeenCalledWith(
-          'Strict mode enabled - all data access attempts will be logged and enforced'
-        );
-      });
-    });
-
-    it('should log RLS enforcement when enabled', async () => {
-      renderWithProviders(
-        <TestWrapper providerProps={{ enforceRLS: true, auditLog: true }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockLogger.debug).toHaveBeenCalledWith(
-          'Strict mode enabled - all data access attempts will be logged and enforced'
-        );
-      });
-    });
-
-    it('should not log when audit logging is disabled', async () => {
-      renderWithProviders(
-        <TestWrapper providerProps={{ strictMode: true, auditLog: false }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // Wait a bit to ensure useEffect has run
-      await waitFor(() => {
-        expect(mockLogger.debug).not.toHaveBeenCalledWith(
-          'Strict mode enabled - all data access attempts will be logged and enforced'
-        );
-      }, { timeout: 100 });
-    });
-  });
-
-  describe('History Management', () => {
-    it('should clear data access history', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('history-length')).toHaveTextContent('0');
-    });
-
-    it('should maintain history within maxHistorySize limit', () => {
-      renderWithProviders(
-        <TestWrapper providerProps={{ maxHistorySize: 5 }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('history-length')).toHaveTextContent('0');
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle missing user gracefully', () => {
-      mockUseUnifiedAuthFn.mockReturnValue({});
-      
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('data-access-allowed')).toHaveTextContent('false');
-    });
-
-    it('should handle missing organisation context gracefully', () => {
-      // Mock resolvedScope to return null
-      mockUseResolvedScopeFn.mockReturnValue({
-        resolvedScope: null
-      });
-      
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      // Component should render without errors even when scope is missing
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('useSecureData Hook', () => {
-    it('should throw error when used outside provider', () => {
-      // Suppress console.error for this test
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-      
-      expect(() => {
-        renderWithProviders(<TestComponent />);
-      }).toThrow('useSecureData must be used within a SecureDataProvider');
-      
-      consoleSpy.mockRestore();
-    });
-
-    it('should return context when used within provider', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('Callback Functions', () => {
-    it('should call onDataAccess callback when provided', () => {
-      const onDataAccess = vi.fn();
-      
-      renderWithProviders(
-        <TestWrapper providerProps={{ onDataAccess }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('should call onStrictModeViolation callback when provided', () => {
-      const onStrictModeViolation = vi.fn();
-      
-      renderWithProviders(
-        <TestWrapper providerProps={{ onStrictModeViolation }}>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('Scope Management', () => {
-    it('should create scope with organisation and event IDs', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-
-    it('should handle missing event ID in scope', () => {
-      mockUseUnifiedAuthFn.mockReturnValue({ ...mockUser, selectedEventId: null });
-      
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-
-  describe('Performance', () => {
-    it('should memoize context value', () => {
-      const { rerender } = renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      const initialHistoryLength = screen.getByTestId('history-length').textContent;
-      
-      rerender(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('history-length')).toHaveTextContent(initialHistoryLength!);
-    });
-  });
-
-  describe('Integration', () => {
-    it('should work with multiple consumers', () => {
-      renderWithProviders(
-        <TestWrapper>
-          <TestComponent testId="component-1" />
-          <TestComponent testId="component-2" />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('component-1')).toBeInTheDocument();
-      expect(screen.getByTestId('component-2')).toBeInTheDocument();
-    });
-
-    it('should maintain state across re-renders', () => {
-      const { rerender } = renderWithProviders(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      
-      rerender(
-        <TestWrapper>
-          <TestComponent />
-        </TestWrapper>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-    });
-  });
-});