@jmruthers/pace-core 0.5.67 → 0.5.69

package/src/rbac/__tests__/integration.authflow.test.tsx

@@ -76,11 +76,7 @@ describe('RBAC AuthFlow Minimal', () => {
       .mockResolvedValue({ data: { user: mockUser }, error: null });
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('renders authenticated view', async () => {
+    it('renders authenticated view', async () => {
     const router = createMemoryRouter([{ path: '/', element: <MinimalAuthComponent /> }]);
 
     render(

package/src/rbac/__tests__/integration.navigation.test.tsx

@@ -49,10 +49,7 @@ const NavUnderTest = () => {
 };
 
 describe('RBAC Navigation Integration', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-  afterEach(() => vi.restoreAllMocks());
+    afterEach(() => vi.restoreAllMocks());
 
   it('shows all mocked navigation items', async () => {
     const router = createMemoryRouter([{ path: '/', element: <NavUnderTest /> }]);

package/src/rbac/__tests__/rbac-core.test.tsx

@@ -19,13 +19,8 @@ const mockSupabaseClient = {
 };
 
 describe('RBAC Core Functionality', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
+  // Removed redundant beforeEach/afterEach - global config handles this
+  // (vitest.config.ts has restoreMocks: true and clearMocks: true)
 
   describe('Permission Types', () => {
     it('has all required operation types', () => {

package/src/rbac/__tests__/rbac-functions.test.ts

@@ -46,15 +46,7 @@ const mockApp = {
 };
 
 describe('RBAC Functions', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('rbac_permission_check', () => {
+      describe('rbac_permission_check', () => {
     it('should return false for null user_id', async () => {
       mockSupabase.rpc.mockResolvedValue({
         data: [{ has_permission: false, role_name: null, permission_source: 'none', granted_at: null }],

package/src/rbac/__tests__/rbac-integration.test.ts

@@ -46,15 +46,7 @@ const testApp = {
 };
 
 describe('RBAC Integration Tests', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Complete Permission Flow', () => {
+      describe('Complete Permission Flow', () => {
     it('should handle user login → permission check → data access flow', async () => {
       // 1. User logs in and session is tracked
       mockSupabase.rpc

package/src/rbac/api.test.ts

@@ -90,15 +90,7 @@ describe('RBAC API', () => {
   const mockCreateRBACConfig = vi.mocked(createRBACConfig);
   const mockGetRBACLogger = vi.mocked(getRBACLogger);
 
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('setupRBAC', () => {
+      describe('setupRBAC', () => {
     it('initializes RBAC system correctly', () => {
       const originalEnv = process.env.NODE_ENV;
       process.env.NODE_ENV = 'production';

package/src/rbac/cache.test.ts

@@ -49,38 +49,40 @@ describe('RBACCache', () => {
   });
 
   describe('TTL Expiration', () => {
-    it.skip('expires entries after TTL', () => {
+    it('expires entries after TTL', () => {
       // Create a new cache instance to avoid timing issues
       const testCache = new RBACCache();
       
       // Mock Date.now to control time
       const mockDateNow = vi.spyOn(Date, 'now');
       const startTime = 1000000;
-      mockDateNow.mockReturnValue(startTime);
       
+      // Set initial time
+      mockDateNow.mockReturnValue(startTime);
       testCache.set('test-key', 'test-value', 1000); // 1 second TTL
       expect(testCache.get('test-key')).toBe('test-value');
       
-      // Advance time by 1 second
-      mockDateNow.mockReturnValue(startTime + 1000);
+      // Advance time by 1 second (1001ms to ensure expiration)
+      mockDateNow.mockReturnValue(startTime + 1001);
       expect(testCache.get('test-key')).toBeNull();
       
       mockDateNow.mockRestore();
     });
 
-    it.skip('uses default TTL when not specified', () => {
+    it('uses default TTL when not specified', () => {
       // Create a new cache instance to avoid timing issues
       const testCache = new RBACCache();
       
       // Mock Date.now to control time
       const mockDateNow = vi.spyOn(Date, 'now');
       const startTime = 1000000;
-      mockDateNow.mockReturnValue(startTime);
       
+      // Set initial time
+      mockDateNow.mockReturnValue(startTime);
       testCache.set('test-key', 'test-value');
       
-      // Advance time by 60 seconds (default TTL)
-      mockDateNow.mockReturnValue(startTime + 60000);
+      // Advance time by 60 seconds (default TTL) + 1ms to ensure expiration
+      mockDateNow.mockReturnValue(startTime + 60001);
       expect(testCache.get('test-key')).toBeNull();
       
       mockDateNow.mockRestore();

package/src/rbac/cli/__tests__/policy-manager.test.ts

@@ -0,0 +1,339 @@
+/**
+ * @file RBAC Policy Manager CLI Tests
+ * @package @jmruthers/pace-core
+ * @module RBAC/CLI/__tests__
+ * @since 1.0.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock external dependencies
+vi.mock('@supabase/supabase-js', () => ({
+  createClient: vi.fn(() => ({
+    from: vi.fn(() => ({
+      select: vi.fn(() => ({
+        eq: vi.fn(() => ({
+          order: vi.fn(() => ({
+            data: [],
+            error: null
+          }))
+        }))
+      })),
+      insert: vi.fn(() => ({
+        data: [],
+        error: null
+      })),
+      update: vi.fn(() => ({
+        eq: vi.fn(() => ({
+          data: [],
+          error: null
+        }))
+      })),
+      delete: vi.fn(() => ({
+        eq: vi.fn(() => ({
+          data: [],
+          error: null
+        }))
+      }))
+    })),
+    rpc: vi.fn(() => ({
+      data: null,
+      error: null
+    }))
+  }))
+}));
+
+vi.mock('commander', () => ({
+  Command: vi.fn(() => ({
+    name: vi.fn().mockReturnThis(),
+    description: vi.fn().mockReturnThis(),
+    version: vi.fn().mockReturnThis(),
+    option: vi.fn().mockReturnThis(),
+    command: vi.fn().mockReturnThis(),
+    argument: vi.fn().mockReturnThis(),
+    action: vi.fn().mockReturnThis(),
+    parse: vi.fn().mockReturnThis()
+  }))
+}));
+
+vi.mock('chalk', () => ({
+  default: {
+    red: vi.fn((text) => text),
+    green: vi.fn((text) => text),
+    yellow: vi.fn((text) => text),
+    blue: vi.fn((text) => text),
+    bold: vi.fn((text) => text)
+  }
+}));
+
+vi.mock('ora', () => ({
+  default: vi.fn(() => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis()
+  }))
+}));
+
+vi.mock('cli-table3', () => ({
+  default: vi.fn(() => ({
+    push: vi.fn(),
+    toString: vi.fn(() => 'Mock table output')
+  }))
+}));
+
+// Mock console methods
+const originalConsole = console;
+beforeEach(() => {
+  console.log = vi.fn();
+  console.error = vi.fn();
+});
+
+afterEach(() => {
+  console.log = originalConsole.log;
+  console.error = originalConsole.error;
+});
+
+describe('[cli] PolicyManager', () => {
+  describe('Class Instantiation', () => {
+    it('creates instance with valid parameters', async () => {
+      // Import the mocked createClient
+      const { createClient } = await import('@supabase/supabase-js');
+      
+      // Test that the class can be instantiated
+      const { PolicyManager } = await import('../policy-manager');
+      const manager = new PolicyManager('https://test.supabase.co', 'test-key');
+      
+      expect(manager).toBeDefined();
+      expect(createClient).toHaveBeenCalledWith('https://test.supabase.co', 'test-key');
+    });
+
+    it('handles invalid Supabase URL', async () => {
+      expect(async () => {
+        const { PolicyManager } = await import('../policy-manager');
+        new PolicyManager('', 'test-key');
+      }).not.toThrow();
+    });
+
+    it('handles invalid Supabase key', async () => {
+      expect(async () => {
+        const { PolicyManager } = await import('../policy-manager');
+        new PolicyManager('https://test.supabase.co', '');
+      }).not.toThrow();
+    });
+  });
+
+  describe('Interface Definitions', () => {
+    it('has correct PolicyConfig interface structure', () => {
+      // Test that the interface is properly defined by checking the mock data structure
+      const mockPolicyConfig = {
+        table_name: 'test_table',
+        page_name: 'test_page',
+        app_name: 'TEST_APP',
+        organisation_column: 'organisation_id',
+        event_column: 'event_id',
+        operations: ['read', 'create', 'update', 'delete'],
+        is_active: true
+      };
+
+      expect(mockPolicyConfig).toHaveProperty('table_name');
+      expect(mockPolicyConfig).toHaveProperty('page_name');
+      expect(mockPolicyConfig).toHaveProperty('app_name');
+      expect(mockPolicyConfig).toHaveProperty('organisation_column');
+      expect(mockPolicyConfig).toHaveProperty('event_column');
+      expect(mockPolicyConfig).toHaveProperty('operations');
+      expect(mockPolicyConfig).toHaveProperty('is_active');
+    });
+
+    it('has correct PolicyAudit interface structure', () => {
+      const mockPolicyAudit = {
+        table_name: 'test_table',
+        policy_name: 'test_policy',
+        operation: 'read',
+        action: 'created',
+        changed_at: '2024-01-01T00:00:00Z',
+        success: true,
+        error_message: undefined
+      };
+
+      expect(mockPolicyAudit).toHaveProperty('table_name');
+      expect(mockPolicyAudit).toHaveProperty('policy_name');
+      expect(mockPolicyAudit).toHaveProperty('operation');
+      expect(mockPolicyAudit).toHaveProperty('action');
+      expect(mockPolicyAudit).toHaveProperty('changed_at');
+      expect(mockPolicyAudit).toHaveProperty('success');
+      expect(mockPolicyAudit).toHaveProperty('error_message');
+    });
+
+    it('has correct HealthCheck interface structure', () => {
+      const mockHealthCheck = {
+        table_name: 'test_table',
+        policy_name: 'test_policy',
+        operation: 'read',
+        is_healthy: true,
+        issues: []
+      };
+
+      expect(mockHealthCheck).toHaveProperty('table_name');
+      expect(mockHealthCheck).toHaveProperty('policy_name');
+      expect(mockHealthCheck).toHaveProperty('operation');
+      expect(mockHealthCheck).toHaveProperty('is_healthy');
+      expect(mockHealthCheck).toHaveProperty('issues');
+    });
+  });
+
+  describe('CLI Command Structure', () => {
+    it('has proper command setup', () => {
+      const { Command } = require('commander');
+      
+      // Test that Command is a function (mocked)
+      expect(Command).toBeInstanceOf(Function);
+    });
+
+    it('handles command line arguments', () => {
+      // Mock process.argv
+      const originalArgv = process.argv;
+      process.argv = ['node', 'policy-manager.js', 'list'];
+      
+      // Test that the CLI can handle arguments
+      expect(process.argv).toContain('list');
+      
+      // Restore original argv
+      process.argv = originalArgv;
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('handles Supabase connection errors gracefully', async () => {
+      const { createClient } = await import('@supabase/supabase-js');
+      const mockedCreateClient = vi.mocked(createClient);
+      
+      // Mock a connection error
+      mockedCreateClient.mockImplementationOnce(() => {
+        throw new Error('Connection failed');
+      });
+
+      await expect(async () => {
+        const { PolicyManager } = await import('../policy-manager');
+        new PolicyManager('https://invalid.supabase.co', 'invalid-key');
+      }).rejects.toThrow('Connection failed');
+    });
+
+    it('handles missing environment variables', () => {
+      const originalEnv = process.env;
+      
+      // Test with missing SUPABASE_URL
+      delete process.env.SUPABASE_URL;
+      delete process.env.SUPABASE_SERVICE_ROLE_KEY;
+      
+      // The CLI should handle missing env vars gracefully
+      expect(process.env.SUPABASE_URL).toBeUndefined();
+      expect(process.env.SUPABASE_SERVICE_ROLE_KEY).toBeUndefined();
+      
+      // Restore original env
+      process.env = originalEnv;
+    });
+  });
+
+  describe('Utility Functions', () => {
+    it('validates table names', () => {
+      const validTableNames = ['users', 'events', 'organisations', 'cake_meal'];
+      const invalidTableNames = ['', '123invalid', 'table with spaces', 'table-with-dashes'];
+      
+      validTableNames.forEach(name => {
+        expect(name).toMatch(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
+      });
+      
+      invalidTableNames.forEach(name => {
+        expect(name).not.toMatch(/^[a-zA-Z_][a-zA-Z0-9_]*$/);
+      });
+    });
+
+    it('validates app names', () => {
+      const validAppNames = ['CAKE', 'PACE', 'TRAC', 'TEST_APP'];
+      const invalidAppNames = ['', 'invalid app', 'app-with-dashes', '123APP'];
+      
+      validAppNames.forEach(name => {
+        expect(name).toMatch(/^[A-Z_][A-Z0-9_]*$/);
+      });
+      
+      invalidAppNames.forEach(name => {
+        expect(name).not.toMatch(/^[A-Z_][A-Z0-9_]*$/);
+      });
+    });
+
+    it('validates operation names', () => {
+      const validOperations = ['read', 'create', 'update', 'delete', 'manage'];
+      const invalidOperations = ['', 'READ', 'invalid', 'read-create'];
+      
+      validOperations.forEach(op => {
+        expect(op).toMatch(/^(read|create|update|delete|manage)$/);
+      });
+      
+      invalidOperations.forEach(op => {
+        expect(op).not.toMatch(/^(read|create|update|delete|manage)$/);
+      });
+    });
+  });
+
+  describe('Mock Data Validation', () => {
+    it('validates mock policy config data', () => {
+      const mockData = {
+        table_name: 'cake_meal',
+        page_name: 'meals',
+        app_name: 'CAKE',
+        organisation_column: 'organisation_id',
+        event_column: 'meal_event_id',
+        operations: ['read', 'create', 'update', 'delete'],
+        is_active: true
+      };
+
+      expect(mockData.table_name).toBe('cake_meal');
+      expect(mockData.page_name).toBe('meals');
+      expect(mockData.app_name).toBe('CAKE');
+      expect(mockData.organisation_column).toBe('organisation_id');
+      expect(mockData.event_column).toBe('meal_event_id');
+      expect(Array.isArray(mockData.operations)).toBe(true);
+      expect(mockData.operations).toContain('read');
+      expect(mockData.operations).toContain('create');
+      expect(mockData.operations).toContain('update');
+      expect(mockData.operations).toContain('delete');
+      expect(typeof mockData.is_active).toBe('boolean');
+    });
+
+    it('validates mock audit data', () => {
+      const mockAudit = {
+        table_name: 'cake_meal',
+        policy_name: 'rbac_read_meals',
+        operation: 'read',
+        action: 'created',
+        changed_at: '2024-01-01T00:00:00Z',
+        success: true
+      };
+
+      expect(mockAudit.table_name).toBe('cake_meal');
+      expect(mockAudit.policy_name).toBe('rbac_read_meals');
+      expect(mockAudit.operation).toBe('read');
+      expect(mockAudit.action).toBe('created');
+      expect(mockAudit.changed_at).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/);
+      expect(typeof mockAudit.success).toBe('boolean');
+    });
+  });
+
+  describe('CLI Integration', () => {
+    it('can be imported without errors', async () => {
+      expect(async () => {
+        const { PolicyManager } = await import('../policy-manager');
+        // Just check that the module can be imported
+        expect(PolicyManager).toBeDefined();
+      }).not.toThrow();
+    });
+
+    it('exports expected interfaces', async () => {
+      const { PolicyManager } = await import('../policy-manager');
+      
+      // The module should be importable
+      expect(PolicyManager).toBeDefined();
+    });
+  });
+});

package/src/rbac/components/EnhancedNavigationMenu.test.tsx

@@ -100,11 +100,7 @@ describe('EnhancedNavigationMenu', () => {
     } as any);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Rendering', () => {
+    describe('Rendering', () => {
     it('renders navigation items correctly', () => {
       render(
         <EnhancedNavigationMenu items={mockNavigationItems} />

package/src/rbac/components/NavigationProvider.test.tsx

@@ -84,11 +84,7 @@ describe('NavigationProvider', () => {
     } as any);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Provider Initialization', () => {
+    describe('Provider Initialization', () => {
     it('renders children correctly', () => {
       render(
         <NavigationProvider>

package/src/rbac/components/PagePermissionProvider.test.tsx

@@ -60,11 +60,7 @@ describe('PagePermissionProvider', () => {
     } as any);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Provider Initialization', () => {
+    describe('Provider Initialization', () => {
     it('renders children correctly', () => {
       render(
         <PagePermissionProvider>

package/src/rbac/components/SecureDataProvider.test.tsx

@@ -74,11 +74,7 @@ describe('SecureDataProvider', () => {
     } as any);
   });
 
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('Provider Initialization', () => {
+    describe('Provider Initialization', () => {
     it('renders children correctly', () => {
       render(
         <SecureDataProvider>