fix(test): address CodeRabbit review on JUnit report export

Author: SahilRakhaiya05

DOCUMENTATION.md

@@ -348,8 +348,14 @@ testsprite test run test_xxxxxxxx --dry-run --output json
 # Batch BE run with JUnit XML for CI (sidecar; --output json unchanged)
 testsprite test run --all --project proj_xxxxxxxx --wait \
   --report junit --report-file ./results.xml --output json
+
+# Optional custom suite name (default: testsprite:<projectId>)
+testsprite test run --all --project proj_xxxxxxxx --wait \
+  --report junit --report-file ./results.xml --report-suite-name my-ci-suite --output json
 ```
 
+Batch `--report` flags apply only to `test run --all --wait` (and batch `test rerun --wait`). `--report junit --report-file <path>` writes a JUnit XML sidecar after polling completes (atomic write); `--output json` is unchanged. Optional `--report-suite-name <name>` overrides the default `testsprite:<projectId>` suite name.
+
 `--target-url` must be a publicly reachable URL — the CLI pre-flights it against local addresses (`localhost`, `127.x`, `::1`, `0.0.0.0`, `169.254.x`, RFC1918) and the backend resolves it via DNS. For testing against localhost, use the [TestSprite MCP plugin](https://www.testsprite.com/docs), which handles the local tunnel. The CLI auto-mints an idempotency key (printed to stderr at `--verbose`); pass `--idempotency-key <uuid>` to control it explicitly.
 
 #### `testsprite test rerun [test-id...]`
@@ -373,10 +379,16 @@ testsprite test rerun --all --project proj_xxxxxxxx --wait --max-concurrency 4 -
 testsprite test rerun --all --project proj_xxxxxxxx --wait \
   --report junit --report-file ./results.xml --output json
 
+# Optional custom suite name (default: testsprite:<projectId>)
+testsprite test rerun --all --project proj_xxxxxxxx --wait \
+  --report junit --report-file ./results.xml --report-suite-name my-ci-suite --output json
+
 # Several specific tests
 testsprite test rerun test_aaaa test_bbbb --wait --output json
 ```
 
+Batch `--report` flags apply only to batch `--wait` reruns (`--all` or multiple test ids). `--report junit --report-file <path>` writes a JUnit XML sidecar after polling completes (atomic write); `--output json` is unchanged. When `--project` is omitted, the CLI infers `projectId` from polled run rows for classname / default suite naming; if inference fails, pass `--project <id>` explicitly (required under `--dry-run`).
+
 Flags:
 
 - `--all` — rerun every test in the resolved project; requires `--project <id>`.

src/commands/test.run.spec.ts

@@ -3679,6 +3679,24 @@ describe('runTestRunAll — JUnit report export', () => {
     ).rejects.toMatchObject({ code: 'VALIDATION_ERROR', exitCode: 5 });
   });
 
+  it('rejects --report-suite-name without --report', async () => {
+    await expect(
+      runTestRunAll(
+        {
+          profile: 'default',
+          output: 'json',
+          debug: false,
+          projectId: 'project_be',
+          wait: true,
+          timeoutSeconds: 60,
+          maxConcurrency: 5,
+          reportSuiteName: 'orphan-suite',
+        },
+        {},
+      ),
+    ).rejects.toMatchObject({ code: 'VALIDATION_ERROR', exitCode: 5 });
+  });
+
   it('--dry-run --report junit writes canned sample XML', async () => {
     const dir = mkdtempSync(join(tmpdir(), 'junit-run-dry-'));
     const reportPath = join(dir, 'results.xml');
@@ -3706,4 +3724,33 @@ describe('runTestRunAll — JUnit report export', () => {
     expect(xml).toContain('name="test_fresh_wave_01"');
     expect(xml).toContain('failures="1"');
   });
+
+  it('--dry-run --report junit --report-suite-name overrides canned suite name', async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'junit-run-dry-suite-'));
+    const reportPath = join(dir, 'results.xml');
+
+    await runTestRunAll(
+      {
+        profile: 'default',
+        output: 'json',
+        debug: false,
+        dryRun: true,
+        projectId: 'project_be',
+        wait: true,
+        timeoutSeconds: 60,
+        maxConcurrency: 5,
+        report: 'junit',
+        reportFile: reportPath,
+        reportSuiteName: 'ci-checkout-suite',
+      },
+      {
+        stdout: () => undefined,
+        stderr: () => undefined,
+      },
+    );
+
+    const xml = readFileSync(reportPath, 'utf8');
+    expect(xml).toContain('<testsuite name="ci-checkout-suite"');
+    expect(xml).not.toContain('testsprite:project_be');
+  });
 });

src/commands/test.ts

