@avi770/testteam 1.2.0

package/core/__tests__/cli.test.ts

@@ -0,0 +1,387 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { join } from 'path';
+import { writeFileSync, mkdirSync, rmSync, existsSync } from 'fs';
+
+// ── Shared mock state ──────────────────────────────────────────────────────
+
+const mockDryRun = vi.fn();
+const mockRunPhase = vi.fn();
+const mockRunInitWizard = vi.fn();
+
+// ── Module mocks ───────────────────────────────────────────────────────────
+
+vi.mock('../init', () => ({
+  runInitWizard: (...args: unknown[]) => mockRunInitWizard(...args),
+}));
+
+vi.mock('../config', () => ({
+  validateConfig: vi.fn((c: unknown) => ({
+    ...(c as Record<string, unknown>),
+    disabledAgentSet: new Set(),
+  })),
+}));
+
+vi.mock('../orchestrator', () => {
+  return {
+    Orchestrator: class MockOrchestrator {
+      dryRun(...args: unknown[]) { return mockDryRun(...args); }
+      runPhase(...args: unknown[]) { return mockRunPhase(...args); }
+    },
+  };
+});
+
+vi.mock('../../agents/registry', () => ({
+  registerAllAgents: vi.fn(),
+}));
+
+vi.mock('../ci-output', () => ({
+  determineExitCode: vi.fn().mockReturnValue(0),
+  writeCISummary: vi.fn(),
+  detectCIEnvironment: vi.fn().mockReturnValue('none'),
+  EXIT_CODE: { SUCCESS: 0, BLOCKING_FAILURE: 1, ADVISORY_WARNINGS: 2 },
+}));
+
+import { parseArgs, main } from '../cli';
+import { determineExitCode, detectCIEnvironment, writeCISummary } from '../ci-output';
+
+// ── Create a temp config file that dynamic import() can actually load ──────
+
+const TEMP_DIR = join(__dirname, '__temp_cli_test__');
+let TEMP_CONFIG = '';
+let configCounter = 0;
+
+function ensureTempConfig(): void {
+  if (!existsSync(TEMP_DIR)) {
+    mkdirSync(TEMP_DIR, { recursive: true });
+  }
+  // Use a unique filename per test to bust Node's ESM import cache
+  configCounter++;
+  TEMP_CONFIG = join(TEMP_DIR, `test-${configCounter}-${Date.now()}.config.mjs`);
+  writeFileSync(
+    TEMP_CONFIG,
+    `export default {
+      schemaVersion: 1,
+      name: 'test',
+      modules: [{ id: 'home', route: '/', sidebarIcon: true }],
+      environments: { alpha: { baseUrl: 'http://localhost:3000' } },
+      auth: { credentials: {}, roles: [] },
+    };`,
+    'utf-8',
+  );
+}
+
+function cleanupTempConfig(): void {
+  try {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  } catch {
+    // ignore cleanup errors
+  }
+}
+
+// Default mock implementations — re-applied each test since clearAllMocks resets them
+function setupDefaultMocks(): void {
+  mockRunInitWizard.mockResolvedValue(0);
+  mockDryRun.mockReturnValue([
+    { agentId: 1, status: 'scheduled' },
+  ]);
+  mockRunPhase.mockResolvedValue({
+    skippedAgents: [],
+    agentResults: { 1: { agentId: 1, status: 'passed' } },
+    gate: { passed: true, failedBlockingAgents: [] },
+  });
+  // These are defined via vi.mock factory but clearAllMocks resets them
+  vi.mocked(determineExitCode).mockReturnValue(0);
+  vi.mocked(detectCIEnvironment).mockReturnValue('none');
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  setupDefaultMocks();
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  // Prevent the module-level auto-execution from calling process.exit
+  vi.spyOn(process, 'exit').mockImplementation((() => {}) as never);
+  ensureTempConfig();
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  cleanupTempConfig();
+});
+
+// Helper to build argv with our temp config
+function argv(...args: string[]): string[] {
+  return ['node', 'cli.ts', ...args, '--config', TEMP_CONFIG];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// parseArgs
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('parseArgs', () => {
+  it('parses --phase alpha', () => {
+    const result = parseArgs(['node', 'cli.ts', '--phase', 'alpha']);
+    expect(result.phase).toBe('alpha');
+    expect(result.dryRun).toBe(false);
+    expect(result.agent).toBeNull();
+  });
+
+  it('parses --phase beta', () => {
+    const result = parseArgs(['node', 'cli.ts', '--phase', 'beta']);
+    expect(result.phase).toBe('beta');
+  });
+
+  it('parses --phase uat', () => {
+    const result = parseArgs(['node', 'cli.ts', '--phase', 'uat']);
+    expect(result.phase).toBe('uat');
+  });
+
+  it('parses --phase release', () => {
+    const result = parseArgs(['node', 'cli.ts', '--phase', 'release']);
+    expect(result.phase).toBe('release');
+  });
+
+  it('parses --phase all', () => {
+    const result = parseArgs(['node', 'cli.ts', '--phase', 'all']);
+    expect(result.phase).toBe('all');
+  });
+
+  it('parses --dry-run flag', () => {
+    const result = parseArgs(['node', 'cli.ts', '--dry-run']);
+    expect(result.dryRun).toBe(true);
+  });
+
+  it('parses --agent flag with valid ID', () => {
+    const result = parseArgs(['node', 'cli.ts', '--agent', '5']);
+    expect(result.agent).toBe(5);
+  });
+
+  it('parses --config flag', () => {
+    const result = parseArgs(['node', 'cli.ts', '--config', 'custom.config.ts']);
+    expect(result.configPath).toBe('custom.config.ts');
+  });
+
+  it('parses combined flags', () => {
+    const result = parseArgs([
+      'node', 'cli.ts',
+      '--phase', 'alpha',
+      '--dry-run',
+      '--agent', '3',
+      '--config', 'my.config.ts',
+    ]);
+    expect(result.phase).toBe('alpha');
+    expect(result.dryRun).toBe(true);
+    expect(result.agent).toBe(3);
+    expect(result.configPath).toBe('my.config.ts');
+  });
+
+  it('defaults configPath to testteam.config.ts', () => {
+    const result = parseArgs(['node', 'cli.ts', '--phase', 'alpha']);
+    expect(result.configPath).toBe('testteam.config.ts');
+  });
+
+  it('defaults phase to null', () => {
+    const result = parseArgs(['node', 'cli.ts', '--dry-run']);
+    expect(result.phase).toBeNull();
+  });
+
+  // ── Error cases ─────────────────────────────────────────────────────
+
+  it('throws on invalid phase', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--phase', 'invalid']))
+      .toThrow('Invalid phase: invalid');
+  });
+
+  it('throws on missing phase value', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--phase']))
+      .toThrow('Invalid phase');
+  });
+
+  it('throws on invalid agent ID (non-number)', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--agent', 'abc']))
+      .toThrow('Invalid agent ID: abc');
+  });
+
+  it('throws on invalid agent ID (zero)', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--agent', '0']))
+      .toThrow('Invalid agent ID: 0');
+  });
+
+  it('throws on invalid agent ID (negative)', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--agent', '-1']))
+      .toThrow('Invalid agent ID: -1');
+  });
+
+  it('throws on missing agent value', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--agent']))
+      .toThrow('Invalid agent ID');
+  });
+
+  it('throws on missing config path', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--config']))
+      .toThrow('--config requires a path');
+  });
+
+  it('throws on unknown argument', () => {
+    expect(() => parseArgs(['node', 'cli.ts', '--unknown']))
+      .toThrow('Unknown argument: --unknown');
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// main
+// ═══════════════════════════════════════════════════════════════════════════
+
+describe('main', () => {
+  // ── Init command ──────────────────────────────────────────────────────
+
+  it('routes to init wizard when "init" is in args', async () => {
+    const code = await main(['node', 'cli.ts', 'init']);
+    expect(mockRunInitWizard).toHaveBeenCalled();
+    expect(code).toBe(0);
+  });
+
+  it('routes to init wizard when "--init" is in args', async () => {
+    const code = await main(['node', 'cli.ts', '--init']);
+    expect(mockRunInitWizard).toHaveBeenCalled();
+    expect(code).toBe(0);
+  });
+
+  // ── No arguments ──────────────────────────────────────────────────────
+
+  it('prints usage and returns 1 when no arguments', async () => {
+    const code = await main(['node', 'cli.ts']);
+    expect(code).toBe(1);
+  });
+
+  // ── Missing phase ─────────────────────────────────────────────────────
+
+  it('returns 1 when phase is missing and not dry-run', async () => {
+    const code = await main(['node', 'cli.ts', '--agent', '1', '--config', TEMP_CONFIG]);
+    expect(code).toBe(1);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('--phase is required'),
+    );
+  });
+
+  // ── Invalid args ──────────────────────────────────────────────────────
+
+  it('returns 1 on invalid args', async () => {
+    const code = await main(['node', 'cli.ts', '--phase', 'bogus']);
+    expect(code).toBe(1);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Invalid phase'),
+    );
+  });
+
+  // ── Dry-run mode ──────────────────────────────────────────────────────
+
+  it('dry-run without phase runs all phases and returns 0', async () => {
+    const code = await main(['node', 'cli.ts', '--dry-run', '--config', TEMP_CONFIG]);
+    expect(code).toBe(0);
+    expect(mockDryRun).toHaveBeenCalledTimes(4);
+  });
+
+  it('dry-run with specific phase runs only that phase', async () => {
+    const code = await main(argv('--dry-run', '--phase', 'alpha'));
+    expect(code).toBe(0);
+    expect(mockDryRun).toHaveBeenCalledTimes(1);
+    expect(mockDryRun).toHaveBeenCalledWith('alpha');
+  });
+
+  it('dry-run with --phase all runs all phases', async () => {
+    const code = await main(argv('--dry-run', '--phase', 'all'));
+    expect(code).toBe(0);
+    expect(mockDryRun).toHaveBeenCalledTimes(4);
+  });
+
+  // ── Run mode ──────────────────────────────────────────────────────────
+
+  it('runs single phase and returns 0 on success', async () => {
+    const code = await main(argv('--phase', 'alpha'));
+    expect(mockRunPhase).toHaveBeenCalledWith('alpha');
+    expect(code).toBe(0);
+  });
+
+  it('runs all phases when --phase all', async () => {
+    const code = await main(argv('--phase', 'all'));
+    expect(code).toBe(0);
+    expect(mockRunPhase).toHaveBeenCalledTimes(4);
+  });
+
+  it('logs skipped agents when present', async () => {
+    mockRunPhase.mockResolvedValueOnce({
+      skippedAgents: [16, 17],
+      agentResults: {},
+      gate: { passed: true, failedBlockingAgents: [] },
+    });
+
+    await main(argv('--phase', 'alpha'));
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Skipped agents: 16, 17'),
+    );
+  });
+
+  it('logs gate FAILED with blocking agents', async () => {
+    mockRunPhase.mockResolvedValueOnce({
+      skippedAgents: [],
+      agentResults: { 1: { agentId: 1, status: 'failed' } },
+      gate: { passed: false, failedBlockingAgents: [1, 3] },
+    });
+
+    await main(argv('--phase', 'alpha'));
+
+    expect(console.log).toHaveBeenCalledWith(
+      expect.stringContaining('Gate: FAILED'),
+    );
+  });
+
+  // ── Exit codes ────────────────────────────────────────────────────────
+
+  it('returns exit code 1 when phase throws error', async () => {
+    mockRunPhase.mockRejectedValueOnce(new Error('boom'));
+
+    const code = await main(argv('--phase', 'alpha'));
+
+    expect(code).toBe(1);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Phase alpha error: boom'),
+    );
+  });
+
+  it('returns exit code 2 for advisory warnings', async () => {
+    vi.mocked(determineExitCode).mockReturnValueOnce(2);
+
+    const code = await main(argv('--phase', 'alpha'));
+    expect(code).toBe(2);
+  });
+
+  // ── CI summary ────────────────────────────────────────────────────────
+
+  it('writes CI summary when running in CI environment', async () => {
+    vi.mocked(detectCIEnvironment).mockReturnValueOnce('github');
+
+    await main(argv('--phase', 'alpha'));
+
+    expect(writeCISummary).toHaveBeenCalled();
+  });
+
+  it('does not write CI summary when not in CI', async () => {
+    vi.mocked(detectCIEnvironment).mockReturnValueOnce('none');
+
+    await main(argv('--phase', 'alpha'));
+
+    expect(writeCISummary).not.toHaveBeenCalled();
+  });
+
+  // ── Config loading failure ────────────────────────────────────────────
+
+  it('returns 1 when config file fails to load', async () => {
+    const code = await main(['node', 'cli.ts', '--phase', 'alpha', '--config', 'nonexistent-config-xyz.ts']);
+    expect(code).toBe(1);
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to load config'),
+    );
+  });
+});

