@jmruthers/pace-core 0.5.190 → 0.5.193

package/src/hooks/__tests__/usePermissionCache.simple.test.ts

@@ -0,0 +1,192 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import React from 'react';
+import { TestWrapper } from '../../__tests__/helpers/test-utils';
+import { useRBAC } from '../../rbac/hooks/useRBAC';
+
+// Mock the useRBAC hook
+vi.mock('../../rbac/hooks/useRBAC');
+
+// Mock isPermittedCached from RBAC API (used by usePermissionCache)
+vi.mock('../../rbac/api', async () => {
+  const actual = await vi.importActual('../../rbac/api');
+  return {
+    ...actual,
+    isPermittedCached: vi.fn().mockResolvedValue(true),
+  };
+});
+
+// Mock logger
+vi.mock('../../utils/core/logger', () => {
+  const mockLoggerInstance = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  };
+  return {
+    createLogger: vi.fn(() => mockLoggerInstance),
+    logger: mockLoggerInstance,
+  };
+});
+
+// Mock useOrganisations hook (required by usePermissionCache)
+const mockOrganisationContext = {
+  selectedOrganisation: {
+    id: 'test-org-id',
+    name: 'Test Organisation',
+    display_name: 'Test Organisation',
+    slug: 'test-org',
+    description: 'Test organisation',
+    subscription_tier: 'basic',
+    settings: {},
+    is_active: true,
+    created_at: '2023-01-01T00:00:00Z',
+    updated_at: '2023-01-01T00:00:00Z',
+  },
+  organisations: [],
+  userMemberships: [],
+  isLoading: false,
+  error: null,
+  hasValidOrganisationContext: true,
+  setSelectedOrganisation: vi.fn(),
+  switchOrganisation: vi.fn().mockResolvedValue(undefined),
+  getUserRole: vi.fn().mockReturnValue('member'),
+  validateOrganisationAccess: vi.fn().mockReturnValue(true),
+  ensureOrganisationContext: vi.fn().mockReturnValue(null),
+  refreshOrganisations: vi.fn().mockResolvedValue(undefined),
+  getPrimaryOrganisation: vi.fn().mockReturnValue(null),
+  isOrganisationSecure: vi.fn().mockReturnValue(true),
+};
+
+vi.mock('../useOrganisations', () => ({
+  useOrganisations: () => mockOrganisationContext,
+}));
+
+// Mock useUnifiedAuth (required by usePermissionCache)
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: { id: 'test-user-id' },
+  session: null,
+  appName: 'test-app',
+  selectedOrganisation: { id: 'test-org-id' },
+  selectedEvent: null,
+  supabase: {},
+  isLoading: false,
+  error: null,
+}));
+vi.mock('../../providers/services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => children,
+}));
+
+// Mock useEvents hook (optional - wrapped in try/catch in usePermissionCache)
+vi.mock('../useEvents', () => ({
+  useEvents: vi.fn(() => ({
+    selectedEvent: { event_id: 'event-123' },
+    events: [],
+    isLoading: false,
+    error: null,
+  })),
+}));
+
+const mockUseRBAC = vi.mocked(useRBAC);
+
+// Import after mocking
+import { usePermissionCache } from '../usePermissionCache';
+import { isPermittedCached } from '../../rbac/api';
+const mockIsPermittedCached = vi.mocked(isPermittedCached);
+
+describe('usePermissionCache - Simple Tests', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    // Reset isPermittedCached mock
+    mockIsPermittedCached.mockClear();
+    mockIsPermittedCached.mockResolvedValue(true);
+    
+    // Mock the useRBAC hook return value
+    mockUseRBAC.mockReturnValue({
+      hasPermission: vi.fn().mockResolvedValue(true),
+      user: { id: 'test-user-id' }
+    });
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+  });
+
+  it('should render without errors', () => {
+    const { result } = renderHook(() => usePermissionCache(), {
+      wrapper: TestWrapper
+    });
+
+    expect(result.current).toHaveProperty('checkPermission');
+    expect(result.current).toHaveProperty('checkMultiplePermissions');
+    expect(result.current).toHaveProperty('getCachedPermissions');
+    expect(result.current).toHaveProperty('invalidateCache');
+    expect(result.current).toHaveProperty('getDebugInfo');
+    expect(result.current).toHaveProperty('getAuditTrail');
+  });
+
+  it('should check permission and return result', async () => {
+    mockIsPermittedCached.mockResolvedValueOnce(true);
+    mockUseRBAC.mockReturnValue({
+      hasPermission: vi.fn().mockResolvedValue(true),
+      user: { id: 'test-user-id' }
+    });
+
+    const { result } = renderHook(() => usePermissionCache(), {
+      wrapper: TestWrapper
+    });
+
+    const permission = await result.current.checkPermission('read', 'dashboard');
+
+    expect(permission).toBe(true);
+    expect(mockIsPermittedCached).toHaveBeenCalled();
+  });
+
+  it('should handle permission check errors gracefully', async () => {
+    const { logger } = await import('../../utils/core/logger');
+    mockIsPermittedCached.mockRejectedValueOnce(new Error('Database error'));
+    
+    mockUseRBAC.mockReturnValue({
+      hasPermission: vi.fn().mockResolvedValue(true),
+      user: { id: 'test-user-id' }
+    });
+
+    const { result } = renderHook(() => usePermissionCache(), {
+      wrapper: TestWrapper
+    });
+
+    const permission = await result.current.checkPermission('read', 'dashboard');
+
+    expect(permission).toBe(false);
+    // Verify error was logged using logger
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  it('should provide debug information', () => {
+    const { result } = renderHook(() => usePermissionCache(), {
+      wrapper: TestWrapper
+    });
+
+    const debugInfo = result.current.getDebugInfo();
+
+    expect(debugInfo).toHaveProperty('cacheSize');
+    expect(debugInfo).toHaveProperty('cacheHits');
+    expect(debugInfo).toHaveProperty('cacheMisses');
+    expect(debugInfo).toHaveProperty('totalChecks');
+    expect(debugInfo).toHaveProperty('averageResponseTime');
+    expect(debugInfo).toHaveProperty('lastInvalidation');
+  });
+
+  it('should provide audit trail', () => {
+    const { result } = renderHook(() => usePermissionCache(), {
+      wrapper: TestWrapper
+    });
+
+    const auditTrail = result.current.getAuditTrail();
+
+    expect(Array.isArray(auditTrail)).toBe(true);
+  });
+});