@@ -21,6 +21,7 @@ import { findSample, sampleJUnitReportXml } from '../lib/dry-run/samples.js';
 import {
   assertJUnitReportOptions,
   buildJUnitReport,
+  resolveBatchReportProjectId,
   writeJUnitReportFile,
   type JUnitReportFormat,
   parseJUnitReportFormat,
@@ -5083,15 +5084,16 @@ async function writeBatchJUnitReportIfRequested(
     report?: JUnitReportFormat;
     reportFile?: string;
     reportSuiteName?: string;
-    projectId: string;
+    projectId?: string;
   },
   results: readonly JUnitTestResult[],
 ): Promise<void> {
   if (opts.report !== 'junit' || opts.reportFile === undefined) return;
-  const suiteName = opts.reportSuiteName ?? `testsprite:${opts.projectId}`;
+  const projectId = resolveBatchReportProjectId(opts, results);
+  const suiteName = opts.reportSuiteName ?? `testsprite:${projectId}`;
   const xml = buildJUnitReport({
     suiteName,
-    classname: opts.projectId,
+    classname: projectId,
     results,
   });
   await writeJUnitReportFile(opts.reportFile, xml);
@@ -5159,10 +5161,13 @@ export async function runTestRunAll(
       idempotencyKey,
       ...(opts.wait ? { thenPoll: '/api/cli/v1/runs/<run-id>?waitSeconds=25' } : {}),
     };
-    out.print(batchRunSample ?? envelope);
     if (opts.report === 'junit' && opts.reportFile !== undefined) {
-      await writeJUnitReportFile(opts.reportFile, sampleJUnitReportXml(opts.projectId));
+      await writeJUnitReportFile(
+        opts.reportFile,
+        sampleJUnitReportXml(opts.projectId, opts.reportSuiteName),
+      );
     }
+    out.print(batchRunSample ?? envelope);
     return undefined;
   }
 
@@ -5491,7 +5496,12 @@ export async function runTestRunAll(
         },
         resolveAlternate,
       });
