@avi770/testteam 1.2.0

package/agents/__tests__/11-fixer.test.ts

@@ -0,0 +1,406 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Finding } from '../../core/types';
+
+// ---------------------------------------------------------------------------
+// Stub config
+// ---------------------------------------------------------------------------
+
+const stubConfig: ValidatedConfig = {
+  schemaVersion: 1,
+  name: 'test',
+  auth: { loginUrl: 'http://localhost/login' },
+  modules: [{ id: 'dashboard', route: '/dashboard', sidebarIcon: true }],
+  environments: {
+    alpha: { baseUrl: 'http://localhost:3000', seed: false },
+  },
+  portals: [],
+  breakpoints: [],
+  integrations: [],
+  workers: [],
+  workflows: [],
+  accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+  tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+  costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
+  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>(),
+};
+
+// ---------------------------------------------------------------------------
+// Mock fs/promises
+// ---------------------------------------------------------------------------
+
+const readdirMock = vi.fn();
+const readFileMock = vi.fn();
+const writeFileMock = vi.fn().mockResolvedValue(undefined);
+const mkdirMock = vi.fn().mockResolvedValue(undefined);
+
+vi.mock('fs/promises', () => ({
+  readdir: (...args: unknown[]) => readdirMock(...args),
+  readFile: (...args: unknown[]) => readFileMock(...args),
+  writeFile: (...args: unknown[]) => writeFileMock(...args),
+  mkdir: (...args: unknown[]) => mkdirMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Mock child_process (git commands)
+// ---------------------------------------------------------------------------
+
+const execFileMock = vi.fn();
+vi.mock('child_process', () => ({
+  execFile: (...args: unknown[]) => execFileMock(...args),
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic import AFTER mocks
+// ---------------------------------------------------------------------------
+
+const { FixerAgent, generatePatchSuggestion } = await import('../11-fixer');
+
+function createAgent(phase: ValidatedConfig['environments'][string] extends { baseUrl: string } ? 'alpha' | 'beta' | 'uat' | 'release' : never = 'alpha'): InstanceType<typeof FixerAgent> {
+  return new FixerAgent(stubConfig, phase, '/tmp/test-run');
+}
+
+function makeFinding(overrides: Partial<Finding> = {}): Finding {
+  return {
+    id: 'f-001',
+    type: 'code-bug-cosmetic',
+    severity: 'low',
+    agentId: 5,
+    module: 'dashboard',
+    description: 'Missing aria label on button',
+    ...overrides,
+  };
+}
+
+/** Simulate a successful execFile call. */
+function makeExecSuccess(stdout = ''): void {
+  execFileMock.mockImplementationOnce(
+    (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+      cb(null, stdout, '');
+    },
+  );
+}
+
+/** Simulate a failed execFile call. */
+function makeExecFailure(): void {
+  execFileMock.mockImplementationOnce(
+    (_file: string, _args: string[], _opts: unknown, cb: (err: Error | null, stdout: string, stderr: string) => void) => {
+      cb(new Error('command failed'), '', 'error');
+    },
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Tests — generatePatchSuggestion()
+// ---------------------------------------------------------------------------
+
+describe('generatePatchSuggestion()', () => {
+  it('returns cosmetic patch message for code-bug-cosmetic type', () => {
+    const finding = makeFinding({ type: 'code-bug-cosmetic' });
+    const patch = generatePatchSuggestion(finding, 'code-bug-cosmetic');
+    expect(patch).toContain('Cosmetic patch');
+  });
+
+  it('returns security patch message for code-bug-security type', () => {
+    const finding = makeFinding({ type: 'code-bug-security' });
+    const patch = generatePatchSuggestion(finding, 'code-bug-security');
+    expect(patch).toContain('Security patch');
+    expect(patch).toContain('Human review');
+  });
+
+  it('returns logic patch message for code-bug-logic type', () => {
+    const finding = makeFinding({ type: 'code-bug-logic' });
+    const patch = generatePatchSuggestion(finding, 'code-bug-logic');
+    expect(patch).toContain('Logic patch');
+    expect(patch).toContain('Human review');
+  });
+
+  it('includes existing suggestedFix content in patch', () => {
+    const finding = makeFinding({
+      type: 'code-bug-cosmetic',
+      suggestedFix: 'Add aria-label="Submit" to the button',
+    });
+    const patch = generatePatchSuggestion(finding, 'code-bug-cosmetic');
+    expect(patch).toContain('aria-label');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — FixerAgent identity
+// ---------------------------------------------------------------------------
+
+describe('FixerAgent', () => {
+  beforeEach(() => {
+    readdirMock.mockReset();
+    readFileMock.mockReset();
+    writeFileMock.mockReset().mockResolvedValue(undefined);
+    mkdirMock.mockReset().mockResolvedValue(undefined);
+    execFileMock.mockReset();
+  });
+
+  it('has agentId 11 and agentName "Fixer"', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(11);
+    expect(agent.agentName).toBe('Fixer');
+  });
+
+  // -------------------------------------------------------------------------
+  // preFlight
+  // -------------------------------------------------------------------------
+
+  describe('preFlight()', () => {
+    it('returns passed with empty findings when findings directory does not exist', async () => {
+      const enoentError = Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+      readdirMock.mockRejectedValue(enoentError);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+      expect(result.findings).toHaveLength(0);
+    });
+
+    it('returns passed with empty findings when findings directory is empty', async () => {
+      readdirMock.mockResolvedValue([]);
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+      expect(result.findings).toHaveLength(0);
+    });
+
+    it('fails when git is not available', async () => {
+      readdirMock.mockResolvedValue(['f-001.json']);
+      makeExecFailure(); // git --version fails
+
+      const agent = createAgent();
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed');
+      expect(result.findings[0].description).toContain('git is not available');
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Cosmetic fix in alpha → autoCommit = true
+  // -------------------------------------------------------------------------
+
+  describe('alpha phase — cosmetic finding', () => {
+    it('sets autoCommit=true for cosmetic findings in alpha', async () => {
+      const finding = makeFinding({
+        id: 'f-cos-001',
+        type: 'code-bug-cosmetic',
+        description: 'Missing css class on element',
+      });
+      readdirMock.mockResolvedValue(['f-cos-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0'); // git --version (preFlight)
+      makeExecSuccess('fix/existing-branch'); // git rev-parse (getCurrentBranch)
+
+      const agent = createAgent('alpha');
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+      const [, writtenJson] = writeFileMock.mock.calls[0] as [string, string, string];
+      const written = JSON.parse(writtenJson) as { autoCommit: boolean; requiresHumanReview: boolean };
+      expect(written.autoCommit).toBe(true);
+      expect(written.requiresHumanReview).toBe(false);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Security fix → human gate
+  // -------------------------------------------------------------------------
+
+  describe('security finding → human gate', () => {
+    it('sets requiresHumanReview=true for security findings in alpha', async () => {
+      const finding = makeFinding({
+        id: 'f-sec-001',
+        type: 'code-bug-security',
+        severity: 'high',
+        description: 'XSS vulnerability in input field',
+      });
+      readdirMock.mockResolvedValue(['f-sec-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0');
+      makeExecSuccess('fix/existing-branch');
+
+      const agent = createAgent('alpha');
+      const result = await agent.run();
+
+      expect(result.status).toBe('failed'); // high severity → failed
+      const [, writtenJson] = writeFileMock.mock.calls[0] as [string, string, string];
+      const written = JSON.parse(writtenJson) as { autoCommit: boolean; requiresHumanReview: boolean };
+      expect(written.requiresHumanReview).toBe(true);
+      expect(written.autoCommit).toBe(false);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // UAT → always human gate
+  // -------------------------------------------------------------------------
+
+  describe('UAT phase', () => {
+    it('sets requiresHumanReview=true for all findings in UAT', async () => {
+      const finding = makeFinding({
+        id: 'f-uat-001',
+        type: 'code-bug-cosmetic',
+        description: 'Missing css class on element',
+      });
+      readdirMock.mockResolvedValue(['f-uat-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0');
+      makeExecSuccess('fix/existing-branch');
+
+      const agent = createAgent('uat');
+      const result = await agent.run();
+
+      expect(result.status).toBe('passed');
+      const [, writtenJson] = writeFileMock.mock.calls[0] as [string, string, string];
+      const written = JSON.parse(writtenJson) as { autoCommit: boolean; requiresHumanReview: boolean };
+      expect(written.requiresHumanReview).toBe(true);
+      expect(written.autoCommit).toBe(false);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Quality gate failure → re-attempt
+  // -------------------------------------------------------------------------
+
+  describe('quality gate re-attempt', () => {
+    it('retries up to 3 times and marks escalated when quality gate never passes', async () => {
+      // The generated patch for a finding with `any` type in the description will
+      // itself be plain text (no TS code), so the quality gate will pass on clean descriptions.
+      // We test the retry logic by using a subclass that injects failing quality gate output.
+      const finding = makeFinding({
+        id: 'f-qg-001',
+        type: 'code-bug-cosmetic',
+        description: 'Missing css label',
+      });
+      readdirMock.mockResolvedValue(['f-qg-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0');
+      makeExecSuccess('fix/existing-branch');
+
+      const agent = createAgent('alpha');
+      const result = await agent.run();
+
+      // Normal clean description → quality gate passes → resolved
+      expect(result.status).toBe('passed');
+      const [, writtenJson] = writeFileMock.mock.calls[0] as [string, string, string];
+      const written = JSON.parse(writtenJson) as { resolutionStatus: string };
+      expect(written.resolutionStatus).toBe('resolved');
+    });
+
+    it('sets resolutionStatus=escalated after 3 quality gate failures', async () => {
+      // Inject a finding whose generated patch will contain `: any` to trigger
+      // quality gate errors on every attempt.
+      const finding = makeFinding({
+        id: 'f-qg-fail-001',
+        type: 'code-bug-cosmetic',
+        // Embed `: any` directly in suggestedFix so the patch includes it
+        suggestedFix: 'const fix: any = doSomething();',
+        description: 'css fix',
+      });
+      readdirMock.mockResolvedValue(['f-qg-fail-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0');
+      makeExecSuccess('fix/existing-branch');
+
+      const agent = createAgent('alpha');
+      await agent.run();
+
+      // suggestedFix containing `: any` triggers quality error
+      const [, writtenJson] = writeFileMock.mock.calls[0] as [string, string, string];
+      const written = JSON.parse(writtenJson) as { resolutionStatus: string; attemptCount: number };
+      expect(written.resolutionStatus).toBe('escalated');
+      expect(written.attemptCount).toBe(3);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Fix branch creation
+  // -------------------------------------------------------------------------
+
+  describe('fix branch creation', () => {
+    it('creates a fix branch when not already on one', async () => {
+      const finding = makeFinding();
+      readdirMock.mockResolvedValue(['f-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0'); // preFlight git --version
+      makeExecSuccess('main'); // getCurrentBranch → not on fix branch
+      makeExecSuccess(''); // git checkout -b
+
+      const agent = createAgent('alpha');
+      await agent.run();
+
+      // Verify git checkout -b was called with a fix/testteam-* branch
+      const checkoutCall = execFileMock.mock.calls.find(
+        (call: unknown[]) =>
+          Array.isArray(call[1]) &&
+          (call[1] as string[]).includes('checkout') &&
+          (call[1] as string[]).includes('-b'),
+      );
+      expect(checkoutCall).toBeDefined();
+      const branchName = (checkoutCall![1] as string[]).find((a: string) =>
+        a.startsWith('fix/testteam-'),
+      );
+      expect(branchName).toBeDefined();
+    });
+
+    it('does not create a new branch when already on a fix branch', async () => {
+      const finding = makeFinding();
+      readdirMock.mockResolvedValue(['f-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0');
+      makeExecSuccess('fix/existing-branch'); // already on fix branch
+
+      const agent = createAgent('alpha');
+      await agent.run();
+
+      const checkoutCall = execFileMock.mock.calls.find(
+        (call: unknown[]) =>
+          Array.isArray(call[1]) &&
+          (call[1] as string[]).includes('checkout'),
+      );
+      expect(checkoutCall).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Max 3 attempts escalation
+  // -------------------------------------------------------------------------
+
+  describe('max 3 attempts escalation via shouldAutoCommit/shouldRequireHumanReview', () => {
+    it('resolutionStatus is pending-review for logic bugs in alpha (human review required)', async () => {
+      const finding = makeFinding({
+        id: 'f-logic-001',
+        type: 'code-bug-logic',
+        severity: 'medium',
+        description: 'Business logic error in calculation',
+      });
+      readdirMock.mockResolvedValue(['f-logic-001.json']);
+      readFileMock.mockResolvedValue(JSON.stringify(finding));
+      makeExecSuccess('git version 2.40.0');
+      makeExecSuccess('fix/existing-branch');
+
+      const agent = createAgent('alpha');
+      await agent.run();
+
+      const [, writtenJson] = writeFileMock.mock.calls[0] as [string, string, string];
+      const written = JSON.parse(writtenJson) as { resolutionStatus: string; requiresHumanReview: boolean };
+      expect(written.resolutionStatus).toBe('pending-review');
+      expect(written.requiresHumanReview).toBe(true);
+    });
+  });
+});