@jmruthers/pace-core 0.5.54 → 0.5.55

package/src/hooks/usePermissionCache.test.ts

@@ -1,542 +1,411 @@
 /**
- * @file usePermissionCache Hook Tests
- * @description Comprehensive tests for the usePermissionCache hook
+ * @file Permission Cache Hook Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/usePermissionCache
+ * @since 0.3.0
+ * 
+ * Comprehensive tests for the usePermissionCache hook covering all critical functionality.
  */
 
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { usePermissionCache } from './usePermissionCache';
 import { useRBAC } from '../rbac/hooks/useRBAC';
-import type { Operation } from '../rbac/types';
 
-// Mock the useRBAC hook
+// Mock the RBAC hook
 vi.mock('../rbac/hooks/useRBAC', () => ({
   useRBAC: vi.fn()
 }));
 
-const mockUseRBAC = vi.mocked(useRBAC);
-
-describe('usePermissionCache Hook', () => {
-  const mockUser = {
-    id: 'user-123',
-    email: 'test@example.com'
-  };
-
-  const mockRBACContext = {
-    user: mockUser,
-    globalRole: null,
-    organisationRole: null,
-    eventAppRole: null,
-    hasPermission: vi.fn(),
-    hasGlobalPermission: vi.fn(),
-    isSuperAdmin: false,
-    isOrgAdmin: false,
-    isEventAdmin: false,
-    canManageOrganisation: false,
-    canManageEvent: false,
-    isLoading: false,
-    error: null
-  };
+describe('usePermissionCache', () => {
+  const mockUseRBAC = vi.mocked(useRBAC);
+  
+  // Create stable mock objects to prevent unnecessary re-renders
+  const stableMockRBAC = {
+    hasPermission: vi.fn().mockResolvedValue(true),
+    isSuperAdmin: vi.fn().mockResolvedValue(false),
+    isOrgAdmin: vi.fn().mockResolvedValue(false),
+    isEventAdmin: vi.fn().mockResolvedValue(false),
+    // Add other required properties
+  } as any;
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockUseRBAC.mockReturnValue(mockRBACContext);
-    vi.useFakeTimers();
+    // Reset the mock functions to return the expected values
+    stableMockRBAC.hasPermission.mockResolvedValue(true);
+    stableMockRBAC.isSuperAdmin.mockResolvedValue(false);
+    stableMockRBAC.isOrgAdmin.mockResolvedValue(false);
+    stableMockRBAC.isEventAdmin.mockResolvedValue(false);
+    mockUseRBAC.mockReturnValue(stableMockRBAC);
   });
 
   afterEach(() => {
-    vi.useRealTimers();
+    vi.restoreAllMocks();
   });
 
-  describe('Initialization', () => {
+  describe('Hook Initialization', () => {
     it('initializes with default configuration', () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      expect(result.current.checkPermission).toBeDefined();
-      expect(result.current.checkMultiplePermissions).toBeDefined();
-      expect(result.current.getCachedPermissions).toBeDefined();
-      expect(result.current.invalidateCache).toBeDefined();
+      expect(result.current).toBeDefined();
+      expect(result.current.checkPermission).toBeInstanceOf(Function);
+      expect(result.current.checkMultiplePermissions).toBeInstanceOf(Function);
+      expect(result.current.getCachedPermissions).toBeInstanceOf(Function);
+      expect(result.current.invalidateCache).toBeInstanceOf(Function);
       expect(result.current.getDebugInfo).toBeDefined();
-      expect(result.current.getAuditTrail).toBeDefined();
     });
 
     it('initializes with custom configuration', () => {
       const customConfig = {
         defaultTTL: 10000,
         maxCacheSize: 500,
-        enableLogging: false,
+        enableLogging: true,
         enableAuditTrail: false
       };
 
       const { result } = renderHook(() => usePermissionCache(customConfig));
 
-      expect(result.current.checkPermission).toBeDefined();
-      expect(result.current.checkMultiplePermissions).toBeDefined();
-      expect(result.current.getCachedPermissions).toBeDefined();
-      expect(result.current.invalidateCache).toBeDefined();
+      expect(result.current).toBeDefined();
       expect(result.current.getDebugInfo).toBeDefined();
-      expect(result.current.getAuditTrail).toBeDefined();
+    });
+
+    it('depends on useRBAC hook', () => {
+      renderHook(() => usePermissionCache());
+      expect(mockUseRBAC).toHaveBeenCalled();
     });
   });
 
   describe('Permission Checking', () => {
-    it('checks permission and caches result', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
+    it('checks single permission and caches result', async () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      const permission = await result.current.checkPermission('read', 'dashboard');
+      const hasPermission = await result.current.checkPermission('read', 'users');
+      expect(hasPermission).toBe(true);
+      expect(mockUseRBAC().hasPermission).toHaveBeenCalledWith('read', 'users');
 
-      expect(permission).toBe(true);
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledWith('read', 'dashboard');
+      // Check that result is cached
+      const cachedResult = await result.current.checkPermission('read', 'users');
+      expect(cachedResult).toBe(true);
     });
 
-    it('returns cached result on subsequent calls', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
+    it('checks multiple permissions in batch', async () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      // First call
-      const firstResult = await result.current.checkPermission('read', 'dashboard');
-      expect(firstResult).toBe(true);
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(1);
+      const permissions = [
+        ['read', 'users'],
+        ['create', 'users'],
+        ['update', 'users'],
+        ['delete', 'users']
+      ];
 
-      // Second call should use cache
-      const secondResult = await result.current.checkPermission('read', 'dashboard');
-      expect(secondResult).toBe(true);
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(1);
+      const results = await result.current.checkMultiplePermissions(permissions);
+      expect(results).toHaveLength(4);
+      expect(results.every(r => r.hasPermission)).toBe(true);
     });
 
-    it('handles permission check errors', async () => {
-      mockRBACContext.hasPermission.mockRejectedValue(new Error('Permission check failed'));
+    it('handles permission check errors gracefully', async () => {
+      mockUseRBAC.mockReturnValue({
+        hasPermission: vi.fn().mockRejectedValue(new Error('Permission check failed')),
+        isSuperAdmin: vi.fn().mockResolvedValue(false),
+        isOrgAdmin: vi.fn().mockResolvedValue(false),
+        isEventAdmin: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => usePermissionCache());
 
-      const permission = await result.current.checkPermission('read', 'dashboard');
-
-      expect(permission).toBe(false);
+      const hasPermission = await result.current.checkPermission('read', 'users');
+      expect(hasPermission).toBe(false);
     });
 
-    it('handles different operations and page IDs', async () => {
-      mockRBACContext.hasPermission
-        .mockResolvedValueOnce(true)
-        .mockResolvedValueOnce(false)
-        .mockResolvedValueOnce(true);
+    it('handles missing RBAC hook gracefully', () => {
+      mockUseRBAC.mockReturnValue(null as any);
 
       const { result } = renderHook(() => usePermissionCache());
 
-      const readPermission = await result.current.checkPermission('read', 'dashboard');
-      const createPermission = await result.current.checkPermission('create', 'events');
-      const updatePermission = await result.current.checkPermission('update', 'users');
-
-      expect(readPermission).toBe(true);
-      expect(createPermission).toBe(false);
-      expect(updatePermission).toBe(true);
+      expect(result.current).toBeDefined();
+      expect(result.current.checkPermission).toBeInstanceOf(Function);
     });
   });
 
-  describe('Multiple Permission Checking', () => {
-    it('checks multiple permissions efficiently', async () => {
-      mockRBACContext.hasPermission
-        .mockResolvedValueOnce(true)
-        .mockResolvedValueOnce(false)
-        .mockResolvedValueOnce(true);
-
+  describe('Cache Management', () => {
+    it('caches permission results with TTL', async () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      const permissions = [
-        ['read', 'dashboard'],
-        ['create', 'events'],
-        ['update', 'users']
-      ] as Array<[Operation, string]>;
-
-      const results = await result.current.checkMultiplePermissions(permissions);
-
-      expect(results).toHaveLength(3);
-      expect(results[0].hasPermission).toBe(true);
-      expect(results[1].hasPermission).toBe(false);
-      expect(results[2].hasPermission).toBe(true);
-      expect(results[0].cached).toBe(false);
-      expect(results[1].cached).toBe(false);
-      expect(results[2].cached).toBe(false);
+      // First check
+      await result.current.checkPermission('read', 'users');
+      
+      // Second check should use cache
+      await result.current.checkPermission('read', 'users');
+      
+      expect(mockUseRBAC().hasPermission).toHaveBeenCalledTimes(1);
     });
 
-    it('uses cache for previously checked permissions', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache());
-
-      // First check individual permission
-      await result.current.checkPermission('read', 'dashboard');
+    it('expires cached results after TTL', async () => {
+      const { result } = renderHook(() => usePermissionCache({
+        defaultTTL: 100 // 100ms TTL
+      }));
 
-      // Then check multiple permissions including the cached one
-      const permissions = [
-        ['read', 'dashboard'], // Should be cached
-        ['create', 'events']   // Should be fresh
-      ] as Array<[Operation, string]>;
-
-      const results = await result.current.checkMultiplePermissions(permissions);
-
-      expect(results[0].cached).toBe(true);
-      expect(results[1].cached).toBe(false);
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(2); // Once for each unique permission
+      // First check
+      await result.current.checkPermission('read', 'users');
+      
+      // Wait for TTL to expire
+      await new Promise(resolve => setTimeout(resolve, 150));
+      
+      // Second check should not use cache
+      await result.current.checkPermission('read', 'users');
+      
+      expect(mockUseRBAC().hasPermission).toHaveBeenCalledTimes(2);
     });
-  });
-
-  describe('Cache Management', () => {
-    it('invalidates all cache', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
 
+    it('invalidates cache correctly', async () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      // Check a permission to populate cache
-      await result.current.checkPermission('read', 'dashboard');
-
+      // Check permission
+      await result.current.checkPermission('read', 'users');
+      
       // Invalidate cache
       result.current.invalidateCache();
-
-      // Check same permission again - should not be cached
-      await result.current.checkPermission('read', 'dashboard');
-
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(2);
-    });
-
-    it('invalidates cache by pattern', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache());
-
-      // Check multiple permissions
-      await result.current.checkPermission('read', 'dashboard');
-      await result.current.checkPermission('read', 'events');
-      await result.current.checkPermission('create', 'dashboard');
-
-      // Invalidate only 'read' permissions
-      result.current.invalidateCache('read:.*');
-
-      // Check permissions again
-      await result.current.checkPermission('read', 'dashboard');
-      await result.current.checkPermission('create', 'dashboard');
-
-      // 'read' permissions should be fresh, 'create' should be cached
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(4); // 2 fresh + 2 cached
+      
+      // Check again - should not use cache
+      await result.current.checkPermission('read', 'users');
+      
+      expect(mockUseRBAC().hasPermission).toHaveBeenCalledTimes(2);
     });
 
-    it('enforces maximum cache size', async () => {
-      const config = { maxCacheSize: 2 };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
-
-      // Add more permissions than max cache size
-      await result.current.checkPermission('read', 'page1');
-      await result.current.checkPermission('read', 'page2');
-      await result.current.checkPermission('read', 'page3');
+    it('respects max cache size', async () => {
+      const { result } = renderHook(() => usePermissionCache({
+        maxCacheSize: 2
+      }));
 
-      // Should have evicted oldest entries
+      // Fill cache beyond max size
+      await result.current.checkPermission('read', 'users');
+      await result.current.checkPermission('create', 'users');
+      await result.current.checkPermission('update', 'users');
+      await result.current.checkPermission('delete', 'users');
+      
+      // Check that cache size is respected
       const debugInfo = result.current.getDebugInfo();
       expect(debugInfo.cacheSize).toBeLessThanOrEqual(2);
     });
   });
 
-  describe('TTL and Expiration', () => {
-    it('respects TTL for cache entries', async () => {
-      const config = { defaultTTL: 1000 }; // 1 second
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
-
-      // Check permission
-      await result.current.checkPermission('read', 'dashboard');
-
-      // Fast-forward time past TTL
-      act(() => {
-        vi.advanceTimersByTime(1001);
-      });
-
-      // Check same permission again - should not be cached
-      await result.current.checkPermission('read', 'dashboard');
-
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(2);
-    });
-
-    it('respects custom TTL for individual permissions', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache());
-
-      // Check permission with custom TTL
-      await result.current.checkPermission('read', 'dashboard', 500);
-
-      // Fast-forward time past custom TTL but before default TTL
-      act(() => {
-        vi.advanceTimersByTime(501);
-      });
-
-      // Check same permission again - should not be cached
-      await result.current.checkPermission('read', 'dashboard');
-
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(2);
-    });
-  });
-
-  describe('Concurrent Requests', () => {
-    it('handles concurrent requests for same permission', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache());
-
-      // Make multiple concurrent requests for same permission
-      const promises = [
-        result.current.checkPermission('read', 'dashboard'),
-        result.current.checkPermission('read', 'dashboard'),
-        result.current.checkPermission('read', 'dashboard')
-      ];
-
-      const results = await Promise.all(promises);
-
-      expect(results).toEqual([true, true, true]);
-      // Should only call the underlying function once
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(1);
-    });
-
-    it('handles concurrent requests for different permissions', async () => {
-      mockRBACContext.hasPermission
-        .mockResolvedValueOnce(true)
-        .mockResolvedValueOnce(false)
-        .mockResolvedValueOnce(true);
-
-      const { result } = renderHook(() => usePermissionCache());
-
-      // Make concurrent requests for different permissions
-      const promises = [
-        result.current.checkPermission('read', 'dashboard'),
-        result.current.checkPermission('create', 'events'),
-        result.current.checkPermission('update', 'users')
-      ];
-
-      const results = await Promise.all(promises);
-
-      expect(results).toEqual([true, false, true]);
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(3);
-    });
-  });
-
   describe('Debug Information', () => {
-    it('provides debug information', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
+    it('provides debug information', () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      // Check some permissions
-      await result.current.checkPermission('read', 'dashboard');
-      await result.current.checkPermission('create', 'events');
-
       const debugInfo = result.current.getDebugInfo();
-
-      expect(debugInfo.cacheSize).toBe(2);
+      expect(debugInfo).toBeDefined();
+      expect(debugInfo.cacheSize).toBe(0);
       expect(debugInfo.cacheHits).toBe(0);
-      expect(debugInfo.cacheMisses).toBe(2);
-      expect(debugInfo.totalChecks).toBe(2);
-      expect(debugInfo.averageResponseTime).toBeGreaterThan(0);
-      expect(debugInfo.lastInvalidation).toBeGreaterThan(0);
+      expect(debugInfo.cacheMisses).toBe(0);
+      expect(debugInfo.totalChecks).toBe(0);
+      expect(debugInfo.averageResponseTime).toBe(0);
+      expect(debugInfo.lastInvalidation).toBe(0);
     });
 
     it('tracks cache hits and misses', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
       const { result } = renderHook(() => usePermissionCache());
 
-      // First call - cache miss
-      await result.current.checkPermission('read', 'dashboard');
+      // First check - cache miss
+      await result.current.checkPermission('read', 'users');
+      
+      // Second check - cache hit
+      await result.current.checkPermission('read', 'users');
       
-      // Second call - cache hit
-      await result.current.checkPermission('read', 'dashboard');
-
       const debugInfo = result.current.getDebugInfo();
-
-      expect(debugInfo.cacheHits).toBe(1);
       expect(debugInfo.cacheMisses).toBe(1);
+      expect(debugInfo.cacheHits).toBe(1);
       expect(debugInfo.totalChecks).toBe(2);
     });
-  });
-
-  describe('Audit Trail', () => {
-    it('records audit trail when enabled', async () => {
-      const config = { enableAuditTrail: true };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
-
-      await result.current.checkPermission('read', 'dashboard');
 
-      const auditTrail = result.current.getAuditTrail();
+    it('tracks average response time', async () => {
+      const { result } = renderHook(() => usePermissionCache());
 
-      expect(auditTrail).toHaveLength(1);
-      expect(auditTrail[0].operation).toBe('read');
-      expect(auditTrail[0].pageId).toBe('dashboard');
-      expect(auditTrail[0].result).toBe(true);
-      expect(auditTrail[0].cached).toBe(false);
-      expect(auditTrail[0].userId).toBe('user-123');
+      // Mock slow permission check
+      mockUseRBAC.mockReturnValue({
+        hasPermission: vi.fn().mockImplementation(() => 
+          new Promise(resolve => setTimeout(() => resolve(true), 100))
+        ),
+        isSuperAdmin: vi.fn().mockResolvedValue(false),
+        isOrgAdmin: vi.fn().mockResolvedValue(false),
+        isEventAdmin: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
+
+      await result.current.checkPermission('read', 'users');
+      
+      const debugInfo = result.current.getDebugInfo();
+      expect(debugInfo.averageResponseTime).toBeGreaterThan(0);
     });
+  });
 
-    it('does not record audit trail when disabled', async () => {
-      const config = { enableAuditTrail: false };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
+  describe('Audit Trail', () => {
+    it('logs permission checks when audit trail is enabled', async () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
-      await result.current.checkPermission('read', 'dashboard');
+      const { result } = renderHook(() => usePermissionCache({
+        enableAuditTrail: true,
+        enableLogging: true
+      }));
 
-      const auditTrail = result.current.getAuditTrail();
+      await result.current.checkPermission('read', 'users');
+      
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('[PermissionCache] read:users = true (fresh)')
+      );
 
-      expect(auditTrail).toHaveLength(0);
+      consoleSpy.mockRestore();
     });
 
-    it('limits audit trail size', async () => {
-      const config = { enableAuditTrail: true };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
+    it('does not log when audit trail is disabled', async () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
-      // Generate more than 500 audit entries
-      for (let i = 0; i < 600; i++) {
-        await result.current.checkPermission('read', `page${i}`);
-      }
+      const { result } = renderHook(() => usePermissionCache({
+        enableAuditTrail: false,
+        enableLogging: false
+      }));
 
-      const auditTrail = result.current.getAuditTrail();
+      await result.current.checkPermission('read', 'users');
+      
+      expect(consoleSpy).not.toHaveBeenCalled();
 
-      expect(auditTrail.length).toBeLessThanOrEqual(500);
+      consoleSpy.mockRestore();
     });
   });
 
-  describe('Cached Permissions', () => {
-    it('returns cached permissions for a page', async () => {
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
+  describe('Performance Optimization', () => {
+    it('batches multiple permission checks efficiently', async () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      // Check multiple permissions for same page
-      await result.current.checkPermission('read', 'dashboard');
-      await result.current.checkPermission('create', 'dashboard');
-      await result.current.checkPermission('update', 'dashboard');
+      const permissions = [
+        ['read', 'users'],
+        ['create', 'users'],
+        ['update', 'users'],
+        ['delete', 'users']
+      ];
 
-      const cachedPermissions = result.current.getCachedPermissions('dashboard');
+      const startTime = Date.now();
+      await result.current.checkMultiplePermissions(permissions);
+      const endTime = Date.now();
 
-      expect(cachedPermissions).toHaveLength(3);
-      expect(cachedPermissions.every(p => p.hasPermission)).toBe(true);
+      // Should complete quickly due to batching
+      expect(endTime - startTime).toBeLessThan(1000);
     });
 
-    it('returns empty array for page with no cached permissions', () => {
-      const { result } = renderHook(() => usePermissionCache());
-
-      const cachedPermissions = result.current.getCachedPermissions('nonexistent');
+    it('uses memoization to prevent unnecessary re-renders', () => {
+      let renderCount = 0;
+      
+      const TestComponent = () => {
+        renderCount++;
+        const cache = usePermissionCache();
+        // Test that the same functions are returned (memoized)
+        expect(cache.checkPermission).toBeInstanceOf(Function);
+        expect(cache.getDebugInfo).toBeInstanceOf(Function);
+        return null;
+      };
 
-      expect(cachedPermissions).toHaveLength(0);
+      const { rerender } = renderHook(() => TestComponent());
+      const initialRenderCount = renderCount;
+      
+      // Re-render with same props
+      rerender();
+      
+      // The hook will re-render, but the functions should be memoized
+      expect(renderCount).toBe(initialRenderCount + 1);
     });
   });
 
   describe('Error Handling', () => {
-    it('handles permission check failures gracefully', async () => {
-      mockRBACContext.hasPermission.mockRejectedValue(new Error('Database error'));
+    it('handles RBAC hook errors gracefully', async () => {
+      mockUseRBAC.mockReturnValue({
+        hasPermission: vi.fn().mockRejectedValue(new Error('RBAC error')),
+        isSuperAdmin: vi.fn().mockResolvedValue(false),
+        isOrgAdmin: vi.fn().mockResolvedValue(false),
+        isEventAdmin: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
 
       const { result } = renderHook(() => usePermissionCache());
 
-      const permission = await result.current.checkPermission('read', 'dashboard');
-
-      expect(permission).toBe(false);
+      const hasPermission = await result.current.checkPermission('read', 'users');
+      expect(hasPermission).toBe(false);
     });
 
-    it('handles multiple permission check failures', async () => {
-      mockRBACContext.hasPermission.mockRejectedValue(new Error('Database error'));
-
+    it('handles invalid permission formats gracefully', async () => {
       const { result } = renderHook(() => usePermissionCache());
 
-      const permissions = [
-        ['read', 'dashboard'],
-        ['create', 'events']
-      ] as Array<[Operation, string]>;
+      const hasPermission = await result.current.checkPermission('', '');
+      expect(hasPermission).toBe(false);
+    });
 
-      const results = await result.current.checkMultiplePermissions(permissions);
+    it('handles null/undefined parameters gracefully', async () => {
+      const { result } = renderHook(() => usePermissionCache());
 
-      expect(results).toHaveLength(2);
-      expect(results.every(r => r.hasPermission === false)).toBe(true);
+      const hasPermission = await result.current.checkPermission(null as any, null as any);
+      expect(hasPermission).toBe(false);
     });
   });
 
-  describe('Configuration', () => {
-    it('uses custom TTL configuration', async () => {
-      const config = { defaultTTL: 2000 };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
-
-      await result.current.checkPermission('read', 'dashboard');
-
-      // Fast-forward time less than custom TTL
-      act(() => {
-        vi.advanceTimersByTime(1000);
-      });
+  describe('Cache Configuration', () => {
+    it('uses custom TTL when provided', async () => {
+      const { result } = renderHook(() => usePermissionCache({
+        defaultTTL: 200
+      }));
 
-      // Should still be cached
-      await result.current.checkPermission('read', 'dashboard');
-
-      expect(mockRBACContext.hasPermission).toHaveBeenCalledTimes(1);
+      await result.current.checkPermission('read', 'users');
+      
+      // Wait for custom TTL to expire
+      await new Promise(resolve => setTimeout(resolve, 250));
+      
+      // Should not use cache
+      await result.current.checkPermission('read', 'users');
+      
+      expect(mockUseRBAC().hasPermission).toHaveBeenCalledTimes(2);
     });
 
-    it('uses custom max cache size', async () => {
-      const config = { maxCacheSize: 1 };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
-
-      await result.current.checkPermission('read', 'page1');
-      await result.current.checkPermission('read', 'page2');
+    it('respects max cache size configuration', async () => {
+      const { result } = renderHook(() => usePermissionCache({
+        maxCacheSize: 1
+      }));
 
+      // Fill cache beyond max size
+      await result.current.checkPermission('read', 'users');
+      await result.current.checkPermission('create', 'users');
+      
       const debugInfo = result.current.getDebugInfo();
       expect(debugInfo.cacheSize).toBeLessThanOrEqual(1);
     });
-
-    it('respects logging configuration', async () => {
-      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-      const config = { enableLogging: true };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
-
-      const { result } = renderHook(() => usePermissionCache(config));
-
-      await result.current.checkPermission('read', 'dashboard');
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringMatching(/\[PermissionCache\].*read:dashboard.*true.*fresh/)
-      );
-
-      consoleSpy.mockRestore();
-    });
   });
 
-  describe('Cleanup', () => {
-    it('cleans up expired entries periodically', async () => {
-      const config = { defaultTTL: 1000 };
-      mockRBACContext.hasPermission.mockResolvedValue(true);
+  describe('Integration with RBAC', () => {
+    it('integrates with useRBAC hook correctly', () => {
+      renderHook(() => usePermissionCache());
+      expect(mockUseRBAC).toHaveBeenCalled();
+    });
 
-      const { result } = renderHook(() => usePermissionCache(config));
+    it('passes correct parameters to RBAC hook', async () => {
+      const { result } = renderHook(() => usePermissionCache());
 
-      await result.current.checkPermission('read', 'dashboard');
+      await result.current.checkPermission('read', 'users');
+      
+      expect(mockUseRBAC().hasPermission).toHaveBeenCalledWith('read', 'users');
+    });
 
-      // Fast-forward time past TTL
-      act(() => {
-        vi.advanceTimersByTime(1001);
-      });
+    it('handles RBAC hook state changes', async () => {
+      const mockHasPermission = vi.fn().mockResolvedValue(true);
+      mockUseRBAC.mockReturnValue({
+        hasPermission: mockHasPermission,
+        isSuperAdmin: vi.fn().mockResolvedValue(false),
+        isOrgAdmin: vi.fn().mockResolvedValue(false),
+        isEventAdmin: vi.fn().mockResolvedValue(false),
+        // Add other required properties
+      } as any);
 
-      // Trigger cleanup by advancing time further to trigger the interval
-      act(() => {
-        vi.advanceTimersByTime(2000);
-      });
+      const { result } = renderHook(() => usePermissionCache());
 
-      // The cleanup might not happen immediately due to interval timing
-      // Just verify the cache has some entries and the cleanup mechanism works
-      const debugInfo = result.current.getDebugInfo();
-      expect(debugInfo.cacheSize).toBeGreaterThanOrEqual(0);
+      await result.current.checkPermission('read', 'users');
+      expect(mockHasPermission).toHaveBeenCalledWith('read', 'users');
     });
   });
-});
+});