test: synchronize ordered runner events

Release the slow fixture over a local socket after the fast fixture
emits its bypassed completion event. This removes the fixed 30-second
delay while preserving event-order assertions and a bounded failure
timeout.

Signed-off-by: Filip Skokan <panva.ip@gmail.com>
Assisted-by: Codex
PR-URL: #65980
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: LiviaMedeiros <livia@cirno.name>

Author: panva

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

@@ -1,9 +1,11 @@
 import { test } from 'node:test';
-import { setTimeout as sleep } from 'node:timers/promises';
+import { once } from 'node:events';
+import { connect } from 'node:net';
 
 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.
-  await sleep(30_000);
+  // The host closes this connection after receiving fast-fail's bypassed
+  // test:complete event, so this test cannot finish before that event arrives.
+  const socket = connect(Number(process.argv[2]), '127.0.0.1');
+  socket.resume();
+  await once(socket, 'end');
 });

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

@@ -1,24 +1,40 @@
 // Flags: --no-warnings
 
-import '../common/index.mjs';
+import { mustCall, platformTimeout } from '../common/index.mjs';
 import * as fixtures from '../common/fixtures.mjs';
 import assert from 'node:assert';
+import { once } from 'node:events';
+import { createServer } from 'node:net';
 import { test, run } from 'node:test';
 
 const files = [
   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 () => {
+test('execution-ordered events bypass FileTest declaration-order buffer', {
+  timeout: platformTimeout(30_000),
+}, async (t) => {
+  const { promise: fastCompleted, resolve: releaseSlow } = Promise.withResolvers();
+  const server = createServer(mustCall((socket) => {
+    t.after(() => socket.destroy());
+    fastCompleted.then(mustCall(() => {
+      socket.end();
+    }));
+  }));
+  t.after(() => server.close());
+  await once(server.listen(0, '127.0.0.1'), 'listening');
+
   // 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.
+  // files sequentially and fast-fail never starts while slow is waiting.
   const stream = run({
     files,
     isolation: 'process',
     concurrency: 2,
+    argv: [String(server.address().port)],
+    signal: t.signal,
   });
 
   const events = [];
@@ -27,6 +43,9 @@ test('execution-ordered events bypass FileTest declaration-order buffer', async
     if (data.name === 'slow' || data.name === 'fast-fail') {
       events.push(`complete:${data.name}`);
     }
+    if (data.name === 'fast-fail') {
+      releaseSlow();
+    }
   });
 
   stream.on('test:fail', (data) => {