fix(scripts): harden mocha-parallel-files against crashes and silent … (#8243)

* fix(scripts): harden mocha-parallel-files against crashes and silent failures

Several paths in the parallel test runner crashed the parent or hid failures
silently, mostly on Windows. Spawn errors (ENOENT, EAGAIN, EMFILE, AV blocking
the binary) emit `error` not `exit`, so the missing listener turned every
failed spawn into an uncaught parent-side exception. SIGINT/SIGTERM didn't
reach children on Windows where there's no process group to inherit. EPIPE
downgraded real test failures to exit 0. Track live children, handle all
three events, forward signals (escalating to SIGKILL after 1 s), and reuse
`process.exitCode` from the EPIPE path.

JUnit aggregation also lost data: with `jobs === 1` each child wrote its xunit
straight to `junitOutFile` and later children overwrote earlier ones, so CI
got only the last file's results. Sharding is now unconditional.

Smaller correctness fixes folded in: `--timeout 0` was treated as falsy,
the stream-end leftover got flushed without a trailing newline,
`isFailureStartLine` matched any test name containing "N failing", junit
attribute parsing returned `NaN` for malformed input, junit cleanup didn't
survive a Windows file lock, and `globSync` results were sorted per pattern
instead of globally.

* refactor(scripts): align mocha-parallel-files with project style

The bigger items: extracted `Entry` / `EntryStats` / `ParseArgsResult`
typedefs so the `/** @type {...} */ (null)` casts inside the entries factory
and `parseArgs` body go away. Renamed single-letter callback args (`m`, `l`,
`f`, `p`) to expressive names; the for-loop counter `i` in `parseArgs` stays.
Switched the one-shot child events (`message`, `exit`, `error`, `stdout` /
`stderr` 'end') from `.on` to `.once`. Added `@param` JSDoc on every callable
the diff defines or changes — closures included — plus three boy-scout
`@param` blocks on adjacent helpers (`isWarningLine`, `handleStdoutChunk`,
`handleStderrChunk`). No prose lines; method names carry the contracts.

The smaller items: `node:` prefix on the core imports, `error` instead of
`err` in catch handlers, `??` over `||` for the stat-coalesce defaults,
brace the three `if/else` sites, drop the dead `?? ''` after `parts.at(-1)`,
drop the no-op `unknown`-cast on the IPC `msg`, inline `ensureDir` (its
body was a single `fs.mkdirSync` call), and remove the `stableUnique`
one-line helper in favour of an inline `[...new Set(...)]`.

Author: BridgeAR

.github/CODEOWNERS

@@ -283,10 +283,14 @@
 /integration-tests/coverage-fixtures/worker.js @DataDog/lang-platform-js
 /integration-tests/coverage-manual-process.spec.js @DataDog/lang-platform-js
 /integration-tests/init.spec.js @DataDog/lang-platform-js
+/integration-tests/mocha-parallel-files-fixtures/ @DataDog/lang-platform-js
+/integration-tests/mocha-parallel-files.spec.js @DataDog/lang-platform-js
 /integration-tests/package-guardrails.spec.js @DataDog/lang-platform-js
 /integration-tests/package-guardrails/flush.js @DataDog/lang-platform-js
 /integration-tests/startup.spec.js @DataDog/lang-platform-js
 
+/scripts/mocha-parallel-files.js @DataDog/lang-platform-js
+
 /packages/datadog-core @DataDog/lang-platform-js
 /packages/datadog-shimmer @DataDog/lang-platform-js
 /packages/dd-trace/*/crashtracking @DataDog/lang-platform-js

integration-tests/mocha-parallel-files-fixtures/extra-ipc-message.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+
+before(() => {
+  if (typeof process.send === 'function') {
+    process.send({ type: 'unrelated-noise', stamp: Date.now() })
+  }
+})
+
+describe('extra-ipc-message fixture', () => {
+  it('passes after an unrelated IPC payload', () => {
+    assert.strictEqual(1, 1)
+  })
+})

integration-tests/mocha-parallel-files-fixtures/long-running.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const { setTimeout: sleep } = require('node:timers/promises')
+
+describe('long-running fixture', () => {
+  it('runs long enough to be interrupted', async function () {
+    this.timeout(10_000)
+    await sleep(3_000)
+  })
+})

integration-tests/mocha-parallel-files.spec.js

@@ -0,0 +1,97 @@
+'use strict'
+
+const assert = require('node:assert/strict')
+const { spawn } = require('node:child_process')
+const path = require('node:path')
+
+const repoRoot = path.resolve(__dirname, '..')
+const parallelScript = path.join(repoRoot, 'scripts', 'mocha-parallel-files.js')
+const fixturesDir = path.join(__dirname, 'mocha-parallel-files-fixtures')
+
+/**
+ * @typedef {{
+ *   stdout: string,
+ *   stderr: string,
+ *   code: number|null,
+ *   signal: NodeJS.Signals|null
+ * }} ChildResult
+ *
+ * @typedef {{
+ *   killSignal?: NodeJS.Signals,
+ *   killOnFirstStdout?: boolean,
+ *   timeoutMs?: number
+ * }} RunOpts
+ */
+
+/**
+ * @param {string[]} args
+ * @param {RunOpts} [opts]
+ * @returns {Promise<ChildResult>}
+ */
+function runParallel (args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    // Drop CI from the inherited env; otherwise mocha-parallel-files writes a
+    // junit file under the repo root for every spawn here.
+    const env = { ...process.env, CI: '' }
+    const child = spawn(process.execPath, [parallelScript, ...args], { cwd: repoRoot, env })
+    let stdout = ''
+    let stderr = ''
+    let killed = false
+    const fireKill = () => {
+      if (killed || !opts.killSignal) return
+      killed = true
+      child.kill(opts.killSignal)
+    }
+
+    child.stdout.setEncoding('utf8')
+    child.stderr.setEncoding('utf8')
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk
+      // The first stdout chunk proves the parent has finished its bootstrap,
+      // registered SIGINT/SIGTERM handlers, and is forwarding output from a
+      // running child. Sending the signal earlier races the handler setup,
+      // which on slow CI lets the default signal terminate the parent before
+      // it can pin its exit code.
+      if (opts.killOnFirstStdout) fireKill()
+    })
+    child.stderr.on('data', (chunk) => { stderr += chunk })
+
+    const timeoutMs = opts.timeoutMs ?? 20_000
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL')
+      reject(new Error(`mocha-parallel-files did not exit within ${timeoutMs}ms`))
+    }, timeoutMs)
+    timer.unref()
+
+    child.once('error', reject)
+    child.once('exit', (code, signal) => {
+      clearTimeout(timer)
+      resolve({ stdout, stderr, code, signal })
+    })
+  })
+}
+
+describe('mocha-parallel-files script', function () {
+  this.timeout(30_000)
+
+  it('records child stats even when the child sends an unrelated IPC payload first', async () => {
+    const fixture = path.join(fixturesDir, 'extra-ipc-message.js')
+    const { stdout, code, signal } = await runParallel(['--', fixture])
+
+    assert.strictEqual(code, 0)
+    assert.strictEqual(signal, null)
+    assert.match(stdout, /Total:\s+1\b/)
+    assert.match(stdout, /Passed:\s+1\b/)
+    assert.match(stdout, /Failed:\s+0\b/)
+  })
+
+  it('preserves the SIGINT exit code on user interrupt', async function () {
+    if (process.platform === 'win32') {
+      this.skip()
+      return
+    }
+    const fixture = path.join(fixturesDir, 'long-running.js')
+    const { code } = await runParallel(['--', fixture], { killSignal: 'SIGINT', killOnFirstStdout: true })
+    assert.strictEqual(code, 130)
+  })
+})