@jmruthers/pace-core 0.5.76 → 0.5.78

package/src/__tests__/hooks/usePermissions.test.ts

@@ -1,261 +0,0 @@
-/**
- * @file usePermissions Hook Tests
- * @package @jmruthers/pace-core
- * @module RBAC/Hooks/usePermissions
- * @since 1.0.0
- *
- * Tests for usePermissions hook to ensure:
- * - Hook returns stable references when data hasn't changed
- * - No infinite re-renders occur
- * - Proper memoization is working
- */
-
-import { renderHook, act } from '@testing-library/react';
-import { vi } from 'vitest';
-import { usePermissions, useCan } from '../../rbac/hooks/usePermissions';
-
-// Mock the API functions
-vi.mock('../../rbac/api', () => ({
-  getPermissionMap: vi.fn(),
-  isPermitted: vi.fn(),
-  isPermittedCached: vi.fn(),
-}));
-
-import { getPermissionMap, isPermitted, isPermittedCached } from '../../rbac/api';
-
-const mockGetPermissionMap = vi.mocked(getPermissionMap);
-const mockIsPermitted = vi.mocked(isPermitted);
-const mockIsPermittedCached = vi.mocked(isPermittedCached);
-
-describe('usePermissions Hook Stability', () => {
-  const mockUserId = 'user-123';
-  const mockScope = {
-    organisationId: 'org-123',
-    eventId: 'event-123',
-    appId: 'app-123'
-  };
-
-    describe('usePermissions', () => {
-    it('should return stable references when data hasn\'t changed', async () => {
-      const mockPermissions = {
-        'read:users': true,
-        'create:users': false
-      };
-
-      mockGetPermissionMap.mockResolvedValue(mockPermissions);
-
-      const { result, rerender } = renderHook(() => 
-        usePermissions(mockUserId, mockScope)
-      );
-
-      // Wait for initial load
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      const firstResult = result.current;
-
-      // Re-render with same props
-      rerender();
-
-      const secondResult = result.current;
-
-      // References should be stable
-      expect(firstResult.permissions).toBe(secondResult.permissions);
-      expect(firstResult.isLoading).toBe(secondResult.isLoading);
-      expect(firstResult.error).toBe(secondResult.error);
-      expect(firstResult.hasPermission).toBe(secondResult.hasPermission);
-      expect(firstResult.hasAnyPermission).toBe(secondResult.hasAnyPermission);
-      expect(firstResult.hasAllPermissions).toBe(secondResult.hasAllPermissions);
-      expect(firstResult.refetch).toBe(secondResult.refetch);
-    });
-
-    it('should update references when data changes', async () => {
-      const initialPermissions = {
-        'read:users': true,
-        'create:users': false
-      };
-
-      const updatedPermissions = {
-        'read:users': true,
-        'create:users': true
-      };
-
-      mockGetPermissionMap
-        .mockResolvedValueOnce(initialPermissions)
-        .mockResolvedValueOnce(updatedPermissions);
-
-      const { result, rerender } = renderHook(() => 
-        usePermissions(mockUserId, mockScope)
-      );
-
-      // Wait for initial load
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      const firstResult = result.current;
-
-      // Trigger refetch
-      await act(async () => {
-        await firstResult.refetch();
-      });
-
-      const secondResult = result.current;
-
-      // References should be different due to data change
-      expect(firstResult.permissions).not.toBe(secondResult.permissions);
-      expect(firstResult.permissions).toEqual(initialPermissions);
-      expect(secondResult.permissions).toEqual(updatedPermissions);
-    });
-
-    it('should not cause infinite re-renders', async () => {
-      let renderCount = 0;
-      
-      mockGetPermissionMap.mockResolvedValue({
-        'read:users': true
-      });
-
-      const { result } = renderHook(() => {
-        renderCount++;
-        return usePermissions(mockUserId, mockScope);
-      });
-
-      // Wait for initial load
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      // Should not have excessive re-renders
-      expect(renderCount).toBeLessThan(5);
-    });
-  });
-
-  describe('useCan', () => {
-    it('should return stable references when data hasn\'t changed', async () => {
-      mockIsPermittedCached.mockResolvedValue(true);
-
-      const { result, rerender } = renderHook(() => 
-        useCan(mockUserId, mockScope, 'read:users', 'page-123', true)
-      );
-
-      // Wait for initial load
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      const firstResult = result.current;
-
-      // Re-render with same props
-      rerender();
-
-      const secondResult = result.current;
-
-      // References should be stable
-      expect(firstResult.can).toBe(secondResult.can);
-      expect(firstResult.isLoading).toBe(secondResult.isLoading);
-      expect(firstResult.error).toBe(secondResult.error);
-      expect(firstResult.refetch).toBe(secondResult.refetch);
-    });
-
-    it('should update references when permission result changes', async () => {
-      mockIsPermittedCached
-        .mockResolvedValueOnce(false)
-        .mockResolvedValueOnce(true);
-
-      const { result, rerender } = renderHook(() => 
-        useCan(mockUserId, mockScope, 'read:users', 'page-123', true)
-      );
-
-      // Wait for initial load
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      const firstResult = result.current;
-
-      // Trigger refetch
-      await act(async () => {
-        await firstResult.refetch();
-      });
-
-      const secondResult = result.current;
-
-      // References should be different due to permission change
-      expect(firstResult.can).toBe(false);
-      expect(secondResult.can).toBe(true);
-    });
-
-    it('should not cause infinite re-renders', async () => {
-      let renderCount = 0;
-      
-      mockIsPermittedCached.mockResolvedValue(true);
-
-      const { result } = renderHook(() => {
-        renderCount++;
-        return useCan(mockUserId, mockScope, 'read:users', 'page-123', true);
-      });
-
-      // Wait for initial load
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      // Should not have excessive re-renders
-      expect(renderCount).toBeLessThan(5);
-    });
-  });
-
-  describe('Hook Dependencies', () => {
-    it('should re-run when userId changes', async () => {
-      mockGetPermissionMap.mockResolvedValue({ 'read:users': true });
-
-      const { result, rerender } = renderHook(
-        ({ userId }) => usePermissions(userId, mockScope),
-        { initialProps: { userId: 'user-1' } }
-      );
-
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      const firstResult = result.current;
-
-      // Change userId
-      rerender({ userId: 'user-2' });
-
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      const secondResult = result.current;
-
-      // Should have re-fetched due to userId change
-      expect(mockGetPermissionMap).toHaveBeenCalledTimes(2);
-      expect(firstResult).not.toBe(secondResult);
-    });
-
-    it('should re-run when scope changes', async () => {
-      mockGetPermissionMap.mockResolvedValue({ 'read:users': true });
-
-      const { result, rerender } = renderHook(
-        ({ scope }) => usePermissions(mockUserId, scope),
-        { initialProps: { scope: { ...mockScope, organisationId: 'org-1' } } }
-      );
-
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      // Change scope
-      rerender({ scope: { ...mockScope, organisationId: 'org-2' } });
-
-      await act(async () => {
-        await new Promise(resolve => setTimeout(resolve, 0));
-      });
-
-      // Should have re-fetched due to scope change
-      expect(mockGetPermissionMap).toHaveBeenCalledTimes(2);
-    });
-  });
-});