[Hackathon] fix(rerun): JUnit drops undispatched tests and keeps stale reports when no runs are accepted #476

import assert from 'node:assert/strict';
import { execFile } from 'node:child_process';
import { mkdtemp, readFile, writeFile, rm } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { promisify } from 'node:util';

// The real compiled CLI runs with fetch fully replaced by an offline fixture.
// No live account, service, test execution, or credits are involved.
const exec = promisify(execFile);
const root = resolve(process.argv[2] ?? 'work/testsprite-cli');
const temp = await mkdtemp(join(tmpdir(), 'testsprite-rerun-junit-'));
const preload = join(temp, 'fixture.mjs');
await writeFile(preload, `
import assert from 'node:assert/strict';
import { writeFileSync } from 'node:fs';
const scenario = JSON.parse(process.env.REPRO_SCENARIO);
const trace = [];
process.on('exit', () => writeFileSync(process.env.REPRO_TRACE, JSON.stringify(trace)));
const json = body => new Response(JSON.stringify(body), {status:200,headers:{'content-type':'application/json'}});
const ids = ['test_1','test_2'];
const rows = ids.map(id => ({id,name:id,projectId:'project_fixture',type:'frontend',
  createdFrom:'cli',createdAt:'2026-10-16T00:00:00Z',updatedAt:'2026-10-17T00:00:00Z',status:'passed'}));
globalThis.fetch = async (input, init = {}) => {
  const url = new URL(typeof input === 'string' ? input : input.url ?? input.href);
  const method = init.method ?? 'GET';
  const body = init.body ? JSON.parse(String(init.body)) : undefined;
  trace.push({method,path:url.pathname,...(body?{body}:{})});
  assert.equal(url.hostname,'mock.example.com','unexpected network destination');
  const path = url.pathname.replace('/api/cli/v1','');
  if (method === 'GET' && path === '/tests') return json({items:rows,nextToken:null});
  if (method === 'GET' && path === '/projects/project_fixture/env') return json({environments:[]});
  if (method === 'GET' && path.startsWith('/tests/')) {
    const row = rows.find(row => path === '/tests/'+row.id);
    if (row) return json(row);
  }
  if (method === 'POST' && ['/tests/batch/rerun','/tests/batch/run'].includes(path)) {
    const selected = body.testIds ?? ids;
    const accepted = selected.filter(id => scenario.allPassed || (!scenario.none && id === 'test_1'))
      .map(testId => ({testId,runId:'run_'+testId,enqueuedAt:'2026-10-17T00:00:00Z'}));
    const skipped = selected.filter(id => !accepted.some(row => row.testId === id));
    return json({accepted,
      notFound:scenario.kind === 'notFound' ? skipped : [],
      deferred:scenario.kind === 'deferred' ? skipped.map(testId => ({testId,reason:'rate_limited'})) : [],
      conflicts:scenario.kind === 'conflicts' ? skipped.map(testId => ({testId,reason:'in_flight'})) : [],
      closure:{byProject:[]},skippedFrontend:[],skippedIntegration:[],
    });
  }
  if (method === 'GET' && path.startsWith('/runs/')) {
    const runId = path.slice('/runs/'.length);
    const testId = runId.slice('run_'.length);
    assert.ok(ids.includes(testId),'unexpected run');
    return json({runId,testId,status:'passed',projectId:'project_fixture',userId:'fixture_user',source:'cli',
      createdAt:'2026-10-17T00:00:00Z',startedAt:'2026-10-17T00:00:01Z',finishedAt:'2026-10-17T00:00:02Z',
      codeVersion:'v1',targetUrl:'https://example.com',createdFrom:'rerun:previous',
      failedStepIndex:null,failureKind:null,error:null,videoUrl:null,
      stepSummary:{total:1,completed:1,passedCount:1,failedCount:0}});
  }
  throw new Error('Unexpected fixture route: '+method+' '+path);
};
`);

