@jmruthers/pace-core 0.5.4 → 0.5.5

package/src/utils/__tests__/permissionUtils.unit.test.ts

@@ -0,0 +1,362 @@
+import { describe, it, expect } from 'vitest';
+import {
+  transformPermissionMapToBoolean,
+  hasPermission,
+  hasAnyPermission,
+  hasAllPermissions
+} from '../permissionUtils';
+
+describe('permissionUtils', () => {
+  describe('transformPermissionMapToBoolean', () => {
+    it('should transform permission map to boolean values', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': 1,
+        'admin:users': 0,
+        'view:reports': 'true',
+        'edit:reports': false
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true,
+        'admin:users': false,
+        'view:reports': true,
+        'edit:reports': false
+      });
+    });
+
+    it('should handle empty permission map', () => {
+      const permissions = {};
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({});
+    });
+
+    it('should handle various truthy and falsy values', () => {
+      const permissions = {
+        'permission1': true,
+        'permission2': false,
+        'permission3': 1,
+        'permission4': 0,
+        'permission5': 'true',
+        'permission6': 'false',
+        'permission7': '',
+        'permission8': null,
+        'permission9': undefined
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'permission1': true,
+        'permission2': false,
+        'permission3': true,
+        'permission4': false,
+        'permission5': true,
+        'permission6': false,
+        'permission7': false,
+        'permission8': false,
+        'permission9': false
+      });
+    });
+
+    it('should handle mixed data types', () => {
+      const permissions = {
+        'read': true,
+        'write': 'yes',
+        'delete': 1,
+        'admin': 'no',
+        'view': 0,
+        'edit': false
+      };
+
+      const result = transformPermissionMapToBoolean(permissions);
+
+      expect(result).toEqual({
+        'read': true,
+        'write': true,
+        'delete': true,
+        'admin': true,
+        'view': false,
+        'edit': false
+      });
+    });
+  });
+
+  describe('hasPermission', () => {
+    it('should return true when permission exists and is true', () => {
+      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('should return false when permission exists but is false', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasPermission(permissions, 'write:users')).toBe(false);
+    });
+
+    it('should return false when permission does not exist', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasPermission(permissions, 'admin:users')).toBe(false);
+    });
+
+    it('should handle empty permissions object', () => {
+      const permissions = {};
+
+      expect(hasPermission(permissions, 'any:permission')).toBe(false);
+    });
+
+    it('should handle various truthy and falsy values', () => {
+      const permissions = {
+        'truthy1': true,
+        'truthy2': 1,
+        'truthy3': 'true',
+        'falsy1': false,
+        'falsy2': 0,
+        'falsy3': 'false',
+        'falsy4': '',
+        'falsy5': null,
+        'falsy6': undefined
+      };
+
+      expect(hasPermission(permissions, 'truthy1')).toBe(true);
+      expect(hasPermission(permissions, 'truthy2')).toBe(true);
+      expect(hasPermission(permissions, 'truthy3')).toBe(true);
+      expect(hasPermission(permissions, 'falsy1')).toBe(false);
+      expect(hasPermission(permissions, 'falsy2')).toBe(false);
+      expect(hasPermission(permissions, 'falsy3')).toBe(true);
+      expect(hasPermission(permissions, 'falsy4')).toBe(false);
+      expect(hasPermission(permissions, 'falsy5')).toBe(false);
+      expect(hasPermission(permissions, 'falsy6')).toBe(false);
+    });
+  });
+
+  describe('hasAnyPermission', () => {
+    it('should return true when any permission in list is granted', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': false,
+        'admin:users': true
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAnyPermission(permissions, ['write:users', 'delete:users', 'admin:users'])).toBe(true);
+    });
+
+    it('should return false when no permissions in list are granted', () => {
+      const permissions = {
+        'read:users': false,
+        'write:users': false,
+        'delete:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+    });
+
+    it('should return false when permission list is empty', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true
+      };
+
+      expect(hasAnyPermission(permissions, [])).toBe(false);
+    });
+
+    it('should return false when permissions object is empty', () => {
+      const permissions = {};
+
+      expect(hasAnyPermission(permissions, ['read:users', 'write:users'])).toBe(false);
+    });
+
+    it('should handle permissions that do not exist', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users', 'nonexistent:permission'])).toBe(true);
+      expect(hasAnyPermission(permissions, ['nonexistent1:permission', 'nonexistent2:permission'])).toBe(false);
+    });
+
+    it('should handle single permission in list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAnyPermission(permissions, ['read:users'])).toBe(true);
+      expect(hasAnyPermission(permissions, ['write:users'])).toBe(false);
+    });
+  });
+
+  describe('hasAllPermissions', () => {
+    it('should return true when all permissions in list 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('should return false when any permission in list is not granted', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+    });
+
+    it('should return true when permission list is empty', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true
+      };
+
+      expect(hasAllPermissions(permissions, [])).toBe(true);
+    });
+
+    it('should return false when permissions object is empty but list is not', () => {
+      const permissions = {};
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users'])).toBe(false);
+    });
+
+    it('should handle permissions that do not exist', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'nonexistent:permission'])).toBe(false);
+      expect(hasAllPermissions(permissions, ['nonexistent1:permission', 'nonexistent2:permission'])).toBe(false);
+    });
+
+    it('should handle single permission in list', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': false
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users'])).toBe(true);
+      expect(hasAllPermissions(permissions, ['write:users'])).toBe(false);
+    });
+
+    it('should handle mixed existing and non-existing permissions', () => {
+      const permissions = {
+        'read:users': true,
+        'write:users': true
+      };
+
+      expect(hasAllPermissions(permissions, ['read:users', 'write:users', 'nonexistent:permission'])).toBe(false);
+    });
+  });
+
+  describe('Integration tests', () => {
+    it('should work together in a realistic permission scenario', () => {
+      const userPermissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': false,
+        'read:reports': true,
+        'write:reports': true,
+        'admin:system': false
+      };
+
+      // Transform permissions to ensure boolean values
+      const booleanPermissions = transformPermissionMapToBoolean(userPermissions);
+
+      // Check individual permissions
+      expect(hasPermission(booleanPermissions, 'read:users')).toBe(true);
+      expect(hasPermission(booleanPermissions, 'write:users')).toBe(false);
+      expect(hasPermission(booleanPermissions, 'admin:system')).toBe(false);
+
+      // Check if user has any user management permissions
+      expect(hasAnyPermission(booleanPermissions, ['read:users', 'write:users', 'delete:users'])).toBe(true);
+
+      // Check if user has all user management permissions
+      expect(hasAllPermissions(booleanPermissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+
+      // Check if user has all report permissions
+      expect(hasAllPermissions(booleanPermissions, ['read:reports', 'write:reports'])).toBe(true);
+
+      // Check if user has any admin permissions
+      expect(hasAnyPermission(booleanPermissions, ['admin:system', 'admin:users'])).toBe(false);
+    });
+
+    it('should handle complex permission hierarchies', () => {
+      const adminPermissions = {
+        'read:users': true,
+        'write:users': true,
+        'delete:users': true,
+        'read:reports': true,
+        'write:reports': true,
+        'delete:reports': true,
+        'admin:system': true
+      };
+
+      const managerPermissions = {
+        'read:users': true,
+        'write:users': true,
+        'delete:users': false,
+        'read:reports': true,
+        'write:reports': true,
+        'delete:reports': false,
+        'admin:system': false
+      };
+
+      const userPermissions = {
+        'read:users': true,
+        'write:users': false,
+        'delete:users': false,
+        'read:reports': true,
+        'write:reports': false,
+        'delete:reports': false,
+        'admin:system': false
+      };
+
+      const booleanAdminPermissions = transformPermissionMapToBoolean(adminPermissions);
+      const booleanManagerPermissions = transformPermissionMapToBoolean(managerPermissions);
+      const booleanUserPermissions = transformPermissionMapToBoolean(userPermissions);
+
+      // Admin should have all permissions
+      expect(hasAllPermissions(booleanAdminPermissions, ['read:users', 'write:users', 'delete:users'])).toBe(true);
+      expect(hasAllPermissions(booleanAdminPermissions, ['read:reports', 'write:reports', 'delete:reports'])).toBe(true);
+      expect(hasPermission(booleanAdminPermissions, 'admin:system')).toBe(true);
+
+      // Manager should have some but not all permissions
+      expect(hasAllPermissions(booleanManagerPermissions, ['read:users', 'write:users'])).toBe(true);
+      expect(hasAllPermissions(booleanManagerPermissions, ['read:users', 'write:users', 'delete:users'])).toBe(false);
+      expect(hasAnyPermission(booleanManagerPermissions, ['delete:users', 'delete:reports'])).toBe(false);
+
+      // User should have limited permissions
+      expect(hasAllPermissions(booleanUserPermissions, ['read:users', 'read:reports'])).toBe(true);
+      expect(hasAnyPermission(booleanUserPermissions, ['write:users', 'write:reports'])).toBe(false);
+      expect(hasPermission(booleanUserPermissions, 'admin:system')).toBe(false);
+    });
+  });
+});