@jmruthers/pace-core 0.6.4 → 0.6.6

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

@@ -1,543 +0,0 @@
-/**
- * @file Secure Data Provider Tests
- * @package @jmruthers/pace-core
- * @module RBAC/Components/SecureDataProvider
- * @since 2.0.0
- * 
- * Comprehensive tests for the SecureDataProvider component covering all critical functionality.
- */
-
-import { render, screen, waitFor } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import React, { ReactNode } from 'react';
-import { SecureDataProvider, useSecureData } from './SecureDataProvider';
-import { useUnifiedAuth } from '../../providers/services/UnifiedAuthProvider';
-// useSecureDataAccess has been removed - SecureDataProvider now uses useSecureSupabase internally
-import { UUID, Scope, Permission } from '../types';
-
-// Mock the auth provider
-const mockUseUnifiedAuthFn = vi.fn();
-vi.mock('../../providers/services/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
-  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
-}));
-
-// Mock the secure data access hook
-// useSecureDataAccess has been removed - no longer needed
-
-// Mock useResolvedScope
-const mockUseResolvedScopeFn = vi.fn();
-vi.mock('../../hooks/useResolvedScope', () => ({
-  useResolvedScope: () => mockUseResolvedScopeFn(),
-}));
-
-// Mock useOrganisations to prevent provider requirement
-vi.mock('../../hooks/useOrganisations', () => ({
-  useOrganisations: vi.fn(() => ({
-    organisations: [],
-    isLoading: false,
-    error: null,
-    refetch: vi.fn(),
-    selectedOrganisation: {
-      id: 'org-123',
-      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-456',
-      event_id: 'event-456',
-      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-123' 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 useSecureSupabase
-vi.mock('../hooks/useSecureSupabase', () => ({
-  useSecureSupabase: vi.fn((supabase) => supabase)
-}));
-
-// Mock the RBAC hooks
-vi.mock('../hooks', () => ({
-  useCan: vi.fn()
-}));
-
-import { useCan } from '../hooks';
-
-// Mock data
-const mockUser = {
-  id: 'user-123' as UUID,
-  email: 'test@example.com'
-};
-
-const mockScope: Scope = {
-  organisationId: 'org-123' as UUID,
-  eventId: 'event-456',
-  appId: 'app-789' as UUID
-};
-
-const mockTable = 'users';
-const mockOperation = 'read';
-
-// Test component
-const TestComponent = ({ children }: { children: ReactNode }) => (
-  <div data-testid="test-component">{children}</div>
-);
-
-describe('SecureDataProvider', () => {
-  // useSecureDataAccess has been removed
-  const mockUseCan = vi.mocked(useCan);
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockUseUnifiedAuthFn.mockReturnValue({
-      user: mockUser,
-      isAuthenticated: true,
-      signOut: vi.fn(),
-      // Add other required properties
-    } as any);
-
-    // useSecureDataAccess has been removed - SecureDataProvider handles this internally
-  });
-
-    describe('Provider Initialization', () => {
-    it('renders children correctly', () => {
-      render(
-        <SecureDataProvider>
-          <TestComponent>Test Content</TestComponent>
-        </SecureDataProvider>
-      );
-
-      expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      expect(screen.getByText('Test Content')).toBeInTheDocument();
-    });
-
-    it('initializes with default configuration', () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        return (
-          <div>
-            <div data-testid="enabled">{context.isEnabled.toString()}</div>
-            <div data-testid="strict-mode">{context.isStrictMode.toString()}</div>
-            <div data-testid="audit-log">{context.isAuditLogEnabled.toString()}</div>
-          </div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      expect(screen.getByTestId('enabled')).toHaveTextContent('true');
-      expect(screen.getByTestId('strict-mode')).toHaveTextContent('true');
-      expect(screen.getByTestId('audit-log')).toHaveTextContent('true');
-    });
-
-    it('initializes with custom configuration', () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        return (
-          <div>
-            <div data-testid="enabled">{context.isEnabled.toString()}</div>
-            <div data-testid="strict-mode">{context.isStrictMode.toString()}</div>
-            <div data-testid="audit-log">{context.isAuditLogEnabled.toString()}</div>
-          </div>
-        );
-      };
-
-      render(
-        <SecureDataProvider
-          strictMode={false}
-          auditLog={false}
-        >
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      expect(screen.getByTestId('enabled')).toHaveTextContent('true');
-      expect(screen.getByTestId('strict-mode')).toHaveTextContent('false');
-      expect(screen.getByTestId('audit-log')).toHaveTextContent('false');
-    });
-  });
-
-  describe('Data Access Validation', () => {
-    it('validates data access correctly', async () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const isAllowed = context.isDataAccessAllowed(mockTable, mockOperation, mockScope);
-        
-        return (
-          <div data-testid="is-allowed">{isAllowed.toString()}</div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('is-allowed')).toHaveTextContent('true');
-      });
-    });
-
-    it('denies data access when user lacks permissions', async () => {
-      // useSecureDataAccess has been removed - SecureDataProvider handles this internally
-
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const isAllowed = context.isDataAccessAllowed('admin_users', 'delete', mockScope);
-        
-        return (
-          <div data-testid="is-allowed">{isAllowed.toString()}</div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('is-allowed')).toHaveTextContent('true');
-      });
-    });
-
-    it('validates data access attempts', async () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const isValid = context.validateDataAccess(mockTable, mockOperation, mockScope);
-        
-        return (
-          <div data-testid="is-valid">{isValid.toString()}</div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('is-valid')).toHaveTextContent('false');
-      });
-    });
-  });
-
-  describe('Data Access Permissions Management', () => {
-    it('gets all data access permissions for current user', async () => {
-      const mockPermissions = {
-        'users': ['read', 'create'],
-        'events': ['read', 'update']
-      };
-
-      // useSecureDataAccess has been removed - SecureDataProvider handles this internally
-
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const permissions = context.getDataAccessPermissions();
-        
-        return (
-          <div data-testid="permissions">{JSON.stringify(permissions)}</div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('permissions')).toHaveTextContent('{}');
-      });
-    });
-
-    it('tracks data access history', async () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const history = context.getDataAccessHistory();
-        
-        return (
-          <div data-testid="history-length">{history.length.toString()}</div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('history-length')).toBeInTheDocument();
-      });
-    });
-
-    it('clears data access history', async () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const clearHistory = context.clearDataAccessHistory;
-        
-        return (
-          <button data-testid="clear-button" onClick={clearHistory}>
-            Clear History
-          </button>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      expect(screen.getByTestId('clear-button')).toBeInTheDocument();
-    });
-  });
-
-  describe('Event Handling', () => {
-    it('calls onDataAccess callback when data access is attempted', async () => {
-      const onDataAccess = vi.fn();
-      const TestConsumer = () => {
-        const context = useSecureData();
-        context.isDataAccessAllowed(mockTable, mockOperation, mockScope);
-        
-        return <div>Test</div>;
-      };
-
-      render(
-        <SecureDataProvider onDataAccess={onDataAccess}>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(onDataAccess).not.toHaveBeenCalled();
-      });
-    });
-
-    it('calls onStrictModeViolation callback when strict mode is violated', async () => {
-      const onStrictModeViolation = vi.fn();
-      // useSecureDataAccess has been removed - SecureDataProvider handles this internally
-      const TestConsumer = () => {
-        const context = useSecureData();
-        context.isDataAccessAllowed('admin_users', 'delete', mockScope);
-        
-        return <div>Test</div>;
-      };
-
-      render(
-        <SecureDataProvider 
-          strictMode={true}
-          onStrictModeViolation={onStrictModeViolation}
-        >
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(onStrictModeViolation).not.toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('handles data access validation errors gracefully', async () => {
-      // useSecureDataAccess has been removed - SecureDataProvider handles this internally
-
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const isAllowed = context.isDataAccessAllowed(mockTable, mockOperation, mockScope);
-        
-        return (
-          <div data-testid="is-allowed">{isAllowed.toString()}</div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('is-allowed')).toHaveTextContent('true');
-      });
-    });
-
-    it('handles missing user context gracefully', async () => {
-      mockUseUnifiedAuthFn.mockReturnValue({
-        user: null,
-        isAuthenticated: false,
-        signOut: vi.fn(),
-      } as any);
-
-      const TestConsumer = () => {
-        const context = useSecureData();
-        const isAllowed = context.isDataAccessAllowed(mockTable, mockOperation, mockScope);
-        
-        return (
-          <div data-testid="is-allowed">{isAllowed.toString()}</div>
-        );
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('is-allowed')).toHaveTextContent('false');
-      });
-    });
-  });
-
-  describe('Context Hook', () => {
-    it('throws error when used outside provider', () => {
-      const TestConsumer = () => {
-        useSecureData();
-        return <div>Test</div>;
-      };
-
-      expect(() => {
-        render(<TestConsumer />);
-      }).toThrow('useSecureData must be used within a SecureDataProvider');
-    });
-
-    it('provides context when used within provider', () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        expect(context).toBeDefined();
-        expect(context.isDataAccessAllowed).toBeInstanceOf(Function);
-        expect(context.getDataAccessPermissions).toBeInstanceOf(Function);
-        expect(context.validateDataAccess).toBeInstanceOf(Function);
-        expect(context.isEnabled).toBeDefined();
-        expect(context.isStrictMode).toBeDefined();
-        expect(context.isAuditLogEnabled).toBeDefined();
-        
-        return <div>Test</div>;
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-    });
-  });
-
-  describe('Performance', () => {
-    it('memoizes context value to prevent unnecessary re-renders', () => {
-      let renderCount = 0;
-      
-      const TestConsumer = React.memo(() => {
-        renderCount++;
-        const context = useSecureData();
-        return <div data-testid="render-count">{renderCount}</div>;
-      });
-
-      const { rerender } = render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      const initialRenderCount = renderCount;
-      
-      // Re-render with same props
-      rerender(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      // Should not cause additional renders due to memoization
-      expect(renderCount).toBe(initialRenderCount);
-    });
-  });
-
-  describe('Integration with useSecureDataAccess', () => {
-    it('integrates with secure data access system', () => {
-      const TestConsumer = () => {
-        const context = useSecureData();
-        context.isDataAccessAllowed(mockTable, mockOperation, mockScope);
-        
-        return <div>Test</div>;
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      // useSecureDataAccess has been removed - this test verifies the component works
-      // expect(mockUseSecureDataAccess).toHaveBeenCalled();
-    });
-
-    it('passes through secure data access functionality', () => {
-      // useSecureDataAccess has been removed - SecureDataProvider handles this internally
-      const TestConsumer = () => {
-        const context = useSecureData();
-        context.isDataAccessAllowed(mockTable, mockOperation, mockScope);
-        
-        return <div>Test</div>;
-      };
-
-      render(
-        <SecureDataProvider>
-          <TestConsumer />
-        </SecureDataProvider>
-      );
-
-      // Component should render without errors
-      expect(screen.getByText('Test')).toBeInTheDocument();
-    });
-  });
-});