@avi770/testteam 1.2.0

package/core/__tests__/evidence.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  initRunDirectory,
+  writeAgentResult,
+  readAgentResult,
+  writeFinding,
+  archivePhaseResults,
+} from '../evidence';
+import type { AgentResult, Finding } from '../types';
+
+let tempDir: string;
+
+beforeEach(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'tf-evidence-test-'));
+});
+
+afterEach(async () => {
+  await fs.rm(tempDir, { recursive: true, force: true });
+});
+
+function makeRunDir(runId: string): string {
+  return path.join(tempDir, '.run', runId);
+}
+
+function makeAgentResult(overrides: Partial<AgentResult> = {}): AgentResult {
+  return {
+    agentId: 1,
+    agentName: 'test-agent',
+    phase: 'alpha',
+    status: 'passed',
+    startedAt: new Date().toISOString(),
+    completedAt: new Date().toISOString(),
+    durationMs: 1000,
+    findings: [],
+    evidence: [],
+    summary: 'All good',
+    ...overrides,
+  };
+}
+
+function makeFinding(overrides: Partial<Finding> = {}): Finding {
+  return {
+    id: 'f-001',
+    type: 'test-bug',
+    severity: 'low',
+    agentId: 1,
+    module: 'home',
+    description: 'A test finding',
+    ...overrides,
+  };
+}
+
+describe('initRunDirectory', () => {
+  it('creates the run directory structure', async () => {
+    const runId = 'run-abc123';
+    const runDir = makeRunDir(runId);
+
+    await initRunDirectory(runDir);
+
+    const expectedDirs = [
+      'agent-results',
+      'findings/test-bugs',
+      'findings/code-bugs',
+      'evidence/screenshots',
+      'evidence/logs',
+      'evidence/reports',
+    ];
+
+    for (const dir of expectedDirs) {
+      const stat = await fs.stat(path.join(runDir, dir));
+      expect(stat.isDirectory()).toBe(true);
+    }
+  });
+
+  it('is idempotent — calling twice does not throw', async () => {
+    const runDir = makeRunDir('run-idem');
+    await initRunDirectory(runDir);
+    await expect(initRunDirectory(runDir)).resolves.toBeUndefined();
+  });
+});
+
+describe('writeAgentResult', () => {
+  it('writes JSON file to agent-results/{agentId}.json', async () => {
+    const runDir = makeRunDir('run-write');
+    await initRunDirectory(runDir);
+
+    const result = makeAgentResult({ agentId: 7, agentName: 'agent-seven' });
+    await writeAgentResult(runDir, 7, result);
+
+    const filePath = path.join(runDir, 'agent-results', '7.json');
+    const stat = await fs.stat(filePath);
+    expect(stat.isFile()).toBe(true);
+  });
+
+  it('writes valid JSON that round-trips cleanly', async () => {
+    const runDir = makeRunDir('run-json');
+    await initRunDirectory(runDir);
+
+    const result = makeAgentResult({ agentId: 3 });
+    await writeAgentResult(runDir, 3, result);
+
+    const filePath = path.join(runDir, 'agent-results', '3.json');
+    const raw = await fs.readFile(filePath, 'utf-8');
+    const parsed = JSON.parse(raw) as AgentResult;
+    expect(parsed.agentId).toBe(3);
+    expect(parsed.agentName).toBe('test-agent');
+  });
+
+  it('creates agent-results directory lazily if not yet initialised', async () => {
+    const runDir = makeRunDir('run-lazy');
+    // Intentionally skip initRunDirectory
+
+    const result = makeAgentResult({ agentId: 5 });
+    await writeAgentResult(runDir, 5, result);
+
+    const filePath = path.join(runDir, 'agent-results', '5.json');
+    const stat = await fs.stat(filePath);
+    expect(stat.isFile()).toBe(true);
+  });
+});
+
+describe('readAgentResult', () => {
+  it('reads back a previously written result', async () => {
+    const runDir = makeRunDir('run-read');
+    await initRunDirectory(runDir);
+
+    const result = makeAgentResult({ agentId: 10, summary: 'Done' });
+    await writeAgentResult(runDir, 10, result);
+
+    const read = await readAgentResult(runDir, 10);
+    expect(read).not.toBeNull();
+    expect(read!.agentId).toBe(10);
+    expect(read!.summary).toBe('Done');
+  });
+
+  it('returns null when the file does not exist', async () => {
+    const runDir = makeRunDir('run-missing');
+    await initRunDirectory(runDir);
+
+    const read = await readAgentResult(runDir, 999);
+    expect(read).toBeNull();
+  });
+});
+
+describe('writeFinding', () => {
+  it('writes test-bug findings to findings/test-bugs/', async () => {
+    const runDir = makeRunDir('run-finding-tb');
+    await initRunDirectory(runDir);
+
+    const finding = makeFinding({ id: 'f-tb-01', type: 'test-bug' });
+    await writeFinding(runDir, finding);
+
+    const filePath = path.join(runDir, 'findings', 'test-bugs', 'f-tb-01.json');
+    const stat = await fs.stat(filePath);
+    expect(stat.isFile()).toBe(true);
+  });
+
+  it('writes code-bug-* findings to findings/code-bugs/', async () => {
+    const runDir = makeRunDir('run-finding-cb');
+    await initRunDirectory(runDir);
+
+    for (const type of ['code-bug-cosmetic', 'code-bug-logic', 'code-bug-security'] as const) {
+      const finding = makeFinding({ id: `f-${type}`, type });
+      await writeFinding(runDir, finding);
+
+      const filePath = path.join(runDir, 'findings', 'code-bugs', `f-${type}.json`);
+      const stat = await fs.stat(filePath);
+      expect(stat.isFile()).toBe(true);
+    }
+  });
+
+  it('writes infra-issue findings to findings/code-bugs/', async () => {
+    const runDir = makeRunDir('run-finding-infra');
+    await initRunDirectory(runDir);
+
+    const finding = makeFinding({ id: 'f-infra-01', type: 'infra-issue' });
+    await writeFinding(runDir, finding);
+
+    const filePath = path.join(runDir, 'findings', 'code-bugs', 'f-infra-01.json');
+    const stat = await fs.stat(filePath);
+    expect(stat.isFile()).toBe(true);
+  });
+
+  it('persists finding content as valid JSON', async () => {
+    const runDir = makeRunDir('run-finding-json');
+    await initRunDirectory(runDir);
+
+    const finding = makeFinding({ id: 'f-json-01', description: 'Button misaligned' });
+    await writeFinding(runDir, finding);
+
+    const filePath = path.join(runDir, 'findings', 'test-bugs', 'f-json-01.json');
+    const raw = await fs.readFile(filePath, 'utf-8');
+    const parsed = JSON.parse(raw) as Finding;
+    expect(parsed.description).toBe('Button misaligned');
+  });
+
+  it('creates target directory lazily if missing', async () => {
+    const runDir = makeRunDir('run-finding-lazy');
+    // Intentionally skip initRunDirectory
+
+    const finding = makeFinding({ id: 'f-lazy-01', type: 'test-bug' });
+    await writeFinding(runDir, finding);
+
+    const filePath = path.join(runDir, 'findings', 'test-bugs', 'f-lazy-01.json');
+    const stat = await fs.stat(filePath);
+    expect(stat.isFile()).toBe(true);
+  });
+});
+
+describe('archivePhaseResults', () => {
+  it('moves agent-results content to archive/attempt-{N}/', async () => {
+    const runDir = makeRunDir('run-archive');
+    await initRunDirectory(runDir);
+
+    const result = makeAgentResult({ agentId: 2 });
+    await writeAgentResult(runDir, 2, result);
+
+    await archivePhaseResults(runDir, 'alpha', 1);
+
+    const archivePath = path.join(runDir, 'archive', 'alpha-attempt-1', '2.json');
+    const stat = await fs.stat(archivePath);
+    expect(stat.isFile()).toBe(true);
+  });
+
+  it('clears agent-results after archiving', async () => {
+    const runDir = makeRunDir('run-archive-clear');
+    await initRunDirectory(runDir);
+
+    await writeAgentResult(runDir, 4, makeAgentResult({ agentId: 4 }));
+    await archivePhaseResults(runDir, 'alpha', 1);
+
+    const remaining = await fs.readdir(path.join(runDir, 'agent-results'));
+    expect(remaining).toHaveLength(0);
+  });
+
+  it('supports multiple attempts with separate archive dirs', async () => {
+    const runDir = makeRunDir('run-archive-multi');
+    await initRunDirectory(runDir);
+
+    await writeAgentResult(runDir, 1, makeAgentResult({ agentId: 1 }));
+    await archivePhaseResults(runDir, 'alpha', 1);
+
+    await writeAgentResult(runDir, 1, makeAgentResult({ agentId: 1, status: 'failed' }));
+    await archivePhaseResults(runDir, 'alpha', 2);
+
+    const attempt1 = path.join(runDir, 'archive', 'alpha-attempt-1', '1.json');
+    const attempt2 = path.join(runDir, 'archive', 'alpha-attempt-2', '1.json');
+
+    const raw1 = await fs.readFile(attempt1, 'utf-8');
+    const raw2 = await fs.readFile(attempt2, 'utf-8');
+
+    expect((JSON.parse(raw1) as AgentResult).status).toBe('passed');
+    expect((JSON.parse(raw2) as AgentResult).status).toBe('failed');
+  });
+
+  it('is a no-op when agent-results is empty', async () => {
+    const runDir = makeRunDir('run-archive-empty');
+    await initRunDirectory(runDir);
+
+    await expect(archivePhaseResults(runDir, 'beta', 1)).resolves.toBeUndefined();
+  });
+});