package/core/__tests__/config.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from 'vitest';
+import type { TestTeamConfig } from '../config';
+import { validateConfig } from '../config';
+
+describe('TestTeamConfig', () => {
+  it('rejects config missing schemaVersion', () => {
+    const invalid = { name: 'test' } as unknown as TestTeamConfig;
+    expect(() => validateConfig(invalid)).toThrow('schemaVersion is required');
+  });
+
+  it('rejects config with empty modules array', () => {
+    const invalid = { schemaVersion: 1, name: 'test', modules: [] } as unknown as TestTeamConfig;
+    expect(() => validateConfig(invalid)).toThrow('at least one module');
+  });
+
+  it('accepts credentials with non-empty passwords', () => {
+    const valid = {
+      schemaVersion: 1,
+      name: 'test',
+      auth: { credentials: { alpha: { email: 'a@b.com', password: 'literal' } } },
+    } as unknown as TestTeamConfig;
+    expect(() => validateConfig(valid)).not.toThrow();
+  });
+
+  it('throws when ALL credentials have empty passwords', () => {
+    const invalid = {
+      schemaVersion: 1,
+      name: 'test',
+      auth: { credentials: { alpha: { email: 'a@b.com', password: '' }, beta: { email: 'b@b.com', password: '' } } },
+      modules: [{ id: 'home', route: '/', sidebarIcon: true }],
+    } as unknown as TestTeamConfig;
+    expect(() => validateConfig(invalid)).toThrow('All credentials have empty passwords');
+  });
+
+  it('accepts valid complete config', () => {
+    const valid = createValidConfig();
+    expect(() => validateConfig(valid)).not.toThrow();
+  });
+
+  it('returns disabled agents as a Set for O(1) lookup', () => {
+    const config = createValidConfig({ disabledAgents: [16, 17] });
+    const validated = validateConfig(config);
+    expect(validated.disabledAgentSet.has(16)).toBe(true);
+    expect(validated.disabledAgentSet.has(1)).toBe(false);
+  });
+});
+
+function createValidConfig(overrides = {}) {
+  return {
+    schemaVersion: 1,
+    name: 'test-project',
+    auth: {
+      loginUrl: '/login',
+      credentials: { alpha: { email: 'test@test.com', password: 'pass' } },
+      roles: [{ name: 'admin', email: 'admin@test.com' }],
+    },
+    modules: [{ id: 'home', route: '/', sidebarIcon: true }],
+    environments: { alpha: { baseUrl: 'http://localhost:3000', seed: true } },
+    portals: [{ name: 'main', queryParam: null }],
+    breakpoints: [1920],
+    integrations: [],
+    workers: [],
+    workflows: [],
+    accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: 'USD', timezone: 'UTC' },
+    tenancy: { enabled: false, isolationField: 'tenantId', testFirms: [] },
+    costBudget: { maxPerRun: 50, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' as const },
+    agentClassification: { blocking: [1], advisory: [] },
+    thresholds: {
+      unitCoverage: { lines: 80, functions: 80, branches: 70, statements: 80 },
+      lighthouse: { accessibility: 90, performance: 85, bestPractices: 85, seo: 80 },
+      apiResponseTime: 500,
+      bundleSizeLimit: 500,
+      maxConsoleErrors: 0,
+    },
+    disabledAgents: [],
+    ...overrides,
+  };
+}

