@avi770/testteam 3.0.0 → 3.2.0

package/core/__tests__/evidence.test.ts

@@ -1,265 +0,0 @@
-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

@@ -1,210 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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');
-  });
-});