[Hackathon] fix(test): interrupted delete-batch drops already-acknowledged deletion results #661

import assert from 'node:assert/strict';
import { spawn } from 'node:child_process';
import { once } from 'node:events';
import { mkdtemp, rm } from 'node:fs/promises';
import { createServer } from 'node:http';
import { tmpdir } from 'node:os';
import { join, resolve } from 'node:path';

// Usage: node repro.mjs ./dist/index.js
// Only a loopback mock is used. No real account or TestSprite API is contacted.
const cli = resolve(process.argv[2] ?? './dist/index.js');
const home = await mkdtemp(join(tmpdir(), 'testsprite-delete-interrupt-'));
const ids = ['test_acknowledged', 'test_interrupted', 'test_not_started'];

async function runCase({ mode = 'json', signal, failLast = false, scope = 'ids' }) {
  const requests = [];
  const acknowledged = [];
  let listings = 0;
  let child;
  const server = createServer((req, res) => {
    const path = new URL(req.url, 'http://127.0.0.1').pathname;
    const id = path.split('/').at(-1);
    if (scope === 'all' && req.method === 'GET' && path === '/api/cli/v1/tests') {
      listings += 1;
      res.writeHead(200, { 'content-type': 'application/json' });
      res.end(JSON.stringify({ items: ids.map(testId => ({
        id: testId, projectId: 'proj_fixture', name: testId, type: 'frontend',
        status: 'passed', createdFrom: 'cli', updatedAt: '2026-10-24T00:00:00.000Z',
      })), nextToken: null }));
      return;
    }
    if (req.method !== 'DELETE' || !ids.includes(id)) {
      res.writeHead(400, { 'content-type': 'application/json' });
      res.end(JSON.stringify({ error: { code: 'VALIDATION_ERROR', message: path } }));
      return;
    }
    requests.push(id);
    req.resume();
    req.on('end', () => {
      // A second request proves the CLI has consumed the first success reply.
      // Leave this response pending: its eventual server outcome is unknown.
      if (signal && id === ids[1]) {
        child.kill(signal);
        return;
      }
      res.writeHead(failLast && id === ids[2] ? 400 : 200, {
        'content-type': 'application/json',
      });
      if (failLast && id === ids[2]) {
        res.end(JSON.stringify({ error: {
          code: 'VALIDATION_ERROR', message: 'Mock refusal', nextAction: '',
          requestId: 'mock-refusal', details: {},
        } }));
      } else {
        acknowledged.push(id);
        res.end(JSON.stringify({ testId: id, deletedAt: '2026-10-24T00:00:00.000Z' }));
      }
    });
  });
  server.listen(0, '127.0.0.1');
  await once(server, 'listening');
  const endpoint = `http://127.0.0.1:${server.address().port}`;
  let stdout = '';
  let stderr = '';
  let timedOut = false;
  try {
    child = spawn(process.execPath, [
      cli, '--endpoint-url', endpoint, 'test', 'delete-batch',
      ...(scope === 'all' ? ['--all', '--project', 'proj_fixture', '--status', 'passed'] : ids),
      '--confirm', '--output', mode,
    ], {
      cwd: home,
      env: {
        PATH: process.env.PATH,
        HOME: home,
        USERPROFILE: home,
        XDG_CONFIG_HOME: join(home, 'config'),
        XDG_CACHE_HOME: join(home, 'cache'),
        TESTSPRITE_API_KEY: 'sk-user-local-reproduction-not-a-real-key',
        TESTSPRITE_NO_TELEMETRY: '1',
        DO_NOT_TRACK: '1',
        TESTSPRITE_NO_UPDATE_NOTIFIER: '1',
        CI: 'true',
      },
      stdio: ['ignore', 'pipe', 'pipe'],
    });
    child.stdout.setEncoding('utf8').on('data', chunk => { stdout += chunk; });
    child.stderr.setEncoding('utf8').on('data', chunk => { stderr += chunk; });
    const watchdog = setTimeout(() => {
      timedOut = true;
      child.kill('SIGKILL');
    }, 10_000);
    let exitCode;
    let exitSignal;
    try {
      [exitCode, exitSignal] = await once(child, 'close');
    } finally {
      clearTimeout(watchdog);
    }
    assert.equal(timedOut, false, 'CLI did not exit within 10 seconds');
    assert.equal(exitSignal, null, 'expected a handled signal, not an OS kill');
    assert.equal(listings, scope === 'all' ? 1 : 0);
    if (signal) {
      assert.equal(exitCode, signal === 'SIGINT' ? 130 : 143);
      assert.deepEqual(requests, ids.slice(0, 2));
      assert.deepEqual(acknowledged, ids.slice(0, 1));
      assert.equal(stdout, '', 'reproduction no longer holds: partial output was emitted');
      assert.equal(stderr.includes(ids[0]), false);
      assert.equal(stderr.includes(ids[1]), false);
      assert.equal(stderr.includes(ids[2]), false);
    } else {
      assert.equal(exitCode, failLast ? 1 : 0);
      assert.deepEqual(requests, ids);
      const payload = JSON.parse(stdout);
      assert.equal(payload.results.length, 3);
      assert.equal(payload.summary.deleted, failLast ? 2 : 3);
      assert.equal(payload.summary.failed, failLast ? 1 : 0);
    }
    console.log(JSON.stringify({
      mode, scope, signal: signal ?? 'none', failLast, exitCode, requests, acknowledged,
      stdoutBytes: Buffer.byteLength(stdout),
      ...(signal ? { stderr: stderr.trim() } : {}),
    }));
  } finally {
    server.closeAllConnections();
    await new Promise((done, reject) => server.close(error => error ? reject(error) : done()));
  }
}

try {
  await runCase({});
  await runCase({ failLast: true });
  await runCase({ signal: 'SIGINT' });
  await runCase({ signal: 'SIGTERM' });
  await runCase({ mode: 'text', signal: 'SIGINT' });
  await runCase({ scope: 'all' });
  await runCase({ scope: 'all', signal: 'SIGINT' });
  await runCase({ scope: 'all', signal: 'SIGTERM' });
} finally {
  await rm(home, { recursive: true, force: true });
}