package/core/__tests__/cost-tracker.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { CostTracker } from '../cost-tracker';
+import type { CostBudget } from '../cost-tracker';
+
+const defaultBudget: CostBudget = {
+  maxPerRun: 50,
+  maxPerAgent: 10,
+  alertThreshold: 0.8,
+  onExceeded: 'abort',
+};
+
+describe('CostTracker', () => {
+  let tracker: CostTracker;
+
+  beforeEach(() => {
+    tracker = new CostTracker(defaultBudget);
+  });
+
+  describe('constructor', () => {
+    it('accepts a CostBudget config', () => {
+      expect(tracker).toBeDefined();
+    });
+
+    it('starts with zero total cost', () => {
+      expect(tracker.getTotalCost()).toBe(0);
+    });
+  });
+
+  describe('trackCost(agentId, amount)', () => {
+    it('accumulates cost for a single agent', () => {
+      tracker.trackCost('agent-1', 3);
+      tracker.trackCost('agent-1', 2);
+      expect(tracker.getAgentCost('agent-1')).toBe(5);
+    });
+
+    it('accumulates total cost across multiple agents', () => {
+      tracker.trackCost('agent-1', 5);
+      tracker.trackCost('agent-2', 7);
+      expect(tracker.getTotalCost()).toBe(12);
+    });
+
+    it('tracks costs per agent independently', () => {
+      tracker.trackCost('agent-1', 4);
+      tracker.trackCost('agent-2', 6);
+      expect(tracker.getAgentCost('agent-1')).toBe(4);
+      expect(tracker.getAgentCost('agent-2')).toBe(6);
+    });
+  });
+
+  describe('getTotalCost()', () => {
+    it('returns 0 with no costs tracked', () => {
+      expect(tracker.getTotalCost()).toBe(0);
+    });
+
+    it('returns accumulated total after multiple tracks', () => {
+      tracker.trackCost('agent-1', 10);
+      tracker.trackCost('agent-2', 15);
+      tracker.trackCost('agent-1', 5);
+      expect(tracker.getTotalCost()).toBe(30);
+    });
+  });
+
+  describe('getAgentCost(agentId)', () => {
+    it('returns 0 for unknown agent', () => {
+      expect(tracker.getAgentCost('unknown-agent')).toBe(0);
+    });
+
+    it('returns correct cost for tracked agent', () => {
+      tracker.trackCost('agent-42', 7.5);
+      expect(tracker.getAgentCost('agent-42')).toBe(7.5);
+    });
+  });
+
+  describe('checkBudget()', () => {
+    it('returns status ok when under alert threshold', () => {
+      // maxPerRun=50, alertThreshold=0.8 → alert at 40
+      tracker.trackCost('agent-1', 30); // 30/50 = 0.6 → ok
+      const result = tracker.checkBudget();
+      expect(result.status).toBe('ok');
+      expect(result.totalCost).toBe(30);
+      expect(result.budgetRemaining).toBe(20);
+    });
+
+    it('returns status alert when above threshold but under max', () => {
+      // 80% of 50 = 40; spending 42 → alert
+      tracker.trackCost('agent-1', 42);
+      const result = tracker.checkBudget();
+      expect(result.status).toBe('alert');
+      expect(result.totalCost).toBe(42);
+      expect(result.budgetRemaining).toBe(8);
+    });
+
+    it('returns status exceeded when above max', () => {
+      tracker.trackCost('agent-1', 55); // 55 > 50
+      const result = tracker.checkBudget();
+      expect(result.status).toBe('exceeded');
+      expect(result.totalCost).toBe(55);
+      expect(result.budgetRemaining).toBe(-5);
+    });
+
+    it('returns status ok when exactly at zero cost', () => {
+      const result = tracker.checkBudget();
+      expect(result.status).toBe('ok');
+      expect(result.budgetRemaining).toBe(50);
+    });
+
+    it('returns status alert when exactly at alert threshold', () => {
+      // exactly 80% of 50 = 40
+      tracker.trackCost('agent-1', 40);
+      const result = tracker.checkBudget();
+      expect(result.status).toBe('alert');
+    });
+
+    it('returns status exceeded when exactly at max', () => {
+      tracker.trackCost('agent-1', 50);
+      const result = tracker.checkBudget();
+      expect(result.status).toBe('exceeded');
+    });
+  });
+
+  describe('isAgentOverBudget(agentId)', () => {
+    it('returns false when agent has not been tracked', () => {
+      expect(tracker.isAgentOverBudget('agent-1')).toBe(false);
+    });
+
+    it('returns false when agent cost is under maxPerAgent', () => {
+      tracker.trackCost('agent-1', 5); // 5 < 10
+      expect(tracker.isAgentOverBudget('agent-1')).toBe(false);
+    });
+
+    it('returns true when agent cost exceeds maxPerAgent', () => {
+      tracker.trackCost('agent-1', 11); // 11 > 10
+      expect(tracker.isAgentOverBudget('agent-1')).toBe(true);
+    });
+
+    it('returns true when agent cost is exactly at maxPerAgent', () => {
+      tracker.trackCost('agent-1', 10); // exactly 10
+      expect(tracker.isAgentOverBudget('agent-1')).toBe(true);
+    });
+
+    it('does not affect other agents budget check', () => {
+      tracker.trackCost('agent-1', 15); // over budget
+      expect(tracker.isAgentOverBudget('agent-2')).toBe(false);
+    });
+  });
+
+  describe('onExceeded config variants', () => {
+    it('accepts alert-continue as onExceeded policy', () => {
+      const t = new CostTracker({ ...defaultBudget, onExceeded: 'alert-continue' });
+      expect(t).toBeDefined();
+    });
+
+    it('accepts skip-remaining as onExceeded policy', () => {
+      const t = new CostTracker({ ...defaultBudget, onExceeded: 'skip-remaining' });
+      expect(t).toBeDefined();
+    });
+  });
+});