@jmruthers/pace-core 0.2.7 → 0.5.1

package/src/rbac/__tests__/components-role-based-router.test.tsx

@@ -1,709 +0,0 @@
-/**
- * @file RoleBasedRouter Component Tests
- * @package @jmruthers/pace-core
- * @module RBAC/Components/RoleBasedRouter
- * @since 2.0.0
- *
- * Comprehensive test suite for the RoleBasedRouter component.
- * Tests all functionality including route protection, permission checking,
- * error handling, strict mode, audit logging, and edge cases.
- */
-
-import React from 'react';
-import { screen, waitFor } from '@testing-library/react';
-import { BrowserRouter, MemoryRouter, Routes, Route } from 'react-router-dom';
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { RoleBasedRouter, RoleBasedRouterProps, RouteConfig } from '../components/RoleBasedRouter';
-import { useCan } from '../hooks';
-import { useUnifiedAuth } from '../../providers/UnifiedAuthProvider';
-import { renderWithProviders, rerenderWithProviders } from '../../__tests__/shared';
-
-// Mock the hooks
-vi.mock('../hooks', () => ({
-  useCan: vi.fn(),
-}));
-
-vi.mock('../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(),
-}));
-
-const mockUseCan = vi.mocked(useCan);
-const mockUseUnifiedAuth = vi.mocked(useUnifiedAuth);
-
-// Test data
-const mockUser = {
-  id: 'user-123',
-  email: 'test@example.com',
-  name: 'Test User'
-};
-
-const mockScope = {
-  organisationId: 'org-456',
-  eventId: 'event-789',
-  appId: undefined
-};
-
-const TestPage = ({ name }: { name: string }) => (
-  <div data-testid={`page-${name}`}>Test Page: {name}</div>
-);
-
-const mockRoutes: RouteConfig[] = [
-  {
-    path: '/dashboard',
-    component: () => <TestPage name="dashboard" />,
-    permissions: ['read:page.dashboard'],
-    meta: { title: 'Dashboard', requiresAuth: true }
-  },
-  {
-    path: '/admin',
-    component: () => <TestPage name="admin" />,
-    permissions: ['manage:page.admin'],
-    roles: ['admin'],
-    accessLevel: 'admin',
-    strictMode: true,
-    meta: { title: 'Admin', requiresAuth: true, hidden: true }
-  },
-  {
-    path: '/settings',
-    component: () => <TestPage name="settings" />,
-    permissions: ['update:page.settings'],
-    meta: { title: 'Settings', requiresAuth: true }
-  }
-];
-
-const defaultProps: RoleBasedRouterProps = {
-  routes: mockRoutes,
-  fallbackRoute: '/unauthorized',
-  children: <div data-testid="router-outlet">Router Outlet</div>
-};
-
-// Helper component to wrap with router
-const RouterWrapper = ({ children, initialEntries = ['/dashboard'] }: { children: React.ReactNode; initialEntries?: string[] }) => (
-  <MemoryRouter initialEntries={initialEntries}>
-    <Routes>
-      <Route path="*" element={children} />
-    </Routes>
-  </MemoryRouter>
-);
-
-describe('RoleBasedRouter Component', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    
-    // Default mock implementations
-    mockUseUnifiedAuth.mockReturnValue({
-      user: mockUser,
-      selectedOrganisationId: 'org-456',
-      selectedEventId: 'event-789',
-      selectedAppId: 'app-101',
-      selectedOrganisation: null,
-      selectedEvent: null,
-      selectedApp: null,
-      isLoading: false,
-      error: null,
-      login: vi.fn(),
-      logout: vi.fn(),
-      selectOrganisation: vi.fn(),
-      selectEvent: vi.fn(),
-      selectApp: vi.fn(),
-    });
-
-    mockUseCan.mockReturnValue({
-      can: true,
-      isLoading: false,
-      error: null,
-      refetch: vi.fn(),
-    });
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('Basic Functionality', () => {
-    it('should render children when no routes are provided', async () => {
-      renderWithProviders(
-        <RouterWrapper>
-          <RoleBasedRouter routes={[]} fallbackRoute="/unauthorized">
-            <div data-testid="no-routes">No Routes</div>
-          </RoleBasedRouter>
-        </RouterWrapper>
-      );
-
-      expect(screen.getByTestId('no-routes')).toBeInTheDocument();
-    });
-
-    it('should render router outlet when routes are provided', async () => {
-      renderWithProviders(
-        <RouterWrapper>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-    });
-
-    it('should handle route matching correctly', async () => {
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      // The router should render the outlet, but the actual route rendering
-      // would be handled by React Router's Outlet component
-      expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-    });
-  });
-
-  describe('Route Protection', () => {
-    it('should check permissions for protected routes', async () => {
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      // The component should check permissions for the current route
-      await waitFor(() => {
-        expect(mockUseCan).toHaveBeenCalled();
-      });
-    });
-
-    it('should handle routes with multiple permissions', async () => {
-      const multiPermissionRoute: RouteConfig[] = [
-        {
-          path: '/multi',
-          component: () => <TestPage name="multi" />,
-          permissions: ['read:page.multi', 'manage:page.multi'],
-          meta: { title: 'Multi Permission' }
-        }
-      ];
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/multi']}>
-          <RoleBasedRouter 
-            routes={multiPermissionRoute} 
-            fallbackRoute="/unauthorized"
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockUseCan).toHaveBeenCalled();
-      });
-    });
-
-    it('should handle routes with roles', async () => {
-      const roleRoute: RouteConfig[] = [
-        {
-          path: '/role-based',
-          component: () => <TestPage name="role-based" />,
-          permissions: ['read:page.role'],
-          roles: ['admin', 'manager'],
-          meta: { title: 'Role Based' }
-        }
-      ];
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/role-based']}>
-          <RoleBasedRouter 
-            routes={roleRoute} 
-            fallbackRoute="/unauthorized"
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockUseCan).toHaveBeenCalled();
-      });
-    });
-
-    it('should handle routes with access levels', async () => {
-      const accessLevelRoute: RouteConfig[] = [
-        {
-          path: '/access-level',
-          component: () => <TestPage name="access-level" />,
-          permissions: ['read:page.access'],
-          accessLevel: 'admin',
-          meta: { title: 'Access Level' }
-        }
-      ];
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/access-level']}>
-          <RoleBasedRouter 
-            routes={accessLevelRoute} 
-            fallbackRoute="/unauthorized"
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockUseCan).toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('Strict Mode', () => {
-    it('should enforce strict mode for routes that require it', async () => {
-      const strictRoute: RouteConfig[] = [
-        {
-          path: '/strict',
-          component: () => <TestPage name="strict" />,
-          permissions: ['manage:page.strict'],
-          strictMode: true,
-          meta: { title: 'Strict Route' }
-        }
-      ];
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/strict']}>
-          <RoleBasedRouter 
-            routes={strictRoute} 
-            fallbackRoute="/unauthorized"
-            strictMode={true}
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockUseCan).toHaveBeenCalled();
-      });
-    });
-
-    it('should not enforce strict mode when disabled globally', async () => {
-      const strictRoute: RouteConfig[] = [
-        {
-          path: '/strict',
-          component: () => <TestPage name="strict" />,
-          permissions: ['manage:page.strict'],
-          strictMode: true,
-          meta: { title: 'Strict Route' }
-        }
-      ];
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/strict']}>
-          <RoleBasedRouter 
-            routes={strictRoute} 
-            fallbackRoute="/unauthorized"
-            strictMode={false}
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockUseCan).toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('Audit Logging', () => {
-    it('should log route access attempts when audit logging is enabled', async () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter 
-            {...defaultProps} 
-            auditLog={true}
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        // The component should log route access attempts
-        expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-      });
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should not log route access attempts when audit logging is disabled', async () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter 
-            {...defaultProps} 
-            auditLog={false}
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(consoleSpy).not.toHaveBeenCalled();
-      });
-
-      consoleSpy.mockRestore();
-    });
-  });
-
-  describe('Callbacks', () => {
-    it('should call onRouteAccess callback when route access is checked', async () => {
-      const onRouteAccess = vi.fn();
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter 
-            {...defaultProps} 
-            onRouteAccess={onRouteAccess}
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(onRouteAccess).toHaveBeenCalled();
-      });
-    });
-
-    it('should call onStrictModeViolation callback when strict mode is violated', async () => {
-      const onStrictModeViolation = vi.fn();
-
-      mockUseCan.mockReturnValue({
-        can: false,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/admin']}>
-          <RoleBasedRouter 
-            {...defaultProps} 
-            strictMode={true}
-            onStrictModeViolation={onStrictModeViolation}
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(onStrictModeViolation).toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle missing organisation context', () => {
-      mockUseUnifiedAuth.mockReturnValue({
-        user: mockUser,
-        selectedOrganisationId: null,
-        selectedEventId: null,
-        selectedAppId: null,
-        selectedOrganisation: null,
-        selectedEvent: null,
-        selectedApp: null,
-        isLoading: false,
-        error: null,
-        login: vi.fn(),
-        logout: vi.fn(),
-        selectOrganisation: vi.fn(),
-        selectEvent: vi.fn(),
-        selectApp: vi.fn(),
-      });
-
-      renderWithProviders(
-        <RouterWrapper>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-      expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-    });
-
-    it('should handle permission check errors gracefully', async () => {
-      const error = new Error('Permission check failed');
-      mockUseCan.mockReturnValue({
-        can: false,
-        isLoading: false,
-        error,
-        refetch: vi.fn(),
-      });
-
-      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(consoleSpy).toHaveBeenCalled();
-      });
-
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle invalid routes gracefully', async () => {
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/invalid-route']}>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      // Should not throw error
-      expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-    });
-  });
-
-  describe('Fallback Route', () => {
-    it('should redirect to fallback route when permission is denied', async () => {
-      mockUseCan.mockReturnValue({
-        can: false,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter 
-            {...defaultProps} 
-            fallbackRoute="/unauthorized"
-          />
-        </RouterWrapper>
-      );
-
-      // The router should handle the redirect
-      await waitFor(() => {
-        expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-      });
-    });
-
-    it('should use default fallback route when not provided', async () => {
-      mockUseCan.mockReturnValue({
-        can: false,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter 
-            routes={mockRoutes}
-            children={<div data-testid="router-outlet">Router Outlet</div>}
-          />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-      });
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle empty routes array', async () => {
-      renderWithProviders(
-        <RouterWrapper>
-          <RoleBasedRouter 
-            routes={[]} 
-            fallbackRoute="/unauthorized"
-          >
-            <div data-testid="empty-routes">Empty Routes</div>
-          </RoleBasedRouter>
-        </RouterWrapper>
-      );
-
-      expect(screen.getByTestId('empty-routes')).toBeInTheDocument();
-    });
-
-    it('should handle routes without permissions', async () => {
-      const noPermissionRoutes: RouteConfig[] = [
-        {
-          path: '/public',
-          component: () => <TestPage name="public" />,
-          permissions: [],
-          meta: { title: 'Public Page' }
-        }
-      ];
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/public']}>
-          <RoleBasedRouter 
-            routes={noPermissionRoutes} 
-            fallbackRoute="/unauthorized"
-          >
-            <div data-testid="router-outlet">Router Outlet</div>
-          </RoleBasedRouter>
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-      });
-    });
-
-    it('should handle undefined user gracefully', async () => {
-      mockUseUnifiedAuth.mockReturnValue({
-        user: null,
-        selectedOrganisationId: 'org-456',
-        selectedEventId: 'event-789',
-        selectedOrganisation: null,
-        selectedEvent: null,
-        isLoading: false,
-        error: null,
-        login: vi.fn(),
-        logout: vi.fn(),
-        selectOrganisation: vi.fn(),
-        selectEvent: vi.fn(),
-      });
-
-      mockUseCan.mockReturnValue({
-        can: false,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(mockUseCan).toHaveBeenCalledWith(
-          '',
-          mockScope,
-          'read:page.dashboard',
-          undefined
-        );
-      });
-    });
-
-    it('should handle rapid route changes', async () => {
-      const { rerender } = renderWithProviders(
-        <RouterWrapper initialEntries={['/dashboard']}>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      // Initially granted
-      mockUseCan.mockReturnValue({
-        can: true,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      await waitFor(() => {
-        expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-      });
-
-      // Change to denied
-      mockUseCan.mockReturnValue({
-        can: false,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      rerender(
-        <RouterWrapper initialEntries={['/admin']}>
-          <RoleBasedRouter {...defaultProps} />
-        </RouterWrapper>
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('router-outlet')).toBeInTheDocument();
-      });
-    });
-  });
-
-  describe('Performance', () => {
-    it('should not re-render unnecessarily when props are the same', async () => {
-      const renderSpy = vi.fn();
-      
-      const TestComponent = () => {
-        renderSpy();
-        return <div data-testid="test-content">Test</div>;
-      };
-
-      mockUseCan.mockReturnValue({
-        can: true,
-        isLoading: false,
-        error: null,
-        refetch: vi.fn(),
-      });
-
-      const { rerender } = renderWithProviders(
-        <RouterWrapper>
-          <RoleBasedRouter 
-            {...defaultProps} 
-            children={<TestComponent />}
-          />
-        </RouterWrapper>
-      );
-
-      // Initial render
-      await waitFor(() => {
-        expect(renderSpy).toHaveBeenCalledTimes(1);
-      });
-
-      // Re-render with same props
-      rerenderWithProviders(
-        <RouterWrapper>
-          <RoleBasedRouter 
-            {...defaultProps} 
-            children={<TestComponent />}
-          />
-        </RouterWrapper>
-      );
-
-      // Should not cause additional renders due to memoization (React 18 Strict Mode renders twice)
-      expect(renderSpy).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('Integration', () => {
-    it('should work with different route configurations', async () => {
-      const complexRoutes: RouteConfig[] = [
-        {
-          path: '/simple',
-          component: () => <TestPage name="simple" />,
-          permissions: ['read:page.simple'],
-          meta: { title: 'Simple' }
-        },
-        {
-          path: '/complex',
-          component: () => <TestPage name="complex" />,
-          permissions: ['read:page.complex', 'manage:page.complex'],
-          roles: ['admin'],
-          accessLevel: 'admin',
-          strictMode: true,
-          pageId: 'complex-page',
-          meta: { title: 'Complex', requiresAuth: true, hidden: false }
-        }
-      ];
-
-      for (const route of complexRoutes) {
-        vi.clearAllMocks();
-        mockUseCan.mockReturnValue({
-          can: true,
-          isLoading: false,
-          error: null,
-          refetch: vi.fn(),
-        });
-
-        renderWithProviders(
-          <RouterWrapper initialEntries={[route.path]}>
-            <RoleBasedRouter 
-              routes={[route]} 
-              fallbackRoute="/unauthorized"
-            >
-              <div data-testid="router-outlet">Router Outlet</div>
-            </RoleBasedRouter>
-          </RouterWrapper>
-        );
-
-        await waitFor(() => {
-          const outlets = screen.getAllByTestId('router-outlet');
-          expect(outlets.length).toBeGreaterThan(0);
-        });
-      }
-    });
-  });
-});