@jmruthers/pace-core 0.5.53 → 0.5.55

package/src/utils/permissionUtils.test.ts

@@ -0,0 +1,393 @@
+/**
+ * @file Permission Utils Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/PermissionUtils
+ * @since 1.0.0
+ * 
+ * Comprehensive tests for permission utility functions covering all critical functionality.
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  transformPermissionMapToBoolean,
+  hasPermission,
+  hasAnyPermission,
+  hasAllPermissions
+} from './permissionUtils';
+
+describe('Permission Utils', () => {
+  describe('transformPermissionMapToBoolean', () => {
+    it('transforms string values correctly', () => {
+      const permissions = {
+        'read:users': 'true',
+        'write:users': 'false',
+        'delete:users': '',
+        'manage:users': 'yes',
+        'view:users': 'no'
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': false,
+        'manage:users': true,
+        'view:users': true
+      });
+    });
+
+    it('transforms boolean values correctly', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      });
+    });
+
+    it('transforms mixed types correctly', () => {
+      const permissions = {
+        'read:users': 'true',
+        'write:users': false,
+        'delete:users': 1,
+        'manage:users': 0,
+        'view:users': null,
+        'edit:users': undefined
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false,
+        'view:users': false,
+        'edit:users': false
+      });
+    });
+
+    it('handles empty object', () => {
+      const permissions = {};
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({});
+    });
+
+    it('handles null and undefined values', () => {
+      const permissions = {
+        'read:users': null,
+        'write:users': undefined,
+        'delete:users': false,
+        'manage:users': true
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': false,
+        'write:users': false,
+        'delete:users': false,
+        'manage:users': true
+      });
+    });
+
+    it('handles numeric values', () => {
+      const permissions = {
+        'read:users': 1,
+        'write:users': 0,
+        'delete:users': -1,
+        'manage:users': 42
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': true
+      });
+    });
+
+    it('handles case-insensitive string values', () => {
+      const permissions = {
+        'read:users': 'TRUE',
+        'write:users': 'FALSE',
+        'delete:users': 'True',
+        'manage:users': 'False'
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      });
+    });
+  });
+
+  describe('hasPermission', () => {
+    it('returns true for granted permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasPermission(permissions, 'read:users')).toBe(true);
+      expect(hasPermission(permissions, 'delete:users')).toBe(true);
+    });
+
+    it('returns false for denied permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasPermission(permissions, 'write:users')).toBe(false);
+    });
+
+    it('returns false for non-existent permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasPermission(permissions, 'manage:users')).toBe(false);
+    });
+
+    it('handles empty permissions object', () => {
+      const permissions = {};
+
+      expect(hasPermission(permissions, 'read:users')).toBe(false);
+    });
+
+    it('handles null/undefined permission', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasPermission(permissions, null as any)).toBe(false);
+      expect(hasPermission(permissions, undefined as any)).toBe(false);
+    });
+  });
+
+  describe('hasAnyPermission', () => {
+    it('returns true when at least one permission is granted', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAnyPermission(permissions, ['write:users', 'delete:users', 'read:users'])).toBe(true);
+    });
+
+    it('returns false when no permissions are granted', () => {
+      const permissions = {
+        'read:users': false,
+        'write:users': false,
+        'delete:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(false);
+    });
+
+    it('returns false for empty permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, [])).toBe(false);
+    });
+
+    it('returns false when permission list contains non-existent permissions', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['manage:users', 'admin:users'])).toBe(false);
+    });
+
+    it('handles mixed permission states', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'manage:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAnyPermission(permissions, ['write:users', 'manage:users'])).toBe(false);
+      expect(hasAnyPermission(permissions, ['delete:users', 'manage:users'])).toBe(true);
+    });
+
+    it('handles null/undefined permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, null as any)).toBe(false);
+      expect(hasAnyPermission(permissions, undefined as any)).toBe(false);
+    });
+  });
+
+  describe('hasAllPermissions', () => {
+    it('returns true when all permissions are granted', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true,
+        'delete:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(true);
+    });
+
+    it('returns false when at least one permission is denied', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users'])).toBe(false);
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+    });
+
+    it('returns true for empty permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAllPermissions(permissions, [])).toBe(true);
+    });
+
+    it('returns false when permission list contains non-existent permissions', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'manage:users'])).toBe(false);
+    });
+
+    it('handles mixed permission states', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true,
+        'delete:users': false,
+        'manage:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+      expect(hasAllPermissions(permissions, ['read:users', 'manage:users'])).toBe(true);
+    });
+
+    it('handles null/undefined permission list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAllPermissions(permissions, null as any)).toBe(false);
+      expect(hasAllPermissions(permissions, undefined as any)).toBe(false);
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('handles very large permission objects', () => {
+      const permissions: Record<string, boolean> = {};
+      for (let i = 0; i < 1000; i++) {
+        permissions[`permission:${i}`] = i % 2 === 0;
+      }
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(Object.keys(result)).toHaveLength(1000);
+      expect(result['permission:0']).toBe(true);
+      expect(result['permission:1']).toBe(false);
+    });
+
+    it('handles special characters in permission names', () => {
+      const permissions = {
+        'read:users@domain.com': true,
+        'write:users#special': false,
+        'delete:users$with$symbols': true,
+        'manage:users.with.dots': false
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(result['read:users@domain.com']).toBe(true);
+      expect(result['write:users#special']).toBe(false);
+      expect(result['delete:users$with$symbols']).toBe(true);
+      expect(result['manage:users.with.dots']).toBe(false);
+    });
+
+    it('handles unicode characters in permission names', () => {
+      const permissions = {
+        'read:用户': true,
+        'write:ユーザー': false,
+        'delete:مستخدم': true
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(result['read:用户']).toBe(true);
+      expect(result['write:ユーザー']).toBe(false);
+      expect(result['delete:مستخدم']).toBe(true);
+    });
+  });
+
+  describe('Type Safety', () => {
+    it('maintains type safety with TypeScript', () => {
+      const permissions: Record<string, boolean> = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      // These should compile without errors
+      const hasRead = hasPermission(permissions, 'read:users');
+      const hasAny = hasAnyPermission(permissions, ['read:users', 'write:users']);
+      const hasAll = hasAllPermissions(permissions, ['read:users']);
+
+      expect(typeof hasRead).toBe('boolean');
+      expect(typeof hasAny).toBe('boolean');
+      expect(typeof hasAll).toBe('boolean');
+    });
+
+    it('handles mixed input types gracefully', () => {
+      const permissions = {
+        'read:users': 'true',
+        'write:users': 1,
+        'delete:users': false,
+        'manage:users': null
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+      expect(typeof result['read:users']).toBe('boolean');
+      expect(typeof result['write:users']).toBe('boolean');
+      expect(typeof result['delete:users']).toBe('boolean');
+      expect(typeof result['manage:users']).toBe('boolean');
+    });
+  });
+});

package/src/utils/permissionUtils.ts

@@ -22,10 +22,13 @@ export function hasPermission(permissions: Record<string, boolean>, permission:
   return Boolean(permissions[permission]);
 }
 
-export function hasAnyPermission(permissions: Record<string, boolean>, permissionList: string[]): boolean {
+export function hasAnyPermission(permissions: Record<string, boolean>, permissionList: string[] | null | undefined): boolean {
+  if (!permissionList || permissionList.length === 0) return false;
   return permissionList.some(permission => hasPermission(permissions, permission));
 }
 
-export function hasAllPermissions(permissions: Record<string, boolean>, permissionList: string[]): boolean {
+export function hasAllPermissions(permissions: Record<string, boolean>, permissionList: string[] | null | undefined): boolean {
+  if (!permissionList) return false;
+  if (permissionList.length === 0) return true;
   return permissionList.every(permission => hasPermission(permissions, permission));
 }