-      return { testId: entry.testId, runId, status: finalRun.status };
+      return {
+        testId: entry.testId,
+        runId,
+        projectId: finalRun.projectId,
+        status: finalRun.status,
+      };
     } catch (err) {
       if (err instanceof TimeoutError) {
         return {
@@ -5573,8 +5583,8 @@ export async function runTestRunAll(
       total: pollable.length,
     },
   };
-  out.print(jsonPayload);
   await writeBatchJUnitReportIfRequested(opts, freshRunResults);
+  out.print(jsonPayload);
 
   // Rate-deferred tests were never dispatched → the batch is incomplete (exit 7),
   // mirroring `test rerun --all`. Checked before the failed-run throw so the
@@ -5636,6 +5646,8 @@ export async function runTestRunAll(
 interface CliRerunResult {
   testId: string;
   runId: string;
+  /** Observed on polled runs; used for JUnit report naming when --project omitted. */
+  projectId?: string;
   /** Terminal status, or 'timeout' for per-run deadline exceeded. */
   status: string;
   /** Set when the test is a closure member (not the user's named test). */
@@ -5751,11 +5763,14 @@ export async function runTestRerun(
         idempotencyKey,
         ...(opts.wait ? { thenPoll: `/api/cli/v1/runs/<run-id>?waitSeconds=25` } : {}),
       };
-      out.print(findSample('POST', '/api/cli/v1/tests/batch/rerun')?.body() ?? envelope);
       if (opts.report === 'junit' && opts.reportFile !== undefined) {
-        const projectKey = opts.projectId ?? 'batch';
-        await writeJUnitReportFile(opts.reportFile, sampleJUnitReportXml(projectKey));
+        const projectKey = resolveBatchReportProjectId(opts, []);
+        await writeJUnitReportFile(
+          opts.reportFile,
+          sampleJUnitReportXml(projectKey, opts.reportSuiteName),
+        );
       }
+      out.print(findSample('POST', '/api/cli/v1/tests/batch/rerun')?.body() ?? envelope);
     }
     void client;
     return undefined;
@@ -6655,7 +6670,12 @@ export async function runTestRerun(
         },
         resolveAlternate,
       });
-      return { testId: entry.testId, runId: entry.runId, status: finalRun.status };
+      return {
+        testId: entry.testId,
+        runId: entry.runId,
+        projectId: finalRun.projectId,
+        status: finalRun.status,
+      };
     } catch (err) {
       if (err instanceof TimeoutError) {
         return {
@@ -6743,9 +6763,8 @@ export async function runTestRerun(
       total: accepted.length,
     },
   };
+  await writeBatchJUnitReportIfRequested(opts, rerunResults);
   out.print(jsonPayload);
-  const reportProjectId = opts.projectId ?? 'batch';
-  await writeBatchJUnitReportIfRequested({ ...opts, projectId: reportProjectId }, rerunResults);
 
   // Determine exit code: timeout (deferred or any timeout) → 7; any fail → 1; all pass → 0
   if (deferred.length > 0 || timedOut > 0) {

src/lib/dry-run/samples.test.ts

@@ -11,6 +11,12 @@ describe('sampleJUnitReportXml', () => {
     expect(xml).toContain('name="test_fresh_wave_02"');
     expect(xml).toContain('failures="1"');
   });
+
+  it('honors reportSuiteName override', () => {
+    const xml = sampleJUnitReportXml('proj_dry', 'custom-ci-suite');
+    expect(xml).toContain('<testsuite name="custom-ci-suite"');
+    expect(xml).not.toContain('testsprite:proj_dry');
+  });
 });
 
 describe('findSample', () => {

src/lib/dry-run/samples.ts

@@ -72,9 +72,12 @@ export const SAMPLE_DRY_RUN_REQUEST_ID = SAMPLE_REQUEST_ID;
  * Canned JUnit XML for batch `--wait --report junit --dry-run`. Mirrors the
  * fresh batch-run sample ids so agents can learn the sidecar shape offline.
  */
-export function sampleJUnitReportXml(projectId: string = SAMPLE_PROJECT_ID): string {
+export function sampleJUnitReportXml(
+  projectId: string = SAMPLE_PROJECT_ID,
+  reportSuiteName?: string,
+): string {
   return buildJUnitReport({
-    suiteName: `testsprite:${projectId}`,
+    suiteName: reportSuiteName ?? `testsprite:${projectId}`,
     classname: projectId,
     results: [
       {

src/lib/junit-report.test.ts

@@ -8,6 +8,7 @@ import {
   buildJUnitReport,
   escapeXml,
   parseJUnitReportFormat,
+  resolveBatchReportProjectId,
   writeJUnitReportFile,
   type JUnitTestResult,
 } from './junit-report.js';
@@ -61,6 +62,16 @@ describe('assertJUnitReportOptions', () => {
     ).toThrowError(ApiError);
   });
 
+  it('rejects report-suite-name without report', () => {
+    expect(() =>
+      assertJUnitReportOptions({
+        reportSuiteName: 'my-suite',
+        wait: true,
+        batchPath: true,
+      }),
+    ).toThrowError(ApiError);
+  });
+
   it('rejects report on non-batch paths', () => {
     expect(() =>
       assertJUnitReportOptions({
@@ -90,6 +101,26 @@ describe('assertJUnitReportOptions', () => {
   });
 });
 
+describe('resolveBatchReportProjectId', () => {
+  it('prefers explicit projectId', () => {
+    expect(resolveBatchReportProjectId({ projectId: 'proj_a' }, [])).toBe('proj_a');
+  });
+
+  it('infers from polled run rows', () => {
+    expect(resolveBatchReportProjectId({}, [{ projectId: 'proj_from_run' }])).toBe('proj_from_run');
+  });
+
+  it('requires --project when the project cannot be inferred', () => {
+    expect(() => resolveBatchReportProjectId({}, [])).toThrowError(ApiError);
+    try {
+      resolveBatchReportProjectId({}, []);
+    } catch (err) {
+      expect((err as ApiError).code).toBe('VALIDATION_ERROR');
+      expect((err as ApiError).exitCode).toBe(5);
+    }
+  });
+});
+
 describe('buildJUnitReport', () => {
   it('renders an empty suite', () => {
     const xml = buildJUnitReport({

src/lib/junit-report.ts

@@ -11,6 +11,8 @@ export interface JUnitTestResult {
   testId: string;
   runId?: string;
   status: string;
+  /** Observed on polled runs; used for classname when --project is omitted. */
+  projectId?: string;
   error?: { code: string; message: string; exitCode?: number };
 }
 
@@ -49,6 +51,12 @@ export function assertJUnitReportOptions(opts: JUnitReportFlagOptions): void {
     if (opts.reportFile !== undefined && opts.reportFile !== '') {
       throw localValidationError('report-file', '--report-file requires --report junit');
     }
+    if (opts.reportSuiteName !== undefined && opts.reportSuiteName !== '') {
+      throw localValidationError(
+        'report-suite-name',
+        '--report-suite-name requires --report junit',
+      );
+    }
     return;
   }
 
@@ -69,6 +77,23 @@ export function assertJUnitReportOptions(opts: JUnitReportFlagOptions): void {
   }
 }
 
+/**
+ * Resolve the project id used for JUnit classname / default suite naming.
+ * Prefer explicit `--project`, then ids observed on polled run rows.
+ */
+export function resolveBatchReportProjectId(
+  opts: { projectId?: string },
+  results: ReadonlyArray<{ projectId?: string }>,
+): string {
+  if (opts.projectId) return opts.projectId;
+  const fromPoll = results.map(r => r.projectId).find((id): id is string => !!id);
+  if (fromPoll) return fromPoll;
+  throw localValidationError(
+    'project',
+    '--report junit requires --project <id> when the project cannot be inferred from run results',
+  );
+}
+
 /**
  * Escape text for inclusion in XML element bodies and double-quoted attributes.
  */