@fulcrum-governance/sdk 0.1.0 → 0.1.3

package/dist/__tests__/clients.test.js

@@ -0,0 +1,847 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const clients_1 = require("../clients");
+// Mock fetch globally
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+describe('PolicyClient', () => {
+    const baseUrl = 'http://localhost:3000';
+    let client;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        client = new clients_1.PolicyClient({ baseUrl });
+    });
+    describe('initialization', () => {
+        it('should create client with default options', () => {
+            const c = new clients_1.PolicyClient({ baseUrl: 'http://example.com' });
+            expect(c).toBeInstanceOf(clients_1.PolicyClient);
+        });
+        it('should trim trailing slash from baseUrl', () => {
+            const c = new clients_1.PolicyClient({ baseUrl: 'http://example.com/' });
+            expect(c.baseUrl).toBe('http://example.com');
+        });
+        it('should set default timeout to 5000ms', () => {
+            expect(client.timeoutMs).toBe(5000);
+        });
+        it('should accept custom options', () => {
+            const c = new clients_1.PolicyClient({
+                baseUrl,
+                apiKey: 'test-key',
+                timeoutMs: 10000,
+            });
+            expect(c.apiKey).toBe('test-key');
+            expect(c.timeoutMs).toBe(10000);
+        });
+    });
+    describe('list', () => {
+        it('should fetch policies successfully', async () => {
+            const mockPolicies = [
+                { id: '1', name: 'Policy 1', policy_type: 'cost', enabled: true },
+                { id: '2', name: 'Policy 2', policy_type: 'rate', enabled: false },
+            ];
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockPolicies,
+            });
+            const policies = await client.list();
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/policies`, expect.objectContaining({
+                method: 'GET',
+                headers: { 'Content-Type': 'application/json' },
+            }));
+            expect(policies).toEqual(mockPolicies);
+        });
+        it('should apply filters to query params', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [],
+            });
+            await client.list({ status: 'ACTIVE', policy_type: 'cost' });
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('status=ACTIVE'), expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('policy_type=cost'), expect.any(Object));
+        });
+        it('should include Authorization header when apiKey is set', async () => {
+            const authedClient = new clients_1.PolicyClient({ baseUrl, apiKey: 'my-key' });
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => [],
+            });
+            await authedClient.list();
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer my-key',
+                }),
+            }));
+        });
+        it('should throw PolicyClientError on failure', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: async () => ({ error: 'Database error' }),
+            });
+            try {
+                await client.list();
+                fail('Expected PolicyClientError to be thrown');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(clients_1.PolicyClientError);
+                expect(error.message).toBe('Database error');
+                expect(error.statusCode).toBe(500);
+            }
+        });
+    });
+    describe('get', () => {
+        it('should fetch single policy by ID', async () => {
+            const mockPolicy = {
+                id: '123',
+                name: 'Test Policy',
+                policy_type: 'cost',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockPolicy,
+            });
+            const policy = await client.get('123');
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/policies/123`, expect.objectContaining({ method: 'GET' }));
+            expect(policy).toEqual(mockPolicy);
+        });
+        it('should throw on 404', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                json: async () => ({ error: 'Policy not found' }),
+            });
+            await expect(client.get('nonexistent')).rejects.toThrow(clients_1.PolicyClientError);
+        });
+    });
+    describe('create', () => {
+        it('should create policy with required fields', async () => {
+            const newPolicy = {
+                name: 'New Policy',
+                policy_type: 'cost',
+                rules: { max_cost: 100 },
+            };
+            const createdPolicy = { id: '456', ...newPolicy, enabled: true };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => createdPolicy,
+            });
+            const result = await client.create(newPolicy);
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/policies`, expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify(newPolicy),
+            }));
+            expect(result).toEqual(createdPolicy);
+        });
+        it('should create policy with optional fields', async () => {
+            const newPolicy = {
+                name: 'New Policy',
+                policy_type: 'cost',
+                rules: { max_cost: 100 },
+                enabled: false,
+                priority: 10,
+                status: 'DRAFT',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ id: '789', ...newPolicy }),
+            });
+            await client.create(newPolicy);
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: JSON.stringify(newPolicy),
+            }));
+        });
+    });
+    describe('update', () => {
+        it('should update policy with partial data', async () => {
+            const updates = { name: 'Updated Name', priority: 5 };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ id: '123', ...updates }),
+            });
+            const result = await client.update('123', updates);
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/policies/123`, expect.objectContaining({
+                method: 'PATCH',
+                body: JSON.stringify(updates),
+            }));
+            expect(result.name).toBe('Updated Name');
+        });
+    });
+    describe('delete', () => {
+        it('should delete policy', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({}),
+            });
+            await expect(client.delete('123')).resolves.toBeUndefined();
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/policies/123`, expect.objectContaining({ method: 'DELETE' }));
+        });
+    });
+    describe('setEnabled', () => {
+        it('should enable policy', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ id: '123', enabled: true }),
+            });
+            const result = await client.setEnabled('123', true);
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/policies/123`, expect.objectContaining({
+                method: 'PATCH',
+                body: JSON.stringify({ enabled: true }),
+            }));
+            expect(result.enabled).toBe(true);
+        });
+        it('should disable policy', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ id: '123', enabled: false }),
+            });
+            const result = await client.setEnabled('123', false);
+            expect(result.enabled).toBe(false);
+        });
+    });
+    describe('setStatus', () => {
+        it('should update policy status', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ id: '123', status: 'INACTIVE' }),
+            });
+            const result = await client.setStatus('123', 'INACTIVE');
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: JSON.stringify({ status: 'INACTIVE' }),
+            }));
+            expect(result.status).toBe('INACTIVE');
+        });
+    });
+});
+describe('ApprovalClient', () => {
+    const baseUrl = 'http://localhost:3000';
+    let client;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        client = new clients_1.ApprovalClient({ baseUrl });
+    });
+    describe('initialization', () => {
+        it('should create client with default options', () => {
+            const c = new clients_1.ApprovalClient({ baseUrl: 'http://example.com' });
+            expect(c).toBeInstanceOf(clients_1.ApprovalClient);
+        });
+        it('should trim trailing slash from baseUrl', () => {
+            const c = new clients_1.ApprovalClient({ baseUrl: 'http://example.com/' });
+            expect(c.baseUrl).toBe('http://example.com');
+        });
+    });
+    describe('list', () => {
+        it('should fetch approvals successfully', async () => {
+            const mockApprovals = [
+                { id: '1', envelope_id: 'env-1', status: 'PENDING' },
+                { id: '2', envelope_id: 'env-2', status: 'APPROVED' },
+            ];
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ approvals: mockApprovals }),
+            });
+            const approvals = await client.list();
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/approvals`, expect.objectContaining({ method: 'GET' }));
+            expect(approvals).toEqual(mockApprovals);
+        });
+        it('should apply status filter', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ approvals: [] }),
+            });
+            await client.list({ status: 'PENDING' });
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('status=PENDING'), expect.any(Object));
+        });
+        it('should throw ApprovalClientError on failure', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: async () => ({ error: 'Server error' }),
+            });
+            await expect(client.list()).rejects.toThrow(clients_1.ApprovalClientError);
+        });
+    });
+    describe('listPending', () => {
+        it('should fetch only pending approvals', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ approvals: [] }),
+            });
+            await client.listPending();
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('status=PENDING'), expect.any(Object));
+        });
+    });
+    describe('get', () => {
+        it('should fetch single approval by ID', async () => {
+            const mockApproval = { id: '123', envelope_id: 'env-1', status: 'PENDING' };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockApproval,
+            });
+            const approval = await client.get('123');
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/approvals/123`, expect.objectContaining({ method: 'GET' }));
+            expect(approval).toEqual(mockApproval);
+        });
+    });
+    describe('decide', () => {
+        it('should submit approval decision', async () => {
+            const decision = {
+                approval_id: '123',
+                decision: 'APPROVED',
+                comment: 'Looks good',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    approval: { id: '123', status: 'APPROVED', review_note: 'Looks good' },
+                }),
+            });
+            const result = await client.decide(decision);
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/approvals`, expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify(decision),
+            }));
+            expect(result.status).toBe('APPROVED');
+        });
+    });
+    describe('approve', () => {
+        it('should approve with comment', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    approval: { id: '123', status: 'APPROVED' },
+                }),
+            });
+            const result = await client.approve('123', 'Approved by admin');
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: JSON.stringify({
+                    approval_id: '123',
+                    decision: 'APPROVED',
+                    comment: 'Approved by admin',
+                }),
+            }));
+            expect(result.status).toBe('APPROVED');
+        });
+        it('should approve without comment', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    approval: { id: '123', status: 'APPROVED' },
+                }),
+            });
+            await client.approve('123');
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: JSON.stringify({
+                    approval_id: '123',
+                    decision: 'APPROVED',
+                    comment: undefined,
+                }),
+            }));
+        });
+    });
+    describe('deny', () => {
+        it('should deny with required comment', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    approval: { id: '123', status: 'DENIED', review_note: 'Policy violation' },
+                }),
+            });
+            const result = await client.deny('123', 'Policy violation');
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: JSON.stringify({
+                    approval_id: '123',
+                    decision: 'DENIED',
+                    comment: 'Policy violation',
+                }),
+            }));
+            expect(result.status).toBe('DENIED');
+        });
+    });
+});
+describe('BudgetClient', () => {
+    const baseUrl = 'http://localhost:3000';
+    let client;
+    const mockBudget = {
+        id: 'bud_123',
+        org_id: 'org_1',
+        name: 'Monthly API Budget',
+        scope: 'GLOBAL',
+        scope_id: null,
+        limit_amount: 1000,
+        period: 'MONTHLY',
+        action: 'WARN',
+        alert_thresholds: [50, 75, 90],
+        current_spend: 450,
+        period_start: '2026-01-01T00:00:00Z',
+        created_by: 'user_1',
+        created_at: '2026-01-01T00:00:00Z',
+        updated_at: '2026-01-01T00:00:00Z',
+        last_alert_sent: null,
+        status: 'active',
+        percentage: 45,
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        client = new clients_1.BudgetClient({ baseUrl });
+    });
+    describe('initialization', () => {
+        it('should create client with default options', () => {
+            const c = new clients_1.BudgetClient({ baseUrl: 'http://example.com' });
+            expect(c).toBeInstanceOf(clients_1.BudgetClient);
+        });
+        it('should trim trailing slash from baseUrl', () => {
+            const c = new clients_1.BudgetClient({ baseUrl: 'http://example.com/' });
+            expect(c.baseUrl).toBe('http://example.com');
+        });
+        it('should set default timeout to 5000ms', () => {
+            expect(client.timeoutMs).toBe(5000);
+        });
+    });
+    describe('list', () => {
+        it('should fetch budgets with summary', async () => {
+            const mockResponse = {
+                budgets: [mockBudget],
+                summary: {
+                    total: 1,
+                    active: 1,
+                    exceeded: 0,
+                    totalLimit: 1000,
+                    totalSpend: 450,
+                },
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const response = await client.list();
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/budgets`, expect.objectContaining({ method: 'GET' }));
+            expect(response.budgets).toHaveLength(1);
+            expect(response.summary.total).toBe(1);
+        });
+        it('should apply filters to query params', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ budgets: [], summary: {} }),
+            });
+            await client.list({ scope: 'GLOBAL', status: 'exceeded' });
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('scope=GLOBAL'), expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('status=exceeded'), expect.any(Object));
+        });
+        it('should throw BudgetClientError on failure', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: async () => ({ error: 'Database error' }),
+            });
+            await expect(client.list()).rejects.toThrow(clients_1.BudgetClientError);
+        });
+    });
+    describe('listBudgets', () => {
+        it('should return only budgets array', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    budgets: [mockBudget],
+                    summary: { total: 1 },
+                }),
+            });
+            const budgets = await client.listBudgets();
+            expect(budgets).toEqual([mockBudget]);
+        });
+    });
+    describe('getSummary', () => {
+        it('should return only summary', async () => {
+            const summary = {
+                total: 5,
+                active: 4,
+                exceeded: 1,
+                totalLimit: 5000,
+                totalSpend: 2500,
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ budgets: [], summary }),
+            });
+            const result = await client.getSummary();
+            expect(result).toEqual(summary);
+        });
+    });
+    describe('get', () => {
+        it('should fetch single budget by ID', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockBudget,
+            });
+            const budget = await client.get('bud_123');
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/budgets/bud_123`, expect.objectContaining({ method: 'GET' }));
+            expect(budget).toEqual(mockBudget);
+        });
+    });
+    describe('create', () => {
+        it('should create budget with required fields', async () => {
+            const newBudget = {
+                name: 'New Budget',
+                scope: 'WORKFLOW',
+                scope_id: 'wf_123',
+                limit_amount: 500,
+                period: 'WEEKLY',
+                action: 'HARD_LIMIT',
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    budget: { id: 'bud_new', ...newBudget, status: 'active', percentage: 0 },
+                    message: 'Budget created successfully',
+                }),
+            });
+            const result = await client.create(newBudget);
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/budgets`, expect.objectContaining({
+                method: 'POST',
+                body: JSON.stringify(newBudget),
+            }));
+            expect(result.id).toBe('bud_new');
+        });
+    });
+    describe('update', () => {
+        it('should update budget with partial data', async () => {
+            const updates = { limit_amount: 2000 };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ ...mockBudget, limit_amount: 2000 }),
+            });
+            const result = await client.update('bud_123', updates);
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/budgets/bud_123`, expect.objectContaining({
+                method: 'PATCH',
+                body: JSON.stringify(updates),
+            }));
+            expect(result.limit_amount).toBe(2000);
+        });
+    });
+    describe('delete', () => {
+        it('should delete budget', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({}),
+            });
+            await expect(client.delete('bud_123')).resolves.toBeUndefined();
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/budgets/bud_123`, expect.objectContaining({ method: 'DELETE' }));
+        });
+    });
+    describe('getExceeded', () => {
+        it('should fetch exceeded budgets', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    budgets: [{ ...mockBudget, status: 'exceeded' }],
+                    summary: { exceeded: 1 },
+                }),
+            });
+            const budgets = await client.getExceeded();
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('status=exceeded'), expect.any(Object));
+            expect(budgets[0].status).toBe('exceeded');
+        });
+    });
+    describe('getWarnings', () => {
+        it('should fetch warning budgets', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    budgets: [{ ...mockBudget, status: 'warning' }],
+                    summary: {},
+                }),
+            });
+            const budgets = await client.getWarnings();
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('status=warning'), expect.any(Object));
+            expect(budgets[0].status).toBe('warning');
+        });
+    });
+    describe('calculatePercentage', () => {
+        it('should calculate percentage correctly', () => {
+            const percentage = client.calculatePercentage(mockBudget);
+            expect(percentage).toBe(45);
+        });
+        it('should return 0 for zero limit', () => {
+            const zeroBudget = { ...mockBudget, limit_amount: 0 };
+            const percentage = client.calculatePercentage(zeroBudget);
+            expect(percentage).toBe(0);
+        });
+        it('should round percentage', () => {
+            const budget = { ...mockBudget, current_spend: 333, limit_amount: 1000 };
+            const percentage = client.calculatePercentage(budget);
+            expect(percentage).toBe(33);
+        });
+    });
+    describe('isAtThreshold', () => {
+        it('should return true when at threshold', () => {
+            const budget = { ...mockBudget, current_spend: 750, limit_amount: 1000 };
+            expect(client.isAtThreshold(budget, 75)).toBe(true);
+        });
+        it('should return true when above threshold', () => {
+            const budget = { ...mockBudget, current_spend: 900, limit_amount: 1000 };
+            expect(client.isAtThreshold(budget, 75)).toBe(true);
+        });
+        it('should return false when below threshold', () => {
+            const budget = { ...mockBudget, current_spend: 500, limit_amount: 1000 };
+            expect(client.isAtThreshold(budget, 75)).toBe(false);
+        });
+    });
+});
+describe('Error classes', () => {
+    describe('PolicyClientError', () => {
+        it('should have correct name and properties', () => {
+            const error = new clients_1.PolicyClientError('Test error', 404);
+            expect(error.name).toBe('PolicyClientError');
+            expect(error.message).toBe('Test error');
+            expect(error.statusCode).toBe(404);
+        });
+    });
+    describe('ApprovalClientError', () => {
+        it('should have correct name and properties', () => {
+            const error = new clients_1.ApprovalClientError('Test error', 500);
+            expect(error.name).toBe('ApprovalClientError');
+            expect(error.message).toBe('Test error');
+            expect(error.statusCode).toBe(500);
+        });
+    });
+    describe('BudgetClientError', () => {
+        it('should have correct name and properties', () => {
+            const error = new clients_1.BudgetClientError('Test error', 403);
+            expect(error.name).toBe('BudgetClientError');
+            expect(error.message).toBe('Test error');
+            expect(error.statusCode).toBe(403);
+        });
+    });
+    describe('MetricsClientError', () => {
+        it('should have correct name and properties', () => {
+            const error = new clients_1.MetricsClientError('Test error', 503);
+            expect(error.name).toBe('MetricsClientError');
+            expect(error.message).toBe('Test error');
+            expect(error.statusCode).toBe(503);
+        });
+    });
+});
+describe('MetricsClient', () => {
+    const baseUrl = 'http://localhost:3000';
+    let client;
+    const mockPublicMetrics = {
+        lastUpdated: '2026-01-09T12:00:00Z',
+        policiesEvaluated24h: 47832,
+        avgLatencyMs: 8,
+        budgetAlerts24h: 127,
+        activeTenants: 42,
+        blockedRequests24h: 1247,
+        cognitiveLayer: {
+            semanticJudgeRequests: 284719,
+            semanticJudgeViolations: 847,
+            oraclePredictions: 12847,
+            oracleSavings: 18430,
+            immunePoliciesGenerated: 34,
+        },
+    };
+    const mockAuditLog = {
+        id: 'audit_123',
+        org_id: 'org_1',
+        timestamp: '2026-01-09T12:00:00Z',
+        actor_id: 'user_1',
+        actor_email: 'admin@example.com',
+        action: 'policy.created',
+        resource_type: 'Policy',
+        resource_id: 'pol_123',
+        resource_name: 'Test Policy',
+        status: 'success',
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        client = new clients_1.MetricsClient({ baseUrl });
+    });
+    describe('initialization', () => {
+        it('should create client with default options', () => {
+            const c = new clients_1.MetricsClient({ baseUrl: 'http://example.com' });
+            expect(c).toBeInstanceOf(clients_1.MetricsClient);
+        });
+        it('should trim trailing slash from baseUrl', () => {
+            const c = new clients_1.MetricsClient({ baseUrl: 'http://example.com/' });
+            expect(c.baseUrl).toBe('http://example.com');
+        });
+    });
+    describe('getPublicMetrics', () => {
+        it('should fetch public metrics', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockPublicMetrics,
+            });
+            const metrics = await client.getPublicMetrics();
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/metrics/public`, expect.objectContaining({ method: 'GET' }));
+            expect(metrics.policiesEvaluated24h).toBe(47832);
+            expect(metrics.cognitiveLayer.semanticJudgeRequests).toBe(284719);
+        });
+        it('should throw MetricsClientError on failure', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: async () => ({ error: 'Server error' }),
+            });
+            await expect(client.getPublicMetrics()).rejects.toThrow(clients_1.MetricsClientError);
+        });
+    });
+    describe('getCognitiveMetrics', () => {
+        it('should return only cognitive layer metrics', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockPublicMetrics,
+            });
+            const cognitive = await client.getCognitiveMetrics();
+            expect(cognitive.semanticJudgeRequests).toBe(284719);
+            expect(cognitive.oracleSavings).toBe(18430);
+        });
+    });
+    describe('getAverageLatency', () => {
+        it('should return average latency', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockPublicMetrics,
+            });
+            const latency = await client.getAverageLatency();
+            expect(latency).toBe(8);
+        });
+    });
+    describe('getPolicyEvaluationCount', () => {
+        it('should return policy evaluation count', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockPublicMetrics,
+            });
+            const count = await client.getPolicyEvaluationCount();
+            expect(count).toBe(47832);
+        });
+    });
+    describe('getAuditLogs', () => {
+        it('should fetch audit logs with pagination', async () => {
+            const mockResponse = {
+                logs: [mockAuditLog],
+                pagination: {
+                    page: 1,
+                    pageSize: 20,
+                    totalCount: 1,
+                    totalPages: 1,
+                },
+                actors: [{ id: 'user_1', email: 'admin@example.com' }],
+            };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => mockResponse,
+            });
+            const response = await client.getAuditLogs();
+            expect(mockFetch).toHaveBeenCalledWith(`${baseUrl}/api/audit-logs`, expect.objectContaining({ method: 'GET' }));
+            expect(response.logs).toHaveLength(1);
+            expect(response.pagination.page).toBe(1);
+        });
+        it('should apply filters to query params', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ logs: [], pagination: {}, actors: [] }),
+            });
+            await client.getAuditLogs({
+                user_id: 'user_1',
+                resource_type: 'Policy',
+                search: 'created',
+                page: 2,
+            });
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('user_id=user_1'), expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('resource_type=Policy'), expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('search=created'), expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('page=2'), expect.any(Object));
+        });
+    });
+    describe('listAuditLogs', () => {
+        it('should return only logs array', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    logs: [mockAuditLog],
+                    pagination: {},
+                    actors: [],
+                }),
+            });
+            const logs = await client.listAuditLogs();
+            expect(logs).toEqual([mockAuditLog]);
+        });
+    });
+    describe('getLogsByResourceType', () => {
+        it('should filter logs by resource type', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    logs: [mockAuditLog],
+                    pagination: {},
+                    actors: [],
+                }),
+            });
+            await client.getLogsByResourceType('Policy');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('resource_type=Policy'), expect.any(Object));
+        });
+    });
+    describe('getLogsByUser', () => {
+        it('should filter logs by user', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    logs: [mockAuditLog],
+                    pagination: {},
+                    actors: [],
+                }),
+            });
+            await client.getLogsByUser('user_123');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('user_id=user_123'), expect.any(Object));
+        });
+    });
+    describe('getLogsByDateRange', () => {
+        it('should filter logs by date range', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    logs: [mockAuditLog],
+                    pagination: {},
+                    actors: [],
+                }),
+            });
+            const startDate = new Date('2026-01-01');
+            const endDate = new Date('2026-01-31');
+            await client.getLogsByDateRange(startDate, endDate);
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('start_date='), expect.any(Object));
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('end_date='), expect.any(Object));
+        });
+    });
+    describe('searchAuditLogs', () => {
+        it('should search logs by term', async () => {
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    logs: [mockAuditLog],
+                    pagination: {},
+                    actors: [],
+                }),
+            });
+            await client.searchAuditLogs('policy.created');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('search=policy.created'), expect.any(Object));
+        });
+    });
+    describe('getAuditLogActors', () => {
+        it('should return list of actors', async () => {
+            const actors = [
+                { id: 'user_1', email: 'admin@example.com' },
+                { id: 'user_2', email: 'user@example.com' },
+            ];
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    logs: [],
+                    pagination: {},
+                    actors,
+                }),
+            });
+            const result = await client.getAuditLogActors();
+            expect(result).toEqual(actors);
+        });
+    });
+});