package/core/__tests__/fix-loop.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect } from 'vitest';
+import { classifyFinding, shouldAutoCommit, shouldRequireHumanReview } from '../fix-loop';
+import type { Finding, Phase } from '../types';
+
+function makeFinding(overrides: Partial<Finding> = {}): Finding {
+  return {
+    id: 'f-001',
+    type: 'code-bug-logic',
+    severity: 'medium',
+    agentId: 1,
+    module: 'home',
+    description: 'A test finding',
+    ...overrides,
+  };
+}
+
+describe('classifyFinding', () => {
+  describe('test-bug classification', () => {
+    it('returns test-bug when finding is in a test file and source is unchanged', () => {
+      const finding = makeFinding({ file: 'src/tests/auth.test.ts' });
+      const changedFiles: string[] = [];
+      expect(classifyFinding(finding, changedFiles)).toBe('test-bug');
+    });
+
+    it('returns test-bug when file path contains /tests/ and the test file itself is not in changedFiles', () => {
+      const finding = makeFinding({ file: 'packages/portal/tests/login.spec.ts' });
+      // changedFiles contains a source file, not the test file itself — test file is unchanged
+      const changedFiles = ['packages/portal/src/login.ts'];
+      expect(classifyFinding(finding, changedFiles)).toBe('test-bug');
+    });
+
+    it('does not return test-bug when the test file itself is in changedFiles', () => {
+      const finding = makeFinding({ file: 'packages/portal/tests/login.spec.ts' });
+      const changedFiles = ['packages/portal/tests/login.spec.ts'];
+      expect(classifyFinding(finding, changedFiles)).not.toBe('test-bug');
+    });
+
+    it('returns test-bug when file is in /tests/ and changedFiles is empty', () => {
+      const finding = makeFinding({ file: '/app/tests/utils.test.ts' });
+      expect(classifyFinding(finding, [])).toBe('test-bug');
+    });
+  });
+
+  describe('code-bug-security classification', () => {
+    it('returns code-bug-security when description contains "xss"', () => {
+      const finding = makeFinding({ description: 'Potential xss vulnerability found' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-security');
+    });
+
+    it('returns code-bug-security when description contains "injection"', () => {
+      const finding = makeFinding({ description: 'SQL injection detected in query builder' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-security');
+    });
+
+    it('returns code-bug-security when description contains "csrf"', () => {
+      const finding = makeFinding({ description: 'Missing csrf token on form submission' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-security');
+    });
+
+    it('returns code-bug-security when description contains "auth-bypass"', () => {
+      const finding = makeFinding({ description: 'auth-bypass possible via malformed JWT' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-security');
+    });
+
+    it('returns code-bug-security when description contains "exposure"', () => {
+      const finding = makeFinding({ description: 'Sensitive data exposure in API response' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-security');
+    });
+
+    it('returns code-bug-security for security keyword in non-test file', () => {
+      const finding = makeFinding({ file: 'src/auth/login.ts', description: 'xss risk in render' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-security');
+    });
+  });
+
+  describe('code-bug-cosmetic classification', () => {
+    it('returns code-bug-cosmetic when description contains "css"', () => {
+      const finding = makeFinding({ description: 'Incorrect css class applied to button' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-cosmetic');
+    });
+
+    it('returns code-bug-cosmetic when description contains "aria"', () => {
+      const finding = makeFinding({ description: 'Missing aria label on icon' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-cosmetic');
+    });
+
+    it('returns code-bug-cosmetic when description contains "i18n"', () => {
+      const finding = makeFinding({ description: 'i18n string missing for German locale' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-cosmetic');
+    });
+
+    it('returns code-bug-cosmetic when description contains "link"', () => {
+      const finding = makeFinding({ description: 'Broken link in footer navigation' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-cosmetic');
+    });
+
+    it('returns code-bug-cosmetic when description contains "alt-text"', () => {
+      const finding = makeFinding({ description: 'Image missing alt-text attribute' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-cosmetic');
+    });
+  });
+
+  describe('code-bug-logic classification (fallback)', () => {
+    it('returns code-bug-logic when no other classification matches', () => {
+      const finding = makeFinding({ description: 'Incorrect calculation in tax module' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-logic');
+    });
+
+    it('returns code-bug-logic when file is undefined and no keywords match', () => {
+      const finding = makeFinding({ file: undefined, description: 'Off-by-one error in pagination' });
+      expect(classifyFinding(finding, [])).toBe('code-bug-logic');
+    });
+  });
+});
+
+describe('shouldAutoCommit', () => {
+  describe('code-bug-cosmetic', () => {
+    it('returns true for code-bug-cosmetic in alpha phase', () => {
+      expect(shouldAutoCommit('code-bug-cosmetic', 'alpha')).toBe(true);
+    });
+
+    it('returns true for code-bug-cosmetic in beta phase', () => {
+      expect(shouldAutoCommit('code-bug-cosmetic', 'beta')).toBe(true);
+    });
+
+    it('returns false for code-bug-cosmetic in uat phase', () => {
+      expect(shouldAutoCommit('code-bug-cosmetic', 'uat')).toBe(false);
+    });
+
+    it('returns false for code-bug-cosmetic in release phase', () => {
+      expect(shouldAutoCommit('code-bug-cosmetic', 'release')).toBe(false);
+    });
+  });
+
+  describe('code-bug-logic', () => {
+    const phases: Phase[] = ['alpha', 'beta', 'uat', 'release'];
+
+    it.each(phases)('returns false for code-bug-logic in %s phase', (phase) => {
+      expect(shouldAutoCommit('code-bug-logic', phase)).toBe(false);
+    });
+  });
+
+  describe('code-bug-security', () => {
+    const phases: Phase[] = ['alpha', 'beta', 'uat', 'release'];
+
+    it.each(phases)('returns false for code-bug-security in %s phase', (phase) => {
+      expect(shouldAutoCommit('code-bug-security', phase)).toBe(false);
+    });
+  });
+
+  describe('test-bug', () => {
+    const phases: Phase[] = ['alpha', 'beta', 'uat', 'release'];
+
+    it.each(phases)('returns true for test-bug in %s phase', (phase) => {
+      expect(shouldAutoCommit('test-bug', phase)).toBe(true);
+    });
+  });
+});
+
+describe('shouldRequireHumanReview', () => {
+  describe('code-bug-security', () => {
+    const phases: Phase[] = ['alpha', 'beta', 'uat', 'release'];
+
+    it.each(phases)('returns true for code-bug-security in %s phase', (phase) => {
+      expect(shouldRequireHumanReview('code-bug-security', phase)).toBe(true);
+    });
+  });
+
+  describe('code-bug-logic', () => {
+    const phases: Phase[] = ['alpha', 'beta', 'uat', 'release'];
+
+    it.each(phases)('returns true for code-bug-logic in %s phase', (phase) => {
+      expect(shouldRequireHumanReview('code-bug-logic', phase)).toBe(true);
+    });
+  });
+
+  describe('uat phase override', () => {
+    it('returns true for code-bug-cosmetic in uat phase', () => {
+      expect(shouldRequireHumanReview('code-bug-cosmetic', 'uat')).toBe(true);
+    });
+
+    it('returns true for test-bug in uat phase', () => {
+      expect(shouldRequireHumanReview('test-bug', 'uat')).toBe(true);
+    });
+
+    it('returns true for infra-issue in uat phase', () => {
+      expect(shouldRequireHumanReview('infra-issue', 'uat')).toBe(true);
+    });
+  });
+
+  describe('code-bug-cosmetic in non-uat phases', () => {
+    it('returns false for code-bug-cosmetic in alpha phase', () => {
+      expect(shouldRequireHumanReview('code-bug-cosmetic', 'alpha')).toBe(false);
+    });
+
+    it('returns false for code-bug-cosmetic in beta phase', () => {
+      expect(shouldRequireHumanReview('code-bug-cosmetic', 'beta')).toBe(false);
+    });
+  });
+
+  describe('test-bug in non-uat phases', () => {
+    it('returns false for test-bug in alpha phase', () => {
+      expect(shouldRequireHumanReview('test-bug', 'alpha')).toBe(false);
+    });
+
+    it('returns false for test-bug in beta phase', () => {
+      expect(shouldRequireHumanReview('test-bug', 'beta')).toBe(false);
+    });
+  });
+});

package/core/__tests__/health-check.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from 'vitest';
+import { runHealthChecks } from '../health-check';
+
+describe('Health Checks', () => {
+  it('returns pass when all required checks succeed', async () => {
+    const results = await runHealthChecks({
+      checks: [
+        { name: 'node', check: async () => true, required: true },
+      ],
+    });
+    expect(results.canProceed).toBe(true);
+    expect(results.results[0].passed).toBe(true);
+  });
+
+  it('returns fail when a required check fails', async () => {
+    const results = await runHealthChecks({
+      checks: [
+        { name: 'db', check: async () => false, required: true },
+      ],
+    });
+    expect(results.canProceed).toBe(false);
+  });
+
+  it('returns pass with warning when optional check fails', async () => {
+    const results = await runHealthChecks({
+      checks: [
+        { name: 'node', check: async () => true, required: true },
+        { name: 'docker', check: async () => false, required: false },
+      ],
+    });
+    expect(results.canProceed).toBe(true);
+    expect(results.warnings).toHaveLength(1);
+  });
+
+  it('handles check that throws as failure', async () => {
+    const results = await runHealthChecks({
+      checks: [
+        { name: 'crash', check: async () => { throw new Error('boom'); }, required: true },
+      ],
+    });
+    expect(results.canProceed).toBe(false);
+    expect(results.results[0].error).toBe('boom');
+  });
+});