@avi770/testteam 1.2.0

package/agents/__tests__/14-data-integrity-auditor.test.ts

@@ -0,0 +1,407 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+const stubConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: {
+    loginUrl: 'http://localhost/login',
+    credentials: { admin: { email: 'admin@test.com', password: 'secret' } },
+  },
+  modules: [{ id: 'clients', route: '/clients', sidebarIcon: true }],
+  environments: {
+    beta: { baseUrl: 'http://localhost:3000', seed: false },
+  },
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: true, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' as const },
+  agentClassification: { blocking: [], advisory: [] },
+  thresholds: {
+    unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 },
+    lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 },
+    apiResponseTime: 2000,
+    bundleSizeLimit: 500000,
+    maxConsoleErrors: 0,
+  },
+  disabledAgents: [],
+  disabledAgentSet: new Set<number>(),
+} satisfies ValidatedConfig;
+
+const stubConfigAccuracyDisabled: ValidatedConfig = {
+  ...stubConfig,
+  accuracy: { ...stubConfig.accuracy, enabled: false },
+};
+
+// ---------------------------------------------------------------------------
+// Mock fetch (used in preFlight isUrlReachable)
+// ---------------------------------------------------------------------------
+
+const fetchMock = vi.fn();
+vi.stubGlobal('fetch', fetchMock);
+
+// ---------------------------------------------------------------------------
+// Mock ApiClient
+// ---------------------------------------------------------------------------
+
+type MockApiResponse = { status: number; body: unknown; headers: Record<string, string>; durationMs: number };
+
+interface MockApiClientInstance {
+  get: ReturnType<typeof vi.fn>;
+  post: ReturnType<typeof vi.fn>;
+  put: ReturnType<typeof vi.fn>;
+  delete: ReturnType<typeof vi.fn>;
+}
+
+const mockApiClientInstance: MockApiClientInstance = {
+  get: vi.fn(),
+  post: vi.fn(),
+  put: vi.fn(),
+  delete: vi.fn(),
+};
+
+const createAuthenticatedMock = vi.fn().mockResolvedValue(mockApiClientInstance);
+
+vi.mock('../../helpers/api-client', () => ({
+  ApiClient: {
+    createAuthenticated: (...args: unknown[]) => createAuthenticatedMock(...args),
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Helper to build mock API responses
+// ---------------------------------------------------------------------------
+
+function ok(body: unknown): MockApiResponse {
+  return { status: 200, body, headers: {}, durationMs: 10 };
+}
+
+function created(body: unknown): MockApiResponse {
+  return { status: 201, body, headers: {}, durationMs: 10 };
+}
+
+function noContent(): MockApiResponse {
+  return { status: 204, body: null, headers: {}, durationMs: 10 };
+}
+
+function notFound(): MockApiResponse {
+  return { status: 404, body: { message: 'Not Found' }, headers: {}, durationMs: 10 };
+}
+
+function serverError(): MockApiResponse {
+  return { status: 500, body: { message: 'Error' }, headers: {}, durationMs: 10 };
+}
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { DataIntegrityAuditorAgent } = await import('../14-data-integrity-auditor');
+
+function createAgent(
+  config: ValidatedConfig = stubConfig,
+  phase: Phase = 'beta',
+): InstanceType<typeof DataIntegrityAuditorAgent> {
+  return new DataIntegrityAuditorAgent(config, phase, '/tmp/test-run');
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('DataIntegrityAuditorAgent', () => {
+  beforeEach(() => {
+    fetchMock.mockReset().mockResolvedValue({ ok: true, status: 200 });
+    createAuthenticatedMock.mockReset().mockResolvedValue(mockApiClientInstance);
+    mockApiClientInstance.get.mockReset();
+    mockApiClientInstance.post.mockReset();
+    mockApiClientInstance.put.mockReset();
+    mockApiClientInstance.delete.mockReset();
+
+    // Default happy-path CRUD responses
+    const clientRecord = {
+      id: 'test-id-123',
+      name: 'TF-DataIntegrity-Test',
+      email: 'tf-integrity-test@test.invalid',
+    };
+
+    mockApiClientInstance.post.mockResolvedValue(created(clientRecord));
+    mockApiClientInstance.get.mockResolvedValue(ok(clientRecord));
+    mockApiClientInstance.put.mockResolvedValue(ok({ ...clientRecord, name: 'TF-DataIntegrity-Updated' }));
+    mockApiClientInstance.delete.mockResolvedValue(noContent());
+  });
+
+  it('has agentId 14 and agentName "Data Integrity Auditor"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(14);
+    expect(agent.agentName).toBe('Data Integrity Auditor');
+  });
+
+  // -------------------------------------------------------------------------
+  // preFlight()
+  // -------------------------------------------------------------------------
+
+  describe('preFlight()', () => {
+    it('throws when accuracy.enabled is false', async () => {
+      const agent = createAgent(stubConfigAccuracyDisabled);
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+      expect(result.findings[0].description).toContain('accuracy.enabled is false');
+    });
+
+    it('throws when base URL is not reachable', async () => {
+      fetchMock.mockRejectedValue(new Error('ECONNREFUSED'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+      expect(result.findings[0].description).toContain('not reachable');
+    });
+
+    it('passes when accuracy enabled and URL reachable', async () => {
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings.some((f) => f.description.includes('accuracy.enabled'))).toBe(false);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // CRUD round-trip
+  // -------------------------------------------------------------------------
+
+  describe('CRUD round-trip', () => {
+    it('returns no findings when create→read fields match', async () => {
+      // The agent generates a unique email using Date.now() so we capture the
+      // post body and echo it back in the get response to ensure fields match.
+      let capturedCreateBody: Record<string, unknown> = {};
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        capturedCreateBody = body as Record<string, unknown>;
+        return created({ id: 'abc-123', ...capturedCreateBody, createdAt: '2026-03-27T10:00:00Z' });
+      });
+
+      let getCallCount = 0;
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCallCount++;
+        if (getCallCount === 1) {
+          // read after create — echo back captured body
+          return ok({ id: 'abc-123', ...capturedCreateBody, createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (getCallCount === 2) {
+          // read after update — return updated name
+          return ok({ id: 'abc-123', ...capturedCreateBody, name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        }
+        // read after delete — 404
+        return notFound();
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(
+        ok({ id: 'abc-123', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' }),
+      );
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.findings).toHaveLength(0);
+      expect(result.status).toBe('passed');
+    });
+
+    it('creates a finding when read returns mismatched name field', async () => {
+      const created_record = {
+        id: 'abc-123',
+        name: 'TF-DataIntegrity-Test',
+        email: 'tf-integrity-test@test.invalid',
+        createdAt: '2026-03-27T10:00:00Z',
+      };
+
+      const mismatched_record = {
+        ...created_record,
+        name: 'WRONG-NAME', // mismatch!
+      };
+
+      mockApiClientInstance.post
+        .mockResolvedValueOnce(created(created_record))
+        .mockResolvedValue(serverError());
+
+      mockApiClientInstance.get
+        .mockResolvedValueOnce(ok(mismatched_record))
+        .mockResolvedValue(ok({ ...mismatched_record, name: 'TF-DataIntegrity-Updated' }));
+
+      mockApiClientInstance.put.mockResolvedValueOnce(ok({ ...mismatched_record }));
+      mockApiClientInstance.delete.mockResolvedValueOnce(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const mismatchFinding = result.findings.find((f) => f.id.includes('crud-field-mismatch'));
+      expect(mismatchFinding).toBeDefined();
+      expect(mismatchFinding!.severity).toBe('high');
+      expect(mismatchFinding!.description).toContain('name');
+    });
+
+    it('creates a finding when resource is still accessible after DELETE', async () => {
+      const clientRecord = {
+        id: 'abc-123',
+        name: 'TF-DataIntegrity-Test',
+        email: 'tf-integrity-test@test.invalid',
+        createdAt: '2026-03-27T10:00:00Z',
+      };
+
+      mockApiClientInstance.post
+        .mockResolvedValueOnce(created(clientRecord))
+        .mockResolvedValue(serverError());
+
+      mockApiClientInstance.get
+        .mockResolvedValueOnce(ok(clientRecord))                                            // read after create
+        .mockResolvedValueOnce(ok({ ...clientRecord, name: 'TF-DataIntegrity-Updated' }))  // read after update
+        .mockResolvedValueOnce(ok(clientRecord));                                           // still accessible after delete!
+
+      mockApiClientInstance.put.mockResolvedValueOnce(ok({ ...clientRecord, name: 'TF-DataIntegrity-Updated' }));
+      mockApiClientInstance.delete.mockResolvedValueOnce(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const deleteFinding = result.findings.find((f) => f.id.includes('crud-delete-verify'));
+      expect(deleteFinding).toBeDefined();
+      expect(deleteFinding!.severity).toBe('high');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Decimal precision
+  // -------------------------------------------------------------------------
+
+  describe('decimal precision', () => {
+    it('creates a finding when decimal drift is detected', async () => {
+      // Capture post bodies to echo fields back with correct email.
+      let crudCaptured: Record<string, unknown> = {};
+      let decimalCaptured: Record<string, unknown> = {};
+      let postCallCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        const b = body as Record<string, unknown>;
+        postCallCount++;
+        if (postCallCount === 1) {
+          // CRUD create
+          crudCaptured = b;
+          return created({ id: 'crud-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (postCallCount === 2) {
+          // Decimal create
+          decimalCaptured = b;
+          return created({ id: 'decimal-id', ...b });
+        }
+        // tz → skip
+        return serverError();
+      });
+
+      let getCallCount = 0;
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCallCount++;
+        if (getCallCount === 1) {
+          return ok({ id: 'crud-id', ...crudCaptured, createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (getCallCount === 2) {
+          return ok({ id: 'crud-id', ...crudCaptured, name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (getCallCount === 3) {
+          return notFound(); // after delete
+        }
+        // decimal read — return drifted amount (1000.1 rounds to 1000.10, not 1000.11)
+        return ok({ id: 'decimal-id', ...decimalCaptured, amount: 1000.1 });
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(
+        ok({ id: 'crud-id', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' }),
+      );
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const decimalFinding = result.findings.find((f) => f.id.includes('decimal-drift'));
+      expect(decimalFinding).toBeDefined();
+      expect(decimalFinding!.severity).toBe('high');
+      expect(decimalFinding!.description).toContain('1000.105');
+    });
+
+    it('does NOT create a finding when amount is stored with correct precision', async () => {
+      let crudCaptured: Record<string, unknown> = {};
+      let decimalCaptured: Record<string, unknown> = {};
+      let postCallCount = 0;
+
+      mockApiClientInstance.post.mockImplementation(async (_path: string, body: unknown) => {
+        const b = body as Record<string, unknown>;
+        postCallCount++;
+        if (postCallCount === 1) {
+          crudCaptured = b;
+          return created({ id: 'crud-id', ...b, createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (postCallCount === 2) {
+          decimalCaptured = b;
+          return created({ id: 'decimal-id', ...b });
+        }
+        return serverError();
+      });
+
+      let getCallCount = 0;
+      mockApiClientInstance.get.mockImplementation(async () => {
+        getCallCount++;
+        if (getCallCount === 1) {
+          return ok({ id: 'crud-id', ...crudCaptured, createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (getCallCount === 2) {
+          return ok({ id: 'crud-id', ...crudCaptured, name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' });
+        }
+        if (getCallCount === 3) {
+          return notFound();
+        }
+        // Decimal read — correctly rounded to 2 decimal places
+        return ok({ id: 'decimal-id', ...decimalCaptured, amount: 1000.11 });
+      });
+
+      mockApiClientInstance.put.mockResolvedValue(
+        ok({ id: 'crud-id', name: 'TF-DataIntegrity-Updated', createdAt: '2026-03-27T10:00:00Z' }),
+      );
+      mockApiClientInstance.delete.mockResolvedValue(noContent());
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      const decimalFindings = result.findings.filter((f) => f.id.includes('decimal-drift'));
+      expect(decimalFindings).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Authentication failure
+  // -------------------------------------------------------------------------
+
+  describe('authentication failure', () => {
+    it('creates a medium finding when authentication fails', async () => {
+      createAuthenticatedMock.mockRejectedValueOnce(new Error('401 Unauthorized'));
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed'); // medium severity doesn't trigger failure
+      const authFinding = result.findings.find((f) => f.id === '14-auth-failed');
+      expect(authFinding).toBeDefined();
+      expect(authFinding!.severity).toBe('medium');
+    });
+  });
+});