test_runner: dont buffer unordered events in process isolation mode

Signed-off-by: Moshe Atlow <moshe@atlow.co.il>
PR-URL: #63432
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>

Author: MoLow

lib/internal/test_runner/runner.js

@@ -123,6 +123,11 @@ const kDiagnosticsFilterArgs = ['tests', 'suites', 'pass', 'fail', 'cancelled',
 constkCanceledTests=newSafeSet()
 .add(kCancelledByParent).add(kAborted).add(kTestTimeoutFailure);
 
+// Execution-ordered events are forwarded immediately, bypassing the
+// per-file declaration-order buffer.
+constkExecutionOrderedEvents=newSafeSet()
+.add('test:enqueue').add('test:dequeue').add('test:complete');
+
 letkResistStopPropagation;
 
 // Worker ID pool management for concurrent test execution
@@ -318,6 +323,10 @@ class FileTest extends Test {
 }
 }
 addToReport(item){
+if(kExecutionOrderedEvents.has(item.type)){
+this.#handleReportItem(item);
+return;
+}
 this.#accumulateReportItem(item);
 if(!this.isClearToSend()){
 ArrayPrototypePush(this.#reportBuffer,item);

test/fixtures/test-runner/execution-ordered-bypass/fast-fail.mjs

@@ -0,0 +1,6 @@
+import{test}from'node:test';
+importassertfrom'node:assert';
+
+test('fast-fail',()=>{
+assert.fail('fast');
+});

test/fixtures/test-runner/execution-ordered-bypass/slow.mjs

@@ -0,0 +1,9 @@
+import{test}from'node:test';
+import{setTimeoutassleep}from'node:timers/promises';
+
+test('slow',async()=>{
+// Long enough that fast-fail's process can spawn, run, and round-trip its
+// bypassed test:complete to the host on slow CI, but short enough that the
+// test does not waste much time when the bypass is working.
+awaitsleep(30_000);
+});

test/parallel/test-runner-execution-ordered-bypass.mjs

@@ -0,0 +1,59 @@
+// Flags: --no-warnings
+
+import'../common/index.mjs';
+import*asfixturesfrom'../common/fixtures.mjs';
+importassertfrom'node:assert';
+import{test,run}from'node:test';
+
+constfiles=[
+fixtures.path('test-runner','execution-ordered-bypass','slow.mjs'),
+fixtures.path('test-runner','execution-ordered-bypass','fast-fail.mjs'),
+];
+
+test('execution-ordered events bypass FileTest declaration-order buffer',async()=>{
+// Concurrency must be a number so the runner does not collapse it to 1 on
+// single-core CI runners (where `concurrency: true` resolves to
+// `availableParallelism() - 1`). Without two slots the runner spawns the
+// files sequentially and fast-fail never starts while slow is sleeping.
+conststream=run({
+ files,
+isolation: 'process',
+concurrency: 2,
+});
+
+constevents=[];
+
+stream.on('test:complete',(data)=>{
+if(data.name==='slow'||data.name==='fast-fail'){
+events.push(`complete:${data.name}`);
+}
+});
+
+stream.on('test:fail',(data)=>{
+if(data.name==='fast-fail'){
+events.push(`fail:${data.name}`);
+}
+});
+
+// eslint-disable-next-line no-unused-vars
+forawait(const_ofstream);
+
+constcompleteFast=events.indexOf('complete:fast-fail');
+constcompleteSlow=events.indexOf('complete:slow');
+constfailFast=events.indexOf('fail:fast-fail');
+
+assert.notStrictEqual(completeFast,-1);
+assert.notStrictEqual(completeSlow,-1);
+assert.notStrictEqual(failFast,-1);
+
+assert.ok(
+completeFast<completeSlow,
+`test:complete for fast-fail should arrive before slow; events=${events.join(', ')}`,
+);
+
+// test:fail is declaration-ordered, so the bypass must not affect it.
+assert.ok(
+failFast>completeSlow,
+`test:fail for fast-fail should arrive after test:complete for slow; events=${events.join(', ')}`,
+);
+});