1  /**
   2   * QA Agent Coverage Boost - Part 2
   3   *
   4   * Targets paths NOT yet covered by qa.test.js and qa-extended.test.js:
   5   * - writeTest: merging with existing tests, generateTests returns null, fixTestIssues failure
   6   * - writeTest: all errors, no tests written → failTask
   7   * - writeTest: filesToTest derived from single `file` field
   8   * - checkCoverage: some files below threshold
   9   * - runTests: with test_files, with pattern, with neither (all)
  10   * - verifyFix: no files_changed → no test files found → creates write_test subtask
  11   * - verifyFix: tests fail → askQuestion + blockTask
  12   * - processTask: implement_feature and fix_bug delegation
  13   * - processTask: totally unknown task type
  14   * - addMissingImport: unknown identifier (comment fallback)
  15   * - addMissingImport: ESM identifier already imported in module
  16   * - addMissingImport: add named import to existing import line
  17   * - addMissingImport: insert after last import line
  18   * - addMissingImport: no existing imports (insert at beginning)
  19   * - mergeTests: no new unique tests → returns existing
  20   * - mergeTests: no describe block in existing → returns new tests
  21   * - mergeTests: new imports added at top
  22   * - approximateUncoveredLines: return false, else branch, default, throw, switch default
  23   */
  24  
  25  import { test, describe, before, after, beforeEach } from 'node:test';
  26  import assert from 'node:assert/strict';
  27  import fs from 'fs/promises';
  28  import Database from 'better-sqlite3';
  29  import { join, dirname } from 'path';
  30  import { fileURLToPath } from 'url';
  31  
  32  const __filename = fileURLToPath(import.meta.url);
  33  const __dirname = dirname(__filename);
  34  const projectRoot = join(__dirname, '../..');
  35  
  36  process.env.AGENT_IMMEDIATE_INVOCATION = 'false';
  37  process.env.AGENT_REALTIME_NOTIFICATIONS = 'false';
  38  
  39  // -----------------------------------------------------------------------
  40  // Schema shared across all test environments
  41  // -----------------------------------------------------------------------
  42  const SCHEMA_SQL = `
  43    CREATE TABLE IF NOT EXISTS agent_tasks (
  44      id INTEGER PRIMARY KEY AUTOINCREMENT,
  45      task_type TEXT NOT NULL,
  46      assigned_to TEXT NOT NULL,
  47      created_by TEXT,
  48      status TEXT DEFAULT 'pending',
  49      priority INTEGER DEFAULT 5,
  50      context_json TEXT,
  51      result_json TEXT,
  52      parent_task_id INTEGER,
  53      error_message TEXT,
  54      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  55      started_at DATETIME,
  56      completed_at DATETIME,
  57      retry_count INTEGER DEFAULT 0
  58    );
  59    CREATE TABLE IF NOT EXISTS agent_messages (
  60      id INTEGER PRIMARY KEY AUTOINCREMENT,
  61      task_id INTEGER,
  62      from_agent TEXT NOT NULL,
  63      to_agent TEXT NOT NULL,
  64      message_type TEXT,
  65      content TEXT NOT NULL,
  66      metadata_json TEXT,
  67      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  68      read_at DATETIME
  69    );
  70    CREATE TABLE IF NOT EXISTS agent_logs (
  71      id INTEGER PRIMARY KEY AUTOINCREMENT,
  72      task_id INTEGER,
  73      agent_name TEXT NOT NULL,
  74      log_level TEXT,
  75      message TEXT,
  76      data_json TEXT,
  77      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  78    );
  79    CREATE TABLE IF NOT EXISTS agent_state (
  80      agent_name TEXT PRIMARY KEY,
  81      last_active DATETIME DEFAULT CURRENT_TIMESTAMP,
  82      current_task_id INTEGER,
  83      status TEXT DEFAULT 'idle',
  84      metrics_json TEXT
  85    );
  86    CREATE TABLE IF NOT EXISTS agent_outcomes (
  87      id INTEGER PRIMARY KEY AUTOINCREMENT,
  88      task_id INTEGER NOT NULL,
  89      agent_name TEXT NOT NULL,
  90      task_type TEXT NOT NULL,
  91      outcome TEXT NOT NULL,
  92      context_json TEXT,
  93      result_json TEXT,
  94      duration_ms INTEGER,
  95      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
  96    );
  97    CREATE TABLE IF NOT EXISTS agent_llm_usage (
  98      id INTEGER PRIMARY KEY AUTOINCREMENT,
  99      agent_name TEXT NOT NULL,
 100      task_id INTEGER,
 101      model TEXT NOT NULL,
 102      prompt_tokens INTEGER NOT NULL,
 103      completion_tokens INTEGER NOT NULL,
 104      cost_usd DECIMAL(10,6) NOT NULL,
 105      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
 106    );
 107    CREATE TABLE IF NOT EXISTS structured_logs (
 108      id INTEGER PRIMARY KEY AUTOINCREMENT,
 109      agent_name TEXT,
 110      task_id INTEGER,
 111      level TEXT,
 112      message TEXT,
 113      data_json TEXT,
 114      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
 115    );
 116  `;
 117  
 118  // -----------------------------------------------------------------------
 119  // Helper: import reset functions lazily (avoid top-level await)
 120  // -----------------------------------------------------------------------
 121  let resetQaBaseDb, resetQaTaskDb, resetQaMessageDb;
 122  
 123  async function getResets() {
 124    if (!resetQaBaseDb) {
 125      ({ resetDb: resetQaBaseDb } = await import('../../src/agents/base-agent.js'));
 126      ({ resetDb: resetQaTaskDb } = await import('../../src/agents/utils/task-manager.js'));
 127      ({ resetDb: resetQaMessageDb } = await import('../../src/agents/utils/message-manager.js'));
 128    }
 129    return { resetQaBaseDb, resetQaTaskDb, resetQaMessageDb };
 130  }
 131  
 132  let _dbCounter = 0;
 133  async function createQaEnv() {
 134    const { resetQaBaseDb, resetQaTaskDb, resetQaMessageDb } = await getResets();
 135    resetQaBaseDb();
 136    resetQaTaskDb();
 137    resetQaMessageDb();
 138  
 139    const dbPath = join('/tmp', `test-qa-cov2-${Date.now()}-${++_dbCounter}.db`);
 140    try {
 141      await fs.unlink(dbPath);
 142    } catch {
 143      /* ignore */
 144    }
 145  
 146    const db = new Database(dbPath);
 147    db.exec(SCHEMA_SQL);
 148  
 149    process.env.DATABASE_PATH = dbPath;
 150  
 151    const { QAAgent } = await import('../../src/agents/qa.js');
 152    const agent = new QAAgent();
 153    await agent.initialize();
 154  
 155    const cleanup = async () => {
 156      const { resetQaBaseDb, resetQaTaskDb, resetQaMessageDb } = await getResets();
 157      resetQaBaseDb();
 158      resetQaTaskDb();
 159      resetQaMessageDb();
 160      try {
 161        db.close();
 162      } catch {
 163        /* ignore */
 164      }
 165      for (const ext of ['', '-wal', '-shm']) {
 166        try {
 167          await fs.unlink(dbPath + ext);
 168        } catch {
 169          /* ignore */
 170        }
 171      }
 172    };
 173  
 174    return { db, agent, cleanup };
 175  }
 176  
 177  function insertTask(db, taskType, contextObj) {
 178    return db
 179      .prepare(
 180        `INSERT INTO agent_tasks (task_type, assigned_to, status, context_json)
 181         VALUES (?, 'qa', 'pending', ?) RETURNING id`
 182      )
 183      .get(taskType, contextObj !== undefined ? JSON.stringify(contextObj) : null).id;
 184  }
 185  
 186  function getTask(db, taskId) {
 187    const row = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 188    if (row?.context_json && typeof row.context_json === 'string') {
 189      try {
 190        row.context_json = JSON.parse(row.context_json);
 191      } catch {
 192        /* ignore */
 193      }
 194    }
 195    if (row?.result_json && typeof row.result_json === 'string') {
 196      try {
 197        row.result_json = JSON.parse(row.result_json);
 198      } catch {
 199        /* ignore */
 200      }
 201    }
 202    return row;
 203  }
 204  
 205  // -----------------------------------------------------------------------
 206  // addMissingImport: all branches
 207  // -----------------------------------------------------------------------
 208  describe('QAAgent - addMissingImport (all branches)', () => {
 209    let agent;
 210    before(async () => {
 211      const { QAAgent } = await import('../../src/agents/qa.js');
 212      agent = new QAAgent();
 213    });
 214  
 215    test('returns comment when identifier is unknown', () => {
 216      const code = `import { test } from 'node:test';
 217  test('x', () => {});`;
 218      const result = agent.addMissingImport(code, 'unknownXyzIdentifier');
 219      assert.ok(result.includes('// TODO: Add import for unknownXyzIdentifier'));
 220    });
 221  
 222    test('ESM: does not add duplicate when identifier already in import', () => {
 223      const code = `import { test, describe } from 'node:test';
 224  test('x', () => {});`;
 225      const result = agent.addMissingImport(code, 'describe');
 226      // Already imported - should not add another import
 227      const count = (result.match(/from 'node:test'/g) || []).length;
 228      assert.equal(count, 1, 'Should not create a duplicate import');
 229    });
 230  
 231    test('ESM: adds named import to existing import line for same module', () => {
 232      const code = `import { test } from 'node:test';
 233  test('x', () => {});`;
 234      const result = agent.addMissingImport(code, 'describe');
 235      assert.ok(result.includes('describe'), 'Should add describe to import');
 236      assert.ok(result.includes("from 'node:test'"), 'Module reference should be preserved');
 237    });
 238  
 239    test('ESM: inserts new import after last import when module not present', () => {
 240      const code = `import assert from 'node:assert';
 241  test('x', () => {});`;
 242      const result = agent.addMissingImport(code, 'test');
 243      assert.ok(result.includes("from 'node:test'"), 'Should add node:test import');
 244    });
 245  
 246    test('ESM: inserts import at start when no existing imports', () => {
 247      // No import lines at all
 248      const code = `test('x', () => {});`;
 249      const result = agent.addMissingImport(code, 'test');
 250      assert.ok(result.startsWith('import'), 'Should add import at beginning');
 251      assert.ok(result.includes("from 'node:test'"));
 252    });
 253  
 254    test('ESM: inserts default (non-named) import for Database', () => {
 255      const code = `import { test } from 'node:test';
 256  test('db test', () => {});`;
 257      const result = agent.addMissingImport(code, 'Database');
 258      assert.ok(result.includes('import Database from'));
 259      assert.ok(result.includes('better-sqlite3'));
 260    });
 261  
 262    test('ESM: inserts default (non-named) import for assert', () => {
 263      const code = `import { test } from 'node:test';
 264  test('x', () => {});`;
 265      const result = agent.addMissingImport(code, 'assert');
 266      assert.ok(result.includes("import assert from 'node:assert'"));
 267    });
 268  
 269    test('ESM: adds writeFile to existing fs/promises import', () => {
 270      const code = `import { readFile } from 'fs/promises';
 271  import { test } from 'node:test';
 272  test('x', () => {});`;
 273      const result = agent.addMissingImport(code, 'writeFile');
 274      assert.ok(result.includes('writeFile'), 'Should add writeFile to import');
 275    });
 276  
 277    test('CJS: adds require for named import (join from path)', () => {
 278      const code = `const test = require('node:test');
 279  test('x', () => { console.log(join('a', 'b')); });`;
 280      const result = agent.addMissingImport(code, 'join');
 281      assert.ok(result.includes("require('path')"), 'Should use require for CJS');
 282      assert.ok(result.includes('join'));
 283    });
 284  
 285    test('CJS: adds require for default import (assert)', () => {
 286      const code = `const test = require('node:test');
 287  test('x', () => { assert.ok(true); });`;
 288      const result = agent.addMissingImport(code, 'assert');
 289      assert.ok(result.includes("require('node:assert')"));
 290    });
 291  });
 292  
 293  // -----------------------------------------------------------------------
 294  // approximateUncoveredLines: patterns
 295  // -----------------------------------------------------------------------
 296  describe('QAAgent - approximateUncoveredLines (pattern coverage)', () => {
 297    let agent;
 298    before(async () => {
 299      const { QAAgent } = await import('../../src/agents/qa.js');
 300      agent = new QAAgent();
 301    });
 302  
 303    test('detects else branch lines', () => {
 304      const code = `function f(x) {
 305    if (x) {
 306      return true;
 307    } else {
 308      return false;
 309    }
 310  }`;
 311      const result = agent.approximateUncoveredLines(code, 50);
 312      assert.ok(
 313        result.uncoveredLines.some(n => n >= 4),
 314        'Should detect else branch'
 315      );
 316      assert.ok(result.uncoveredLines.includes(5), 'return false line should be flagged');
 317    });
 318  
 319    test('detects switch default lines', () => {
 320      const code = `function f(x) {
 321    switch (x) {
 322      case 'a': return 1;
 323      default:
 324        return 0;
 325    }
 326  }`;
 327      const result = agent.approximateUncoveredLines(code, 60);
 328      assert.ok(
 329        result.uncoveredLines.some(n => n >= 4),
 330        'Should detect default: line'
 331      );
 332    });
 333  
 334    test('detects throw new Error lines', () => {
 335      const code = `function validate(x) {
 336    if (!x) {
 337      throw new Error('x is required');
 338    }
 339    return x;
 340  }`;
 341      const result = agent.approximateUncoveredLines(code, 70);
 342      assert.ok(result.uncoveredLines.includes(3), 'throw line should be detected');
 343    });
 344  
 345    test('skips empty lines and comment lines', () => {
 346      const code = `
 347  // Single-line comment
 348  /* block comment */
 349  * JSDoc line
 350  function f() {
 351    return 1;
 352  }`;
 353      const result = agent.approximateUncoveredLines(code, 80);
 354      // Empty line (1), comment (2), block comment (3), jsdoc (4) should NOT be in uncovered
 355      for (const lineNum of [1, 2, 3, 4]) {
 356        assert.ok(!result.uncoveredLines.includes(lineNum), `Line ${lineNum} should be skipped`);
 357      }
 358    });
 359  
 360    test('detects catch blocks', () => {
 361      const code = `async function fetchSomething() {
 362    try {
 363      const r = await fetch('http://example.com');
 364      return r.json();
 365    } catch (err) {
 366      console.error(err);
 367      return null;
 368    }
 369  }`;
 370      const result = agent.approximateUncoveredLines(code, 40);
 371      // catch line should be detected
 372      assert.ok(
 373        result.uncoveredLines.some(n => n >= 5),
 374        'catch block should be detected'
 375      );
 376    });
 377  
 378    test('returns correct structure even for empty code', () => {
 379      const result = agent.approximateUncoveredLines('', 100);
 380      assert.deepEqual(result.uncoveredLines, []);
 381      assert.equal(result.coveragePct, 100);
 382      assert.equal(result.sourceCode, '');
 383    });
 384  });
 385  
 386  // -----------------------------------------------------------------------
 387  // mergeTests: additional branch coverage
 388  // -----------------------------------------------------------------------
 389  describe('QAAgent - mergeTests (additional branches)', () => {
 390    let agent;
 391    before(async () => {
 392      const { QAAgent } = await import('../../src/agents/qa.js');
 393      agent = new QAAgent();
 394    });
 395  
 396    test('returns existing when all new tests are duplicates', async () => {
 397      const existing = `import { test } from 'node:test';
 398  import assert from 'node:assert';
 399  test('existing test', () => {
 400    assert.ok(true);
 401  });
 402  `;
 403      const newTests = `import { test } from 'node:test';
 404  test('existing test', () => {
 405    assert.ok(true);
 406  });
 407  `;
 408      const result = await agent.mergeTests(existing, newTests);
 409      // Safe-append: deduplicates imports but still appends non-import content
 410      // The test body "test('existing test', ...)" is not empty after import removal, so it gets appended
 411      assert.ok(result.includes("test('existing test'"));
 412      assert.ok(result.startsWith(existing.trimEnd()));
 413    });
 414  
 415    test('returns new tests when existing has no describe/closing brace', async () => {
 416      // Safe-append: always appends after existing content with separator
 417      const existing = `// Empty file with no tests`;
 418      const newTests = `import { test } from 'node:test';
 419  test('brand new', () => {});
 420  `;
 421      const result = await agent.mergeTests(existing, newTests);
 422      // Should contain both existing and new tests with separator
 423      assert.ok(result.includes(existing));
 424      assert.ok(result.includes("test('brand new'"));
 425      assert.ok(result.includes('Coverage supplement'));
 426    });
 427  
 428    test('adds new imports from new tests not in existing', async () => {
 429      const existing = `import { test } from 'node:test';
 430  
 431  test('first', () => {});
 432  });
 433  `;
 434      const newTests = `import { test } from 'node:test';
 435  import path from 'path';
 436  test('uses path', () => {});
 437  `;
 438      const result = await agent.mergeTests(existing, newTests);
 439      // path import should be added
 440      assert.ok(result.includes("import path from 'path'") || result.includes('import'));
 441    });
 442  
 443    test('handles new tests with unique name successfully', async () => {
 444      const existing = `import { test } from 'node:test';
 445  
 446  describe('module', () => {
 447    test('existing test A', () => {});
 448  });
 449  `;
 450      const newTests = `import { test } from 'node:test';
 451  test('brand new unique test B', () => {
 452    const x = 1 + 1;
 453    return x;
 454  });
 455  `;
 456      const result = await agent.mergeTests(existing, newTests);
 457      assert.ok(typeof result === 'string');
 458      assert.ok(result.includes('existing test A'), 'Original test should be preserved');
 459    });
 460  });
 461  
 462  // -----------------------------------------------------------------------
 463  // processTask: delegation paths
 464  // -----------------------------------------------------------------------
 465  describe('QAAgent - processTask delegation', () => {
 466    test('delegates implement_feature to correct agent', async () => {
 467      const { db, agent, cleanup } = await createQaEnv();
 468      try {
 469        const taskId = insertTask(db, 'implement_feature', { description: 'Build X' });
 470        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 471        await agent.processTask(taskRow);
 472        const updated = getTask(db, taskId);
 473        // Should be completed (delegated)
 474        assert.equal(updated.status, 'completed');
 475        assert.ok(updated.result_json?.delegated === true, 'Should be marked delegated');
 476      } finally {
 477        await cleanup();
 478      }
 479    });
 480  
 481    test('delegates fix_bug to correct agent', async () => {
 482      const { db, agent, cleanup } = await createQaEnv();
 483      try {
 484        const taskId = insertTask(db, 'fix_bug', { error: 'NPE in line 42' });
 485        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 486        await agent.processTask(taskRow);
 487        const updated = getTask(db, taskId);
 488        assert.equal(updated.status, 'completed');
 489        assert.ok(updated.result_json?.delegated === true);
 490      } finally {
 491        await cleanup();
 492      }
 493    });
 494  
 495    test('delegates unknown task type and logs warning', async () => {
 496      const { db, agent, cleanup } = await createQaEnv();
 497      try {
 498        const taskId = insertTask(db, 'totally_unknown_xyz_999', { x: 1 });
 499        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 500        await agent.processTask(taskRow);
 501        const updated = getTask(db, taskId);
 502        // Should complete via delegation
 503        assert.equal(updated.status, 'completed');
 504      } finally {
 505        await cleanup();
 506      }
 507    });
 508  });
 509  
 510  // -----------------------------------------------------------------------
 511  // runTests: all three branches (test_files, pattern, neither)
 512  // -----------------------------------------------------------------------
 513  describe('QAAgent - runTests branches', () => {
 514    test('runTests with test_files array calls runTestFiles', async () => {
 515      const { db, agent, cleanup } = await createQaEnv();
 516      try {
 517        // Mock runTestFiles to avoid actually running npm test
 518        agent.runTestFiles = async files => ({
 519          success: true,
 520          output: `1 passing\nFile: ${files[0]}`,
 521          count: 1,
 522        });
 523  
 524        const taskId = insertTask(db, 'run_tests', {
 525          test_files: ['tests/agents/qa.test.js'],
 526        });
 527        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 528        await agent.processTask(taskRow);
 529  
 530        const updated = getTask(db, taskId);
 531        assert.equal(updated.status, 'completed');
 532        assert.equal(updated.result_json?.success, true);
 533        assert.equal(updated.result_json?.test_count, 1);
 534      } finally {
 535        await cleanup();
 536      }
 537    });
 538  
 539    test('runTests with pattern calls runTestPattern', async () => {
 540      const { db, agent, cleanup } = await createQaEnv();
 541      try {
 542        agent.runTestPattern = async pattern => ({
 543          success: true,
 544          output: `Pattern: ${pattern} matched 3 tests`,
 545          count: 3,
 546        });
 547  
 548        const taskId = insertTask(db, 'run_tests', { pattern: 'scoring' });
 549        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 550        await agent.processTask(taskRow);
 551  
 552        const updated = getTask(db, taskId);
 553        assert.equal(updated.status, 'completed');
 554        assert.equal(updated.result_json?.success, true);
 555      } finally {
 556        await cleanup();
 557      }
 558    });
 559  
 560    test('runTests with neither test_files nor pattern calls runAllTests', async () => {
 561      const { db, agent, cleanup } = await createQaEnv();
 562      try {
 563        agent.runAllTests = async () => ({
 564          success: true,
 565          output: 'All 100 tests passing',
 566          count: 100,
 567        });
 568  
 569        const taskId = insertTask(db, 'run_tests', {});
 570        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 571        await agent.processTask(taskRow);
 572  
 573        const updated = getTask(db, taskId);
 574        assert.equal(updated.status, 'completed');
 575        assert.equal(updated.result_json?.success, true);
 576      } finally {
 577        await cleanup();
 578      }
 579    });
 580  
 581    test('runTests with failed test run completes with success=false', async () => {
 582      const { db, agent, cleanup } = await createQaEnv();
 583      try {
 584        agent.runTestFiles = async () => ({
 585          success: false,
 586          output: 'AssertionError: expected true to equal false',
 587          count: 0,
 588        });
 589  
 590        const taskId = insertTask(db, 'run_tests', {
 591          test_files: ['tests/broken.test.js'],
 592        });
 593        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 594        await agent.processTask(taskRow);
 595  
 596        const updated = getTask(db, taskId);
 597        assert.equal(updated.status, 'completed');
 598        assert.equal(updated.result_json?.success, false);
 599      } finally {
 600        await cleanup();
 601      }
 602    });
 603  });
 604  
 605  // -----------------------------------------------------------------------
 606  // checkCoverage: below threshold branch
 607  // -----------------------------------------------------------------------
 608  describe('QAAgent - checkCoverage (below threshold)', () => {
 609    test('returns below_threshold entries when coverage < 80', async () => {
 610      const { db, agent, cleanup } = await createQaEnv();
 611      try {
 612        agent.getFileCoverage = async files => {
 613          const r = {};
 614          files.forEach(f => (r[f] = 60));
 615          return r;
 616        };
 617  
 618        const taskId = insertTask(db, 'check_coverage', {
 619          files: ['src/capture.js', 'src/enrich.js'],
 620        });
 621        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 622        await agent.processTask(taskRow);
 623  
 624        const updated = getTask(db, taskId);
 625        assert.equal(updated.status, 'completed');
 626        assert.equal(updated.result_json?.all_meet_threshold, false);
 627        assert.equal(updated.result_json?.below_threshold?.length, 2);
 628      } finally {
 629        await cleanup();
 630      }
 631    });
 632  
 633    test('checkCoverage with empty files array completes cleanly', async () => {
 634      const { db, agent, cleanup } = await createQaEnv();
 635      try {
 636        agent.getFileCoverage = async () => ({});
 637  
 638        const taskId = insertTask(db, 'check_coverage', { files: [] });
 639        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 640        await agent.processTask(taskRow);
 641  
 642        const updated = getTask(db, taskId);
 643        assert.equal(updated.status, 'completed');
 644        assert.equal(updated.result_json?.all_meet_threshold, true);
 645      } finally {
 646        await cleanup();
 647      }
 648    });
 649  
 650    test('checkCoverage with mixed coverage (some above, some below)', async () => {
 651      const { db, agent, cleanup } = await createQaEnv();
 652      try {
 653        agent.getFileCoverage = async files => {
 654          const r = {};
 655          files.forEach((f, i) => (r[f] = i % 2 === 0 ? 90 : 50));
 656          return r;
 657        };
 658  
 659        const taskId = insertTask(db, 'check_coverage', {
 660          files: ['src/a.js', 'src/b.js', 'src/c.js'],
 661        });
 662        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 663        await agent.processTask(taskRow);
 664  
 665        const updated = getTask(db, taskId);
 666        assert.equal(updated.status, 'completed');
 667        assert.equal(updated.result_json?.all_meet_threshold, false);
 668        // a.js (90%), b.js (50%) → below; c.js (90%) above
 669        assert.equal(updated.result_json?.below_threshold?.length, 1);
 670      } finally {
 671        await cleanup();
 672      }
 673    });
 674  });
 675  
 676  // -----------------------------------------------------------------------
 677  // verifyFix: no test files found → creates write_test subtask + blocks
 678  // -----------------------------------------------------------------------
 679  describe('QAAgent - verifyFix edge cases', () => {
 680    test('blocks task when no test files exist for changed files', async () => {
 681      const { db, agent, cleanup } = await createQaEnv();
 682      try {
 683        // fileExists always returns false → no test files found
 684        agent.fileExists = async () => false;
 685  
 686        const taskId = insertTask(db, 'verify_fix', {
 687          files_changed: ['src/new-module.js'],
 688          fix_commit: 'abc123',
 689        });
 690        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 691        await agent.processTask(taskRow);
 692  
 693        const updated = getTask(db, taskId);
 694        assert.equal(updated.status, 'blocked', 'Should block when no test files found');
 695  
 696        // A write_test subtask should have been created
 697        const subtask = db
 698          .prepare(`SELECT * FROM agent_tasks WHERE task_type = 'write_test' AND parent_task_id = ?`)
 699          .get(taskId);
 700        assert.ok(subtask, 'Should create write_test subtask');
 701      } finally {
 702        await cleanup();
 703      }
 704    });
 705  
 706    test('blocks and asks developer when tests fail', async () => {
 707      const { db, agent, cleanup } = await createQaEnv();
 708      try {
 709        agent.fileExists = async f => f.endsWith('.test.js');
 710        agent.runTestFiles = async () => ({
 711          success: false,
 712          output: 'AssertionError: 1 !== 2',
 713          count: 0,
 714        });
 715        agent.askQuestion = async () => {};
 716  
 717        const taskId = insertTask(db, 'verify_fix', {
 718          files_changed: ['src/scoring.js'],
 719        });
 720        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 721        await agent.processTask(taskRow);
 722  
 723        const updated = getTask(db, taskId);
 724        assert.equal(updated.status, 'blocked', 'Should block when tests fail');
 725      } finally {
 726        await cleanup();
 727      }
 728    });
 729  
 730    test('verifyFix with multiple files, only some have test files', async () => {
 731      const { db, agent, cleanup } = await createQaEnv();
 732      try {
 733        // Only the first file has a test file
 734        agent.fileExists = async f => f.includes('scoring');
 735        agent.runTestFiles = async () => ({
 736          success: true,
 737          output: '3 passing',
 738          count: 3,
 739        });
 740        agent.getFileCoverage = async files => {
 741          const r = {};
 742          files.forEach(f => (r[f] = 85));
 743          return r;
 744        };
 745  
 746        const taskId = insertTask(db, 'verify_fix', {
 747          files_changed: ['src/scoring.js', 'src/nonexistent-no-tests.js'],
 748        });
 749        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 750        await agent.processTask(taskRow);
 751  
 752        // The task should complete (one test file found and it passed)
 753        const updated = getTask(db, taskId);
 754        assert.ok(['completed', 'blocked'].includes(updated.status));
 755      } finally {
 756        await cleanup();
 757      }
 758    });
 759  });
 760  
 761  // -----------------------------------------------------------------------
 762  // writeTest: all-errors path (failTask), single `file` field, merge with existing
 763  // -----------------------------------------------------------------------
 764  describe('QAAgent - writeTest edge cases', () => {
 765    test('fails task when all files produce errors and no tests written', async () => {
 766      const { db, agent, cleanup } = await createQaEnv();
 767      try {
 768        // identifyUncoveredLines throws for every file
 769        agent.identifyUncoveredLines = async () => {
 770          throw new Error('Coverage parse failure');
 771        };
 772  
 773        const taskId = insertTask(db, 'write_test', {
 774          files_to_test: ['src/failing-module.js'],
 775          current_coverage: 20,
 776        });
 777        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 778        await agent.processTask(taskRow);
 779  
 780        const updated = getTask(db, taskId);
 781        assert.equal(updated.status, 'failed', 'Should fail task when all writes error');
 782      } finally {
 783        await cleanup();
 784      }
 785    });
 786  
 787    test('uses single `file` field when files_to_test not provided', async () => {
 788      const { db, agent, cleanup } = await createQaEnv();
 789      const tmpTestFile = join(projectRoot, 'tests/agents/tmp-qa-cov2-single-file.test.js');
 790      try {
 791        agent.identifyUncoveredLines = async () => ({
 792          uncoveredLines: [5, 10],
 793          sourceCode: 'function f() { return null; }',
 794          coveragePct: 50,
 795        });
 796        agent.generateTests = async () =>
 797          "import { test } from 'node:test';\ntest('coverage', () => {});\n";
 798        agent.getTestFile = () => tmpTestFile;
 799        agent.fileExists = async () => false;
 800        agent.runTestFiles = async () => ({ success: true, output: '1 passing', count: 1 });
 801        agent.getFileCoverage = async files => {
 802          const r = {};
 803          files.forEach(f => (r[f] = 85));
 804          return r;
 805        };
 806  
 807        // Uses `file` (singular) not `files_to_test`
 808        const taskId = insertTask(db, 'write_test', {
 809          file: 'src/single-file.js',
 810          current_coverage: 50,
 811          target_coverage: 80,
 812        });
 813        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 814        await agent.processTask(taskRow);
 815  
 816        const updated = getTask(db, taskId);
 817        assert.ok(['completed', 'failed'].includes(updated.status));
 818      } finally {
 819        await cleanup();
 820        try {
 821          await fs.unlink(tmpTestFile);
 822        } catch {
 823          /* ignore */
 824        }
 825      }
 826    });
 827  
 828    test('merges with existing test file when test file already exists', async () => {
 829      const { db, agent, cleanup } = await createQaEnv();
 830      const tmpTestFile = join(projectRoot, 'tests/agents/tmp-qa-cov2-merge.test.js');
 831      try {
 832        // Write an initial test file
 833        const existingContent = `import { test } from 'node:test';
 834  import assert from 'node:assert';
 835  
 836  describe('existing module tests', () => {
 837    test('existing test one', () => {
 838      assert.ok(true);
 839    });
 840  });
 841  `;
 842        await fs.writeFile(tmpTestFile, existingContent, 'utf8');
 843  
 844        agent.identifyUncoveredLines = async () => ({
 845          uncoveredLines: [20],
 846          sourceCode: 'function g(x) { if (!x) return null; return x; }',
 847          coveragePct: 60,
 848        });
 849        agent.generateTests = async () =>
 850          "import { test } from 'node:test';\ntest('merged test unique abc', () => {});\n";
 851        agent.getTestFile = () => tmpTestFile;
 852        agent.fileExists = async () => true; // File exists → merge path
 853        agent.runTestFiles = async () => ({ success: true, output: '2 passing', count: 2 });
 854        agent.getFileCoverage = async files => {
 855          const r = {};
 856          files.forEach(f => (r[f] = 85));
 857          return r;
 858        };
 859  
 860        const taskId = insertTask(db, 'write_test', {
 861          files_to_test: ['src/merge-module.js'],
 862          current_coverage: 60,
 863        });
 864        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 865        await agent.processTask(taskRow);
 866  
 867        const updated = getTask(db, taskId);
 868        assert.ok(['completed', 'failed'].includes(updated.status));
 869      } finally {
 870        await cleanup();
 871        try {
 872          await fs.unlink(tmpTestFile);
 873        } catch {
 874          /* ignore */
 875        }
 876      }
 877    });
 878  
 879    test('writeTest: no uncovered lines → completes with empty tests_written', async () => {
 880      const { db, agent, cleanup } = await createQaEnv();
 881      try {
 882        // identifyUncoveredLines returns empty uncovered lines
 883        agent.identifyUncoveredLines = async () => ({
 884          uncoveredLines: [],
 885          sourceCode: 'function f() { return 1; }',
 886          coveragePct: 100,
 887        });
 888  
 889        const taskId = insertTask(db, 'write_test', {
 890          files_to_test: ['src/fully-covered.js'],
 891        });
 892        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 893        await agent.processTask(taskRow);
 894  
 895        const updated = getTask(db, taskId);
 896        assert.equal(updated.status, 'completed');
 897        assert.ok(Array.isArray(updated.result_json?.tests_written));
 898        assert.equal(updated.result_json?.tests_written.length, 0);
 899      } finally {
 900        await cleanup();
 901      }
 902    });
 903  
 904    test('writeTest: generateTests returns null → skips file but completes', async () => {
 905      const { db, agent, cleanup } = await createQaEnv();
 906      try {
 907        agent.identifyUncoveredLines = async () => ({
 908          uncoveredLines: [5, 10],
 909          sourceCode: 'function f() { return null; }',
 910          coveragePct: 50,
 911        });
 912        // generateTests returns null (LLM failure)
 913        agent.generateTests = async () => null;
 914  
 915        const taskId = insertTask(db, 'write_test', {
 916          files_to_test: ['src/llm-fail-module.js'],
 917          current_coverage: 50,
 918        });
 919        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 920        await agent.processTask(taskRow);
 921  
 922        const updated = getTask(db, taskId);
 923        // Should complete with success=false (no tests written, but not an error)
 924        assert.ok(['completed', 'failed'].includes(updated.status));
 925      } finally {
 926        await cleanup();
 927      }
 928    });
 929  
 930    test('writeTest: tests fail and fixTestIssues succeeds (fixed=true path)', async () => {
 931      const { db, agent, cleanup } = await createQaEnv();
 932      const tmpTestFile = join(projectRoot, 'tests/agents/tmp-qa-cov2-fix-ok.test.js');
 933      try {
 934        agent.identifyUncoveredLines = async () => ({
 935          uncoveredLines: [3],
 936          sourceCode: 'function f() { return null; }',
 937          coveragePct: 40,
 938        });
 939        agent.generateTests = async () =>
 940          "import { test } from 'node:test';\ntest('auto-fix ok', () => {});\n";
 941        agent.getTestFile = () => tmpTestFile;
 942        agent.fileExists = async () => false;
 943  
 944        let callCount = 0;
 945        agent.runTestFiles = async () => {
 946          callCount++;
 947          // First call fails, second (after fix) succeeds
 948          if (callCount === 1)
 949            return { success: false, output: 'assert.equal deprecation', count: 0 };
 950          return { success: true, output: '1 passing', count: 1 };
 951        };
 952        agent.getFileCoverage = async files => {
 953          const r = {};
 954          files.forEach(f => (r[f] = 82));
 955          return r;
 956        };
 957  
 958        const taskId = insertTask(db, 'write_test', {
 959          files_to_test: ['src/fix-ok-module.js'],
 960          current_coverage: 40,
 961        });
 962        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
 963        await agent.processTask(taskRow);
 964  
 965        const updated = getTask(db, taskId);
 966        assert.ok(['completed', 'failed'].includes(updated.status));
 967      } finally {
 968        await cleanup();
 969        try {
 970          await fs.unlink(tmpTestFile);
 971        } catch {
 972          /* ignore */
 973        }
 974      }
 975    });
 976  
 977    test('writeTest: tests fail and fixTestIssues fails → errors array populated', async () => {
 978      const { db, agent, cleanup } = await createQaEnv();
 979      const tmpTestFile = join(projectRoot, 'tests/agents/tmp-qa-cov2-fix-fail.test.js');
 980      try {
 981        agent.identifyUncoveredLines = async () => ({
 982          uncoveredLines: [3],
 983          sourceCode: 'function f() { return null; }',
 984          coveragePct: 40,
 985        });
 986        agent.generateTests = async () =>
 987          "import { test } from 'node:test';\ntest('will fail', () => {});\n";
 988        agent.getTestFile = () => tmpTestFile;
 989        agent.fileExists = async () => false;
 990        // Always fail - fixTestIssues will also fail (no pattern match)
 991        agent.runTestFiles = async () => ({
 992          success: false,
 993          output: 'Some completely unrecognized failure pattern xyz',
 994          count: 0,
 995        });
 996        agent.getFileCoverage = async files => {
 997          const r = {};
 998          files.forEach(f => (r[f] = 50));
 999          return r;
1000        };
1001  
1002        const taskId = insertTask(db, 'write_test', {
1003          files_to_test: ['src/fix-fail-module.js'],
1004          current_coverage: 40,
1005        });
1006        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
1007        await agent.processTask(taskRow);
1008  
1009        const updated = getTask(db, taskId);
1010        // Should fail when tests can't be fixed
1011        assert.equal(updated.status, 'failed');
1012      } finally {
1013        await cleanup();
1014        try {
1015          await fs.unlink(tmpTestFile);
1016        } catch {
1017          /* ignore */
1018        }
1019      }
1020    });
1021  });
1022  
1023  // -----------------------------------------------------------------------
1024  // getFileCoverage: successful read from coverage file
1025  // -----------------------------------------------------------------------
1026  describe('QAAgent - getFileCoverage with coverage data', () => {
1027    let agent;
1028    let coveragePath;
1029  
1030    before(async () => {
1031      const { QAAgent } = await import('../../src/agents/qa.js');
1032      agent = new QAAgent();
1033      agent.log = async () => {};
1034  
1035      // Create a temporary coverage-summary.json
1036      coveragePath = join(projectRoot, 'coverage', 'coverage-summary.json');
1037      try {
1038        await fs.mkdir(join(projectRoot, 'coverage'), { recursive: true });
1039      } catch {
1040        /* ignore */
1041      }
1042    });
1043  
1044    test('reads line coverage percentage when file is in coverage data', async () => {
1045      // Write a minimal coverage-summary.json
1046      const fakeCoverage = {
1047        total: {
1048          lines: { pct: 70 },
1049          statements: { pct: 70 },
1050          branches: { pct: 65 },
1051          functions: { pct: 72 },
1052        },
1053        '/fake/test/file.js': {
1054          lines: { pct: 92 },
1055          statements: { pct: 91 },
1056          branches: { pct: 88 },
1057          functions: { pct: 95 },
1058        },
1059      };
1060  
1061      // Write coverage file temporarily if it doesn't exist (don't overwrite real one)
1062      let createdCoverage = false;
1063      try {
1064        await fs.access(coveragePath);
1065      } catch {
1066        await fs.writeFile(coveragePath, JSON.stringify(fakeCoverage), 'utf8');
1067        createdCoverage = true;
1068      }
1069  
1070      try {
1071        const result = await agent.getFileCoverage(['/fake/test/file.js']);
1072        // Either found in coverage (92%) or defaulted to 0
1073        assert.ok(typeof result['/fake/test/file.js'] === 'number');
1074        assert.ok(result['/fake/test/file.js'] >= 0 && result['/fake/test/file.js'] <= 100);
1075      } finally {
1076        if (createdCoverage) {
1077          try {
1078            await fs.unlink(coveragePath);
1079          } catch {
1080            /* ignore */
1081          }
1082        }
1083      }
1084    });
1085  
1086    test('returns 0 for all files when coverage file does not exist (ENOENT)', async () => {
1087      // Temporarily rename coverage file if it exists
1088      let hadCoverage = false;
1089      const backupPath = `${coveragePath}.bak`;
1090      try {
1091        await fs.rename(coveragePath, backupPath);
1092        hadCoverage = true;
1093      } catch {
1094        /* ignore */
1095      }
1096  
1097      try {
1098        const result = await agent.getFileCoverage(['src/missing.js', 'src/also-missing.js']);
1099        assert.equal(result['src/missing.js'], 0);
1100        assert.equal(result['src/also-missing.js'], 0);
1101      } finally {
1102        if (hadCoverage) {
1103          try {
1104            await fs.rename(backupPath, coveragePath);
1105          } catch {
1106            /* ignore */
1107          }
1108        }
1109      }
1110    });
1111  });
1112  
1113  // -----------------------------------------------------------------------
1114  // exploratoryTest: no test_areas provided
1115  // -----------------------------------------------------------------------
1116  describe('QAAgent - exploratoryTest without test_areas', () => {
1117    test('completes even without test_areas in context', async () => {
1118      const { db, agent, cleanup } = await createQaEnv();
1119      try {
1120        const taskId = insertTask(db, 'exploratory_testing', {
1121          feature: 'SMS outreach',
1122          // no test_areas
1123        });
1124        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
1125        await agent.processTask(taskRow);
1126  
1127        const updated = getTask(db, taskId);
1128        assert.equal(updated.status, 'completed');
1129        assert.equal(updated.result_json?.manual_testing_required, true);
1130      } finally {
1131        await cleanup();
1132      }
1133    });
1134  
1135    test('exploratoryTest with files but no feature key', async () => {
1136      const { db, agent, cleanup } = await createQaEnv();
1137      try {
1138        const taskId = insertTask(db, 'exploratory_testing', {
1139          files: ['src/outreach/sms.js', 'src/outreach/email.js'],
1140          test_areas: ['bounces', 'retries'],
1141        });
1142        const taskRow = db.prepare('SELECT * FROM agent_tasks WHERE id = ?').get(taskId);
1143        await agent.processTask(taskRow);
1144  
1145        const updated = getTask(db, taskId);
1146        assert.equal(updated.status, 'completed');
1147        const result = updated.result_json;
1148        assert.equal(result?.exploratory_testing_performed, false);
1149      } finally {
1150        await cleanup();
1151      }
1152    });
1153  });