faf-taf-git 2.3.1 → 2.4.1

package/src/parsers/junit.ts

@@ -0,0 +1,110 @@
+/**
+ * JUnit XML parser
+ *
+ * Extracts test counts from a JUnit XML report — the common format nearly every
+ * test runner can write: pytest (--junitxml), cargo (nextest, cargo2junit), Go
+ * (go-junit-report, gotestsum), Maven/Gradle, .NET, PHPUnit, Jest (jest-junit).
+ */
+
+import { TestResults } from './jest';
+
+const SUITE_TAG = /<(\/?)testsuite\b([^>]*?)(\/?)>/g;
+
+/** Read one numeric attribute; undefined when the attribute is absent. */
+function attr(attrs: string, name: string): number | undefined {
+  const match = attrs.match(new RegExp(`\\b${name}\\s*=\\s*["'](\\d+)["']`));
+  return match ? parseInt(match[1], 10) : undefined;
+}
+
+interface Counts {
+  tests: number;
+  failed: number;
+  skipped: number;
+}
+
+/** Counts from a <testsuite> or <testsuites> attribute list, or null without a `tests` count. */
+function countsFromAttrs(attrs: string): Counts | null {
+  const tests = attr(attrs, 'tests');
+  if (tests === undefined) return null;
+  return {
+    tests,
+    failed: (attr(attrs, 'failures') ?? 0) + (attr(attrs, 'errors') ?? 0),
+    skipped: (attr(attrs, 'skipped') ?? 0) + (attr(attrs, 'disabled') ?? 0),
+  };
+}
+
+/** Fallback when suites carry no counts: walk the <testcase> elements themselves. */
+function countsFromTestcases(xml: string): Counts {
+  const counts: Counts = { tests: 0, failed: 0, skipped: 0 };
+  const testcase = /<testcase\b[^>]*?(?:\/>|>([\s\S]*?)<\/testcase>)/g;
+  let match: RegExpExecArray | null;
+  while ((match = testcase.exec(xml)) !== null) {
+    counts.tests++;
+    const body = match[1] ?? '';
+    if (/<(failure|error)\b/.test(body)) counts.failed++;
+    else if (/<skipped\b/.test(body)) counts.skipped++;
+  }
+  return counts;
+}
+
+/**
+ * Parse a JUnit XML report to extract test results
+ *
+ * Handles:
+ * - a <testsuites> root that carries the totals (gotestsum, Maven)
+ * - a <testsuites> root without totals, around counted <testsuite>s (pytest)
+ * - a single <testsuite> root
+ * - nested <testsuite>s (only the outermost level is counted, never twice)
+ * - suites with no counts at all (the <testcase> elements are counted instead)
+ *
+ * failures + errors count as failed; skipped + disabled count as skipped.
+ */
+export function parseJunitOutput(output: string): TestResults | null {
+  const xml = output.replace(/<!--[\s\S]*?-->/g, '');
+  if (!/<testsuites?\b/.test(xml)) return null;
+
+  let counts: Counts | null = null;
+
+  const root = xml.match(/<testsuites\b([^>]*)>/);
+  if (root) counts = countsFromAttrs(root[1]);
+
+  if (!counts) {
+    // Sum the outermost <testsuite>s; a suite without counts sends us to the testcases.
+    let depth = 0;
+    let summed: Counts | null = { tests: 0, failed: 0, skipped: 0 };
+    let seen = 0;
+    let match: RegExpExecArray | null;
+    SUITE_TAG.lastIndex = 0;
+    while ((match = SUITE_TAG.exec(xml)) !== null) {
+      const [, closing, attrs, selfClosing] = match;
+      if (closing) {
+        depth--;
+        continue;
+      }
+      if (depth === 0 && summed) {
+        seen++;
+        const suite = countsFromAttrs(attrs);
+        if (suite) {
+          summed.tests += suite.tests;
+          summed.failed += suite.failed;
+          summed.skipped += suite.skipped;
+        } else {
+          summed = null;
+        }
+      }
+      if (!selfClosing) depth++;
+    }
+    counts = seen > 0 && summed ? summed : countsFromTestcases(xml);
+  }
+
+  if (counts.tests === 0) return null;
+
+  const passed = Math.max(0, counts.tests - counts.failed - counts.skipped);
+  return {
+    total: counts.tests,
+    passed,
+    failed: counts.failed,
+    skipped: counts.skipped > 0 ? counts.skipped : undefined,
+    result: counts.failed > 0 ? 'FAILED' : 'PASSED',
+  };
+}

