@jmruthers/pace-core 0.5.4 → 0.5.6

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

@@ -0,0 +1,192 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type { SupabaseClient } from '@supabase/supabase-js';
+import {
+  setOrganisationContext,
+  clearOrganisationContext,
+  getOrganisationContext,
+  isOrganisationContextAvailable
+} from '../organisationContext';
+
+describe('organisationContext', () => {
+  let mockSupabase: SupabaseClient;
+
+  beforeEach(() => {
+    // Reset all mocks
+    vi.clearAllMocks();
+    
+    // Create a mock Supabase client
+    mockSupabase = {
+      rpc: vi.fn(),
+      auth: {
+        getUser: vi.fn()
+      }
+    } as unknown as SupabaseClient;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('setOrganisationContext', () => {
+    it('should set organisation context successfully', async () => {
+      const organisationId = 'org-123';
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      mockSupabase.rpc = mockRpc;
+
+      await setOrganisationContext(mockSupabase, organisationId);
+
+      expect(mockRpc).toHaveBeenCalledWith('set_organisation_context', {
+        org_id: organisationId
+      });
+    });
+
+    it('should handle missing supabase client gracefully', async () => {
+      await setOrganisationContext(null as any, 'org-123');
+      // Function should complete without throwing
+      expect(true).toBe(true);
+    });
+
+    it('should handle missing organisation ID gracefully', async () => {
+      await setOrganisationContext(mockSupabase, '');
+      // Function should complete without throwing
+      expect(true).toBe(true);
+    });
+
+    it('should handle database function not available', async () => {
+      const mockRpc = vi.fn().mockResolvedValue({ 
+        error: { message: 'Function not found' } 
+      });
+      mockSupabase.rpc = mockRpc;
+
+      await setOrganisationContext(mockSupabase, 'org-123');
+      // Function should complete without throwing
+      expect(true).toBe(true);
+    });
+
+    it('should handle unexpected errors gracefully', async () => {
+      const mockRpc = vi.fn().mockRejectedValue(new Error('Network error'));
+      mockSupabase.rpc = mockRpc;
+
+      await setOrganisationContext(mockSupabase, 'org-123');
+      // Function should complete without throwing
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('clearOrganisationContext', () => {
+    it('should clear organisation context successfully', async () => {
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      mockSupabase.rpc = mockRpc;
+
+      await clearOrganisationContext(mockSupabase);
+
+      expect(mockRpc).toHaveBeenCalledWith('clear_organisation_context');
+    });
+
+    it('should handle missing supabase client gracefully', async () => {
+      await clearOrganisationContext(null as any);
+      // Function should complete without throwing
+      expect(true).toBe(true);
+    });
+
+    it('should handle database function not available', async () => {
+      const mockRpc = vi.fn().mockResolvedValue({ 
+        error: { message: 'Function not found' } 
+      });
+      mockSupabase.rpc = mockRpc;
+
+      await clearOrganisationContext(mockSupabase);
+      // Function should complete without throwing
+      expect(true).toBe(true);
+    });
+
+    it('should handle unexpected errors gracefully', async () => {
+      const mockRpc = vi.fn().mockRejectedValue(new Error('Network error'));
+      mockSupabase.rpc = mockRpc;
+
+      await clearOrganisationContext(mockSupabase);
+      // Function should complete without throwing
+      expect(true).toBe(true);
+    });
+  });
+
+  describe('getOrganisationContext', () => {
+    it('should get organisation context successfully', async () => {
+      const mockRpc = vi.fn().mockResolvedValue({ 
+        data: 'org-123',
+        error: null 
+      });
+      mockSupabase.rpc = mockRpc;
+
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(mockRpc).toHaveBeenCalledWith('get_organisation_context');
+      expect(result).toBe('org-123');
+    });
+
+    it('should handle missing supabase client gracefully', async () => {
+      const result = await getOrganisationContext(null as any);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle database function not available', async () => {
+      const mockRpc = vi.fn().mockResolvedValue({ 
+        data: null,
+        error: { message: 'Function not found' } 
+      });
+      mockSupabase.rpc = mockRpc;
+
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle unexpected errors gracefully', async () => {
+      const mockRpc = vi.fn().mockRejectedValue(new Error('Network error'));
+      mockSupabase.rpc = mockRpc;
+
+      const result = await getOrganisationContext(mockSupabase);
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('isOrganisationContextAvailable', () => {
+    it('should return true when functions are available', async () => {
+      const mockRpc = vi.fn().mockResolvedValue({ error: null });
+      mockSupabase.rpc = mockRpc;
+
+      const result = await isOrganisationContextAvailable(mockSupabase);
+
+      expect(mockRpc).toHaveBeenCalledWith('get_organisation_context');
+      expect(result).toBe(true);
+    });
+
+    it('should return false when supabase client is missing', async () => {
+      const result = await isOrganisationContextAvailable(null as any);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when database function has error', async () => {
+      const mockRpc = vi.fn().mockResolvedValue({ 
+        error: { message: 'Function not found' } 
+      });
+      mockSupabase.rpc = mockRpc;
+
+      const result = await isOrganisationContextAvailable(mockSupabase);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false when unexpected error occurs', async () => {
+      const mockRpc = vi.fn().mockRejectedValue(new Error('Network error'));
+      mockSupabase.rpc = mockRpc;
+
+      const result = await isOrganisationContextAvailable(mockSupabase);
+
+      expect(result).toBe(false);
+    });
+  });
+}); 

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

@@ -0,0 +1,259 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { performanceBudgetMonitor, PERFORMANCE_BUDGETS } from '../performanceBudgets';
+
+describe('performanceBudgets', () => {
+  let consoleSpy: {
+    log: ReturnType<typeof vi.spyOn>;
+    warn: ReturnType<typeof vi.spyOn>;
+    error: ReturnType<typeof vi.spyOn>;
+    info: ReturnType<typeof vi.spyOn>;
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    // Create console spies
+    consoleSpy = {
+      log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+      warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+      error: vi.spyOn(console, 'error').mockImplementation(() => {}),
+      info: vi.spyOn(console, 'info').mockImplementation(() => {})
+    };
+    
+    // Reset the monitor before each test
+    performanceBudgetMonitor.reset();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('PERFORMANCE_BUDGETS', () => {
+    it('should have all required performance budget thresholds', () => {
+      expect(PERFORMANCE_BUDGETS).toHaveProperty('COMPONENT_RENDER');
+      expect(PERFORMANCE_BUDGETS).toHaveProperty('BUNDLE_SIZE');
+      expect(PERFORMANCE_BUDGETS).toHaveProperty('CHUNK_COUNT');
+      expect(PERFORMANCE_BUDGETS).toHaveProperty('TREESHAKING_SCORE');
+      expect(PERFORMANCE_BUDGETS).toHaveProperty('ERROR_BOUNDARY_TRIGGER');
+      expect(PERFORMANCE_BUDGETS).toHaveProperty('MEMORY_INCREASE');
+      expect(PERFORMANCE_BUDGETS).toHaveProperty('LARGE_LIST_RENDER');
+    });
+
+    it('should have appropriate threshold values', () => {
+      expect(PERFORMANCE_BUDGETS.COMPONENT_RENDER.threshold).toBe(50);
+      expect(PERFORMANCE_BUDGETS.BUNDLE_SIZE.threshold).toBe(150000);
+      expect(PERFORMANCE_BUDGETS.CHUNK_COUNT.threshold).toBe(10);
+      expect(PERFORMANCE_BUDGETS.TREESHAKING_SCORE.threshold).toBe(70);
+      expect(PERFORMANCE_BUDGETS.ERROR_BOUNDARY_TRIGGER.threshold).toBe(5);
+      expect(PERFORMANCE_BUDGETS.MEMORY_INCREASE.threshold).toBe(1000);
+      expect(PERFORMANCE_BUDGETS.LARGE_LIST_RENDER.threshold).toBe(500);
+    });
+  });
+
+  describe('performanceBudgetMonitor.measure', () => {
+    it('should measure performance metrics correctly', () => {
+      const result = performanceBudgetMonitor.measure('COMPONENT_RENDER', 30);
+
+      expect(result.passed).toBe(true);
+      expect(result.value).toBe(30);
+      expect(result.threshold).toBe(50);
+    });
+
+    it('should fail when metric exceeds threshold', () => {
+      const result = performanceBudgetMonitor.measure('COMPONENT_RENDER', 60);
+
+      expect(result.passed).toBe(false);
+      expect(result.value).toBe(60);
+      expect(result.threshold).toBe(50);
+    });
+
+    it('should handle unknown metrics with default threshold', () => {
+      const result = performanceBudgetMonitor.measure('UNKNOWN_METRIC', 80);
+
+      expect(result.passed).toBe(true);
+      expect(result.value).toBe(80);
+      expect(result.threshold).toBe(100); // Default threshold
+    });
+
+    it('should log metrics in development mode', () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'development';
+
+      performanceBudgetMonitor.measure('TEST_METRIC', 25, { component: 'Button' });
+
+      expect(consoleSpy.log).toHaveBeenCalledWith(
+        '📊 Performance Metric: TEST_METRIC = 25',
+        { component: 'Button' }
+      );
+
+      process.env.NODE_ENV = originalEnv;
+    });
+
+    it('should not log metrics in production mode', () => {
+      const originalEnv = process.env.NODE_ENV;
+      process.env.NODE_ENV = 'production';
+
+      performanceBudgetMonitor.measure('TEST_METRIC', 25);
+
+      expect(consoleSpy.log).not.toHaveBeenCalled();
+
+      process.env.NODE_ENV = originalEnv;
+    });
+  });
+
+  describe('performanceBudgetMonitor.setBudget', () => {
+    it('should set budget with default threshold', () => {
+      performanceBudgetMonitor.setBudget('CUSTOM_METRIC', 100);
+      performanceBudgetMonitor.measure('CUSTOM_METRIC', 150); // Exceed the budget
+
+      const violations = performanceBudgetMonitor.checkBudgets();
+      expect(violations).toHaveLength(1);
+      expect(violations[0].metric).toBe('CUSTOM_METRIC');
+      expect(violations[0].budget).toBe(100);
+      expect(violations[0].threshold).toBe('warning');
+    });
+
+    it('should set budget with custom threshold', () => {
+      performanceBudgetMonitor.setBudget('CRITICAL_METRIC', 50, 'error');
+      performanceBudgetMonitor.measure('CRITICAL_METRIC', 75); // Exceed the budget
+
+      const violations = performanceBudgetMonitor.checkBudgets();
+      expect(violations).toHaveLength(1);
+      expect(violations[0].threshold).toBe('error');
+    });
+
+    it('should handle multiple budgets', () => {
+      performanceBudgetMonitor.setBudget('METRIC_1', 100);
+      performanceBudgetMonitor.setBudget('METRIC_2', 200, 'info');
+      performanceBudgetMonitor.measure('METRIC_1', 150); // Exceed budget
+      performanceBudgetMonitor.measure('METRIC_2', 250); // Exceed budget
+
+      const violations = performanceBudgetMonitor.checkBudgets();
+      expect(violations).toHaveLength(2);
+    });
+  });
+
+  describe('performanceBudgetMonitor.checkBudgets', () => {
+    it('should return empty array when no violations', () => {
+      performanceBudgetMonitor.setBudget('TEST_METRIC', 100);
+      performanceBudgetMonitor.measure('TEST_METRIC', 50);
+
+      const violations = performanceBudgetMonitor.checkBudgets();
+
+      expect(violations).toHaveLength(0);
+    });
+
+    it('should detect budget violations', () => {
+      performanceBudgetMonitor.setBudget('TEST_METRIC', 100);
+      performanceBudgetMonitor.measure('TEST_METRIC', 150);
+
+      const violations = performanceBudgetMonitor.checkBudgets();
+
+      expect(violations).toHaveLength(1);
+      expect(violations[0].metric).toBe('TEST_METRIC');
+      expect(violations[0].actual).toBe(150);
+      expect(violations[0].budget).toBe(100);
+    });
+
+    it('should log error for error threshold violations', () => {
+      performanceBudgetMonitor.setBudget('CRITICAL_METRIC', 100, 'error');
+      performanceBudgetMonitor.measure('CRITICAL_METRIC', 150);
+
+      performanceBudgetMonitor.checkBudgets();
+
+      expect(consoleSpy.error).toHaveBeenCalledWith(
+        '❌ Performance budget exceeded: CRITICAL_METRIC (150 > 100)'
+      );
+    });
+
+    it('should log warning for warning threshold violations', () => {
+      performanceBudgetMonitor.setBudget('WARNING_METRIC', 100, 'warning');
+      performanceBudgetMonitor.measure('WARNING_METRIC', 150);
+
+      performanceBudgetMonitor.checkBudgets();
+
+      expect(consoleSpy.warn).toHaveBeenCalledWith(
+        '⚠️ Performance budget exceeded: WARNING_METRIC (150 > 100)'
+      );
+    });
+
+    it('should log info for info threshold violations', () => {
+      performanceBudgetMonitor.setBudget('INFO_METRIC', 100, 'info');
+      performanceBudgetMonitor.measure('INFO_METRIC', 150);
+
+      performanceBudgetMonitor.checkBudgets();
+
+      expect(consoleSpy.info).toHaveBeenCalledWith(
+        'ℹ️ Performance budget exceeded: INFO_METRIC (150 > 100)'
+      );
+    });
+
+    it('should handle multiple violations', () => {
+      performanceBudgetMonitor.setBudget('METRIC_1', 100);
+      performanceBudgetMonitor.setBudget('METRIC_2', 200);
+      performanceBudgetMonitor.measure('METRIC_1', 150);
+      performanceBudgetMonitor.measure('METRIC_2', 250);
+
+      const violations = performanceBudgetMonitor.checkBudgets();
+
+      expect(violations).toHaveLength(2);
+    });
+  });
+
+  describe('performanceBudgetMonitor.getMetrics', () => {
+    it('should return performance metrics', () => {
+      performanceBudgetMonitor.measure('BUNDLE_SIZE', 100000);
+      performanceBudgetMonitor.measure('CHUNK_COUNT', 5);
+      performanceBudgetMonitor.measure('TREESHAKING_SCORE', 80);
+      performanceBudgetMonitor.measure('DYNAMIC_IMPORTS', 3);
+
+      const metrics = performanceBudgetMonitor.getMetrics();
+
+      expect(metrics).toEqual({
+        bundleSize: 100000,
+        chunkCount: 5,
+        treeshakingEffectiveness: 80,
+        dynamicImportUsage: 3
+      });
+    });
+
+    it('should return zero for unmeasured metrics', () => {
+      const metrics = performanceBudgetMonitor.getMetrics();
+
+      expect(metrics).toEqual({
+        bundleSize: 0,
+        chunkCount: 0,
+        treeshakingEffectiveness: 0,
+        dynamicImportUsage: 0
+      });
+    });
+  });
+
+  describe('performanceBudgetMonitor.reset', () => {
+    it('should clear all metrics and budgets', () => {
+      performanceBudgetMonitor.measure('TEST_METRIC', 100);
+      performanceBudgetMonitor.setBudget('TEST_METRIC', 50);
+      
+      performanceBudgetMonitor.reset();
+
+      const metrics = performanceBudgetMonitor.getMetrics();
+      const violations = performanceBudgetMonitor.checkBudgets();
+
+      expect(metrics.bundleSize).toBe(0);
+      expect(violations).toHaveLength(0);
+    });
+  });
+
+  describe('Default performance budgets', () => {
+    it('should have default budgets set', () => {
+      const violations = performanceBudgetMonitor.checkBudgets();
+      
+      // Should have 4 default budgets
+      expect(violations.length).toBeGreaterThanOrEqual(0);
+      
+      // Check that default budgets are accessible
+      const metrics = performanceBudgetMonitor.getMetrics();
+      expect(metrics).toBeDefined();
+    });
+  });
+}); 

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

@@ -0,0 +1,250 @@
+import { describe, it, expect } from 'vitest';
+import { PermissionType, parsePermission } from '../permissionTypes';
+
+describe('permissionTypes', () => {
+  describe('PermissionType enum', () => {
+    it('should have all required permission types', () => {
+      expect(PermissionType.READ).toBe('read');
+      expect(PermissionType.WRITE).toBe('write');
+      expect(PermissionType.DELETE).toBe('delete');
+      expect(PermissionType.ADMIN).toBe('admin');
+    });
+
+    it('should have correct string values', () => {
+      expect(typeof PermissionType.READ).toBe('string');
+      expect(typeof PermissionType.WRITE).toBe('string');
+      expect(typeof PermissionType.DELETE).toBe('string');
+      expect(typeof PermissionType.ADMIN).toBe('string');
+    });
+
+    it('should have unique values', () => {
+      const values = Object.values(PermissionType);
+      const uniqueValues = new Set(values);
+      expect(uniqueValues.size).toBe(values.length);
+    });
+  });
+
+  describe('parsePermission', () => {
+    it('should parse valid permission strings', () => {
+      const testCases = [
+        { input: 'read:users', expected: { resource: 'users', action: 'read' } },
+        { input: 'write:reports', expected: { resource: 'reports', action: 'write' } },
+        { input: 'delete:events', expected: { resource: 'events', action: 'delete' } },
+        { input: 'admin:system', expected: { resource: 'system', action: 'admin' } }
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = parsePermission(input);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    it('should handle complex resource names', () => {
+      const testCases = [
+        { input: 'read:user_profiles', expected: { resource: 'user_profiles', action: 'read' } },
+        { input: 'write:api_keys', expected: { resource: 'api_keys', action: 'write' } },
+        { input: 'delete:system_logs', expected: { resource: 'system_logs', action: 'delete' } },
+        { input: 'admin:user_management', expected: { resource: 'user_management', action: 'admin' } }
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = parsePermission(input);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    it('should handle resource names with hyphens', () => {
+      const testCases = [
+        { input: 'read:user-profiles', expected: { resource: 'user-profiles', action: 'read' } },
+        { input: 'write:api-keys', expected: { resource: 'api-keys', action: 'write' } },
+        { input: 'delete:system-logs', expected: { resource: 'system-logs', action: 'delete' } }
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = parsePermission(input);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    it('should handle resource names with dots', () => {
+      const testCases = [
+        { input: 'read:user.profiles', expected: { resource: 'user.profiles', action: 'read' } },
+        { input: 'write:api.keys', expected: { resource: 'api.keys', action: 'write' } },
+        { input: 'delete:system.logs', expected: { resource: 'system.logs', action: 'delete' } }
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = parsePermission(input);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    it('should return null for invalid permission strings', () => {
+      const invalidPermissions = [
+        '', // Empty string
+        'read', // Missing resource
+        ':users', // Missing action
+        'read:users:extra', // Too many parts
+        'read-users', // Wrong separator
+        'read/users', // Wrong separator
+        'read users', // Wrong separator
+        'read::users', // Double colon
+        ':read:users', // Leading colon
+        'read:users:', // Trailing colon
+        'read:', // Action with trailing colon
+        ':users', // Resource with leading colon
+        'read:users:admin', // Three parts
+        'read:users:admin:extra' // Four parts
+      ];
+
+      invalidPermissions.forEach(permission => {
+        const result = parsePermission(permission);
+        expect(result).toBeNull();
+      });
+    });
+
+    it('should return null for non-string inputs', () => {
+      const invalidInputs = [
+        null,
+        undefined,
+        123,
+        true,
+        false,
+        {},
+        [],
+        () => {}
+      ];
+
+      invalidInputs.forEach(input => {
+        const result = parsePermission(input as any);
+        expect(result).toBeNull();
+      });
+    });
+
+    it('should handle whitespace in permission strings', () => {
+      const testCases = [
+        { input: ' read:users', expected: { resource: 'users', action: ' read' } }, // Leading space
+        { input: 'read:users ', expected: { resource: 'users ', action: 'read' } }, // Trailing space
+        { input: ' read:users ', expected: { resource: 'users ', action: ' read' } }, // Both spaces
+        { input: 'read :users', expected: { resource: 'users', action: 'read ' } }, // Space around colon
+        { input: 'read: users', expected: { resource: ' users', action: 'read' } }, // Space after colon
+        { input: ' read : users ', expected: { resource: ' users ', action: ' read ' } } // Multiple spaces
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = parsePermission(input);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    it('should handle case sensitivity', () => {
+      const testCases = [
+        { input: 'READ:users', expected: { resource: 'users', action: 'READ' } },
+        { input: 'read:USERS', expected: { resource: 'USERS', action: 'read' } },
+        { input: 'READ:USERS', expected: { resource: 'USERS', action: 'READ' } },
+        { input: 'Read:Users', expected: { resource: 'Users', action: 'Read' } }
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = parsePermission(input);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    it('should handle special characters in resource names', () => {
+      const testCases = [
+        { input: 'read:users-123', expected: { resource: 'users-123', action: 'read' } },
+        { input: 'write:api_v2', expected: { resource: 'api_v2', action: 'write' } },
+        { input: 'delete:test@example.com', expected: { resource: 'test@example.com', action: 'delete' } },
+        { input: 'admin:user+profile', expected: { resource: 'user+profile', action: 'admin' } }
+      ];
+
+      testCases.forEach(({ input, expected }) => {
+        const result = parsePermission(input);
+        expect(result).toEqual(expected);
+      });
+    });
+  });
+
+  describe('Integration tests', () => {
+    it('should work with PermissionType enum values', () => {
+      const testCases = [
+        { permission: `${PermissionType.READ}:users`, expected: { resource: 'users', action: PermissionType.READ } },
+        { permission: `${PermissionType.WRITE}:reports`, expected: { resource: 'reports', action: PermissionType.WRITE } },
+        { permission: `${PermissionType.DELETE}:events`, expected: { resource: 'events', action: PermissionType.DELETE } },
+        { permission: `${PermissionType.ADMIN}:system`, expected: { resource: 'system', action: PermissionType.ADMIN } }
+      ];
+
+      testCases.forEach(({ permission, expected }) => {
+        const result = parsePermission(permission);
+        expect(result).toEqual(expected);
+      });
+    });
+
+    it('should handle realistic permission scenarios', () => {
+      const realisticPermissions = [
+        'read:user_profiles',
+        'write:user_profiles',
+        'delete:user_profiles',
+        'read:system_logs',
+        'write:system_logs',
+        'admin:user_management',
+        'read:api_keys',
+        'write:api_keys',
+        'delete:api_keys',
+        'admin:system_config'
+      ];
+
+      realisticPermissions.forEach(permission => {
+        const result = parsePermission(permission);
+        expect(result).not.toBeNull();
+        expect(result).toHaveProperty('action');
+        expect(result).toHaveProperty('resource');
+        expect(typeof result!.action).toBe('string');
+        expect(typeof result!.resource).toBe('string');
+      });
+    });
+
+    it('should handle permission validation workflow', () => {
+      const userPermissions = [
+        'read:users',
+        'write:users',
+        'read:reports',
+        'admin:system'
+      ];
+
+      const parsedPermissions = userPermissions
+        .map(permission => parsePermission(permission))
+        .filter(result => result !== null);
+
+      expect(parsedPermissions).toHaveLength(4);
+      expect(parsedPermissions[0]).toEqual({ action: 'read', resource: 'users' });
+      expect(parsedPermissions[1]).toEqual({ action: 'write', resource: 'users' });
+      expect(parsedPermissions[2]).toEqual({ action: 'read', resource: 'reports' });
+      expect(parsedPermissions[3]).toEqual({ action: 'admin', resource: 'system' });
+    });
+
+    it('should handle mixed valid and invalid permissions', () => {
+      const mixedPermissions = [
+        'read:users',
+        'invalid-permission',
+        'write:reports',
+        '',
+        'read:',
+        ':users',
+        'admin:system',
+        null,
+        'read:users:extra'
+      ];
+
+      const validResults = mixedPermissions
+        .map(permission => parsePermission(permission))
+        .filter(result => result !== null);
+
+      expect(validResults).toHaveLength(3);
+      expect(validResults[0]).toEqual({ action: 'read', resource: 'users' });
+      expect(validResults[1]).toEqual({ action: 'write', resource: 'reports' });
+      expect(validResults[2]).toEqual({ action: 'admin', resource: 'system' });
+    });
+  });
+});