const cases = [
  {name:'rerun-all-passed-control',allPassed:true,code:0,xmlTests:2,xmlSkipped:0,summarySkipped:0},
  {name:'rerun-partial-notFound',kind:'notFound',code:0,xmlTests:1,xmlSkipped:0,summarySkipped:1},
  {name:'rerun-all-selection-partial-notFound',all:true,kind:'notFound',code:0,xmlTests:1,xmlSkipped:0,summarySkipped:1},
  {name:'rerun-partial-conflicts',kind:'conflicts',code:0,xmlTests:1,xmlSkipped:0,summarySkipped:1},
  {name:'rerun-partial-deferred',kind:'deferred',code:7,xmlTests:1,xmlSkipped:0,summarySkipped:1},
  {name:'rerun-none-notFound',kind:'notFound',none:true,code:4,missing:true,summarySkipped:2},
  {name:'rerun-none-conflicts',kind:'conflicts',none:true,code:6,missing:true,summarySkipped:2},
  {name:'rerun-none-deferred',kind:'deferred',none:true,code:7,missing:true,summarySkipped:2},
  {name:'rerun-none-notFound-stale-report',kind:'notFound',none:true,seed:true,code:4,stale:true,summarySkipped:2},
  {name:'fresh-partial-conflicts-control',fresh:true,kind:'conflicts',code:6,xmlTests:2,xmlSkipped:1,summarySkipped:1},
  {name:'fresh-none-conflicts-control',fresh:true,kind:'conflicts',none:true,code:6,xmlTests:2,xmlSkipped:2,summarySkipped:2},
];
const results = [];
const staleReport = '<?xml version="1.0"?><testsuites><testsuite name="old-run" tests="9" failures="0" errors="0" skipped="0"/></testsuites>\n';
try {
  for (const scenario of cases) {
    const traceFile = join(temp,scenario.name+'.trace.json');
    const reportFile = join(temp,scenario.name+'.xml');
    const summaryFile = join(temp,scenario.name+'.summary.json');
    if (scenario.seed) await writeFile(reportFile,staleReport);
    const args = ['test',scenario.fresh?'run':'rerun',
      ...(scenario.fresh||scenario.all?['--all']:['test_1','test_2']),
      '--project','project_fixture','--wait','--timeout','1','--output','json',
      '--report','junit','--report-file',reportFile,'--summary-file',summaryFile];
    let stdout = '', stderr = '', code = 0;
    try {
      ({stdout,stderr} = await exec(process.execPath,['--import',preload,join(root,'dist/index.js'),...args],{
        cwd:temp,timeout:15000,
        env:{PATH:dirname(process.execPath)+':/usr/bin:/bin',HOME:temp,
          TESTSPRITE_API_KEY:'sk-user-offline-fixture',TESTSPRITE_API_URL:'https://mock.example.com',
          TESTSPRITE_NO_TELEMETRY:'1',TESTSPRITE_NO_UPDATE_NOTIFIER:'1',
          REPRO_SCENARIO:JSON.stringify(scenario),REPRO_TRACE:traceFile},
      }));
    } catch (err) {
      if (typeof err.code !== 'number') throw err;
      ({stdout,stderr,code} = err);
    }
    assert.equal(code,scenario.code,scenario.name+' exit; stderr: '+stderr);
    const trace = JSON.parse(await readFile(traceFile,'utf8'));
    const summary = JSON.parse(await readFile(summaryFile,'utf8'));
    const xml = await readFile(reportFile,'utf8').catch(err => {if(err.code==='ENOENT')return null;throw err;});
    assert.equal(code,scenario.code,scenario.name+' exit; stderr: '+stderr);
    assert.equal(summary.total,2,scenario.name+' summary.total');
    assert.equal(summary.skipped,scenario.summarySkipped,scenario.name+' summary.skipped');
    if (scenario.missing) assert.equal(xml,null,scenario.name+' missing XML');
    else if (scenario.stale) assert.equal(xml,staleReport,scenario.name+' unchanged old XML');
    else {
      assert.ok(xml.includes('tests="'+scenario.xmlTests+'"'),scenario.name+' XML count: '+xml);
      assert.ok(xml.includes('skipped="'+scenario.xmlSkipped+'"'),scenario.name+' XML skipped');
      if (!scenario.allPassed && !scenario.fresh) assert.ok(!xml.includes('test_2'),scenario.name+' missing member');
    }
    results.push({name:scenario.name,exitCode:code,summary,xml,trace,stdout,stderr});
  }
  console.log(JSON.stringify({node:process.version,platform:process.platform,results},null,2));
} finally { await rm(temp,{recursive:true,force:true}); }