package/tests/cli-version.test.ts

@@ -0,0 +1,31 @@
+/**
+ * `faf-taf-git --version` is a stranger's first command. Before 2.4.1 it fell
+ * through to "No test output file specified" and exit 1 (found by /dev-notes
+ * on the published 2.4.0).
+ */
+import { spawnSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { cliVersion } from '../src/cli';
+
+const root = path.join(__dirname, '..');
+const pkgVersion = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8')).version;
+const bin = path.join(root, 'dist', 'cli.js');
+
+describe('--version', () => {
+  test('cliVersion() is the package.json version', () => {
+    expect(cliVersion()).toBe(pkgVersion);
+  });
+
+  test.each(['--version', '-V'])('the built bin answers %s with the version and exit 0', (flag) => {
+    const r = spawnSync(process.execPath, [bin, flag], { encoding: 'utf-8' });
+    expect(r.status).toBe(0);
+    expect(r.stdout.trim()).toBe(pkgVersion);
+  });
+
+  test('-v is still --verbose, not the version', () => {
+    const r = spawnSync(process.execPath, [bin, '-v'], { encoding: 'utf-8' });
+    expect(r.status).toBe(1);
+    expect(r.stderr).toContain('No test output file specified');
+  });
+});

package/tests/junit-parser.test.ts

@@ -0,0 +1,109 @@
+/**
+ * JUnit XML Parser Tests
+ */
+
+import { parseJunitOutput } from '../src/parsers/junit';
+import { parseTestOutput, SUPPORTED_PARSERS } from '../src/parsers';
+
+describe('JUnit XML Parser', () => {
+  describe('parseJunitOutput', () => {
+    test('should parse a pytest report (<testsuites> root without totals)', () => {
+      const output = `<?xml version="1.0" encoding="utf-8"?>
+<testsuites name="pytest tests"><testsuite name="pytest" errors="0" failures="1" skipped="2" tests="12" time="0.4" timestamp="2026-10-29T20:00:00" hostname="runner">
+<testcase classname="tests.test_a" name="test_ok" time="0.001" />
+<testcase classname="tests.test_a" name="test_bad" time="0.002"><failure message="assert 1 == 2">assert 1 == 2</failure></testcase>
+</testsuite></testsuites>`;
+      const result = parseJunitOutput(output);
+      expect(result).toEqual({ total: 12, passed: 9, failed: 1, skipped: 2, result: 'FAILED' });
+    });
+
+    test('should use the totals on a <testsuites> root (gotestsum, Maven)', () => {
+      const output = `<testsuites tests="40" failures="0" errors="0" skipped="3">
+  <testsuite name="pkg/a" tests="25" failures="0" errors="0" skipped="1"></testsuite>
+  <testsuite name="pkg/b" tests="15" failures="0" errors="0" skipped="2"></testsuite>
+</testsuites>`;
+      expect(parseJunitOutput(output)).toEqual({ total: 40, passed: 37, failed: 0, skipped: 3, result: 'PASSED' });
+    });
+
+    test('should sum the suites when the root has no totals (cargo2junit)', () => {
+      const output = `<testsuites>
+  <testsuite id="0" name="faf_rust_sdk" package="testsuite/faf_rust_sdk" tests="30" errors="0" failures="0" hostname="localhost" timestamp="2026-10-29T20:00:00Z" time="0">
+    <testcase name="parses_minimal" time="0" />
+  </testsuite>
+  <testsuite id="1" name="integration" tests="8" errors="1" failures="0" skipped="0" time="0"></testsuite>
+</testsuites>`;
+      expect(parseJunitOutput(output)).toEqual({ total: 38, passed: 37, failed: 1, skipped: undefined, result: 'FAILED' });
+    });
+
+    test('should parse a single <testsuite> root', () => {
+      const output = `<?xml version="1.0"?>
+<testsuite name="jest tests" tests="7" failures="0" errors="0" skipped="0"></testsuite>`;
+      expect(parseJunitOutput(output)).toEqual({ total: 7, passed: 7, failed: 0, skipped: undefined, result: 'PASSED' });
+    });
+
+    test('should count nested suites once (outermost level only)', () => {
+      const output = `<testsuites>
+  <testsuite name="outer" tests="5" failures="0" errors="0">
+    <testsuite name="inner" tests="5" failures="0" errors="0"></testsuite>
+  </testsuite>
+</testsuites>`;
+      expect(parseJunitOutput(output)!.total).toBe(5);
+    });
+
+    test('should count failures and errors together as failed', () => {
+      const output = `<testsuite tests="10" failures="2" errors="1" skipped="1"></testsuite>`;
+      expect(parseJunitOutput(output)).toEqual({ total: 10, passed: 6, failed: 3, skipped: 1, result: 'FAILED' });
+    });
+
+    test('should count disabled tests as skipped', () => {
+      const output = `<testsuites tests="6" failures="0" errors="0" disabled="2"></testsuites>`;
+      expect(parseJunitOutput(output)).toEqual({ total: 6, passed: 4, failed: 0, skipped: 2, result: 'PASSED' });
+    });
+
+    test('should count <testcase> elements when the suites carry no counts', () => {
+      const output = `<testsuites><testsuite name="bare">
+  <testcase name="a" />
+  <testcase name="b"><failure message="boom" /></testcase>
+  <testcase name="c"><skipped /></testcase>
+  <testcase name="d"><error message="crash" /></testcase>
+</testsuite></testsuites>`;
+      expect(parseJunitOutput(output)).toEqual({ total: 4, passed: 1, failed: 2, skipped: 1, result: 'FAILED' });
+    });
+
+    test('should accept single-quoted attributes', () => {
+      expect(parseJunitOutput(`<testsuite tests='3' failures='0'></testsuite>`)!.total).toBe(3);
+    });
+
+    test('should ignore a commented-out suite', () => {
+      const output = `<!-- <testsuite tests="99" failures="9"></testsuite> -->
+<testsuite tests="2" failures="0"></testsuite>`;
+      expect(parseJunitOutput(output)).toEqual({ total: 2, passed: 2, failed: 0, skipped: undefined, result: 'PASSED' });
+    });
+
+    test('should return null for a report with zero tests', () => {
+      expect(parseJunitOutput(`<testsuites><testsuite tests="0" failures="0"></testsuite></testsuites>`)).toBeNull();
+    });
+
+    test('should return null for output that is not JUnit XML', () => {
+      expect(parseJunitOutput('Tests: 173 passed, 173 total')).toBeNull();
+      expect(parseJunitOutput('')).toBeNull();
+    });
+  });
+
+  describe('parseTestOutput routing', () => {
+    test('should list JUnit XML first among the supported parsers', () => {
+      expect(SUPPORTED_PARSERS[0]).toBe('JUnit XML');
+    });
+
+    test('should read the XML counts even when captured stdout holds another summary line', () => {
+      const output = `<testsuite tests="20" failures="0" errors="0" skipped="0">
+  <system-out>Tests: 3 passed, 3 total</system-out>
+</testsuite>`;
+      expect(parseTestOutput(output)!.total).toBe(20);
+    });
+
+    test('should still route plain Jest output to the Jest parser', () => {
+      expect(parseTestOutput('Tests: 1 failed, 172 passed, 173 total')!.total).toBe(173);
+    });
+  });
+});