fix(junit): preserve suite identity for hook failures reported from workers

[kapil971390]

What's the bug

Under run-workers, when a BeforeSuite/AfterSuite hook fails, the JUnit report puts the failure under a generic <testsuite name="Tests"> instead of the suite that actually failed, and each failure gets split into its own <testsuite> element instead of being grouped with other failures from the same suite.

This is a follow-up to #5657, which fixed the main bug from #5645 (hook failures not appearing in the report at all). That PR's description explicitly notes this as a known limitation:

Under run-workers the forwarded payload (hook.simplify()) doesn't carry the suite, so hook-failure testcases group under a fallback Tests suite instead of the feature title. Fixable later by including the suite title in the worker message.

This PR does that.

Root cause

lib/plugin/junitReporter.js's event.hook.failed listener reads the suite from hook.ctx.test.parent:

const runnable = hook.ctx && hook.ctx.test
const suite = runnable && runnable.parent

On the main thread hook.ctx is a live Mocha context and this works (verified separately with a real Mocha run — ctx.test for a suite-level hook is the hook's own runnable, and runnable.parent is the real Suite). But under run-workers, the failure is forwarded from the worker process via Hook.simplify() (lib/mocha/hooks.js):

simplify() {
  return {
    hookName: this.hookName,
    title: this.title,
    error: this.err ? serializeError(this.err) : null,
  }
}

No ctx, so runnable and suite are both undefined for every worker-forwarded hook failure. buildXml's groupBySuite then keys each failure by itself (test.parent || test), and the suite name falls back to the literal 'Tests':

const suiteName = (suite && suite.title) || 'Tests'

Fix

Hook.simplify() now also serializes the suite identity from this.runnable.parent (the same object the main-thread path already reads successfully):

simplify() {
  const suite = this.runnable?.parent
  return {
    hookName: this.hookName,
    title: this.title,
    error: this.err ? serializeError(this.err) : null,
    suiteTitle: suite?.title || null,
    suiteFile: suite?.file || null,
    suiteTags: suite?.tags || [],
  }
}

junitReporter.js's listener falls back to these fields when hook.ctx is absent, reusing one synthetic suite object per title+file pair so multiple failures from the same worker-reported suite still group into a single <testsuite> instead of one per failure:

let suite = runnable && runnable.parent
if (!suite && hook.suiteTitle) {
  const key = `${hook.suiteTitle} ${hook.suiteFile || ''}`
  if (!workerSuiteByKey.has(key)) {
    workerSuiteByKey.set(key, { title: hook.suiteTitle, file: hook.suiteFile, tags: hook.suiteTags })
  }
  suite = workerSuiteByKey.get(key)
}

Reproduction steps

1. tests/My_test.js:

   Feature('My');
   BeforeSuite(async () => { throw new Error('Before Suite Error'); });
   Scenario('test something', () => {});
   AfterSuite(async () => { throw new Error('After Suite Error'); });

2. codecept.conf.js with junitReporter: { enabled: true }
3. Run: node bin/codecept.js run-workers 2 --config codecept.conf.js
4. Inspect output/report.xml

Before this change:

testsuite name="Tests"
testsuite name="Tests"

After:

testsuite name="My"

(single element, both failures grouped inside)

Edge cases verified

All run against the actual run-workers command, not simulated.

Scenario	Before	After
BeforeSuite + AfterSuite fail, same suite, run-workers	2x <testsuite name="Tests">, one testcase each	1x <testsuite name="My">, both testcases inside
Two different suites each with a failing BeforeSuite/AfterSuite, run-workers	not tested pre-fix (same "Tests" collapse issue)	each suite gets its own correctly-named <testsuite>; no cross-suite mixing
Per-test Before hook failure (not BeforeSuite/AfterSuite), run-workers	unaffected (different hookName, filtered out before this code path)	unaffected, same as before
Plain Scenario failure (no hook failure at all), run-workers	unaffected (goes through result.tests, not hookFailures)	unaffected, same as before
Main-thread (no run-workers) BeforeSuite/AfterSuite failure	correct suite name (existing hook.ctx path)	unchanged — this path doesn't touch the new fallback at all

Existing test suite: mocha test/unit/junitReporter_test.js — 10/10 passing, including the two hook-failure tests already in that file.
Full suite: mocha test/unit — 761 passing, 11 pending, 0 failing.
mocha test/runner — 275 passing, 2 pending, 0 failing.

Out of scope

lib/listener/result.js also listens on event.hook.failed but only for stats counting (failedHooks), unaffected by this change. The other known limitation mentioned in #5657 (_beforeSuite/_afterSuite helper-level failures via suiteSetup/suiteTeardown not emitting event.hook.failed at all) is a separate, pre-existing gap not touched here.

[kapil971390]

Real terminal screenshots of the before/after run-workers reproduction (not simulated) will be attached here manually.
After:

Before: