test_runner: show interrupted test on SIGINT

When the test runner process is killed with SIGINT (Ctrl+C), display
which test was running at the time of interruption. This makes it
easier to identify tests that hang or take too long.
- Add `test:interrupted` event emitted when SIGINT is received
- Add `interrupted()` method to TestsStream
- Handle the event in both TAP and spec reporters
- TAP outputs: `# Interrupted while running: <test>`
- Spec outputs with yellow header and warning symbol
- Use setImmediate to allow reporter stream to flush before exit
With process isolation (default), shows the file path since the
parent runner only knows about file-level tests.
With --test-isolation=none, shows the actual test name.
PR-URL: #61676
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>

Author: mcollina

doc/api/test.md

@@ -3343,6 +3343,32 @@ This event is guaranteed to be emitted in the same order as the tests are
 defined.
 The corresponding execution ordered event is `'test:complete'`.
 
+### Event: `'test:interrupted'`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+*`data` {Object}
+*`tests` {Array} An array of objects containing information about the
+ interrupted tests.
+*`column` {number|undefined} The column number where the test is defined,
+ or `undefined` if the test was run through the REPL.
+*`file` {string|undefined} The path of the test file,
+`undefined` if test was run through the REPL.
+*`line` {number|undefined} The line number where the test is defined, or
+`undefined` if the test was run through the REPL.
+*`name` {string} The test name.
+*`nesting` {number} The nesting level of the test.
+
+Emitted when the test runner is interrupted by a `SIGINT` signal (e.g., when
+pressing <kbd>Ctrl</kbd>+<kbd>C</kbd>). The event contains information about
+the tests that were running at the time of interruption.
+
+When using process isolation (the default), the test name will be the file path
+since the parent runner only knows about file-level tests. When using
+`--test-isolation=none`, the actual test name is shown.
+
 ### Event: `'test:pass'`
 
 *`data` {Object}

lib/internal/test_runner/harness.js

@@ -3,6 +3,7 @@ const {
  ArrayPrototypeForEach,
  ArrayPrototypePush,
  FunctionPrototypeBind,
+ Promise,
  PromiseResolve,
  PromiseWithResolvers,
  SafeMap,
@@ -32,7 +33,7 @@ const { PassThrough, compose } = require('stream');
 const{ reportReruns }=require('internal/test_runner/reporter/rerun');
 const{ queueMicrotask }=require('internal/process/task_queues');
 const{TIMEOUT_MAX}=require('internal/timers');
-const{ clearInterval, setInterval }=require('timers');
+const{ clearInterval,setImmediate,setInterval }=require('timers');
 const{bigint: hrtime}=process.hrtime;
 consttestResources=newSafeMap();
 letglobalRoot;
@@ -289,7 +290,33 @@ function setupProcessState(root, globalOptions) {
 }
 };
 
+constfindRunningTests=(test,running=[])=>{
+if(test.startTime!==null&&!test.finished){
+for(leti=0;i<test.subtests.length;i++){
+findRunningTests(test.subtests[i],running);
+}
+// Only add leaf tests (innermost running tests)
+if(test.activeSubtests===0&&test.name!=='<root>'){
+ArrayPrototypePush(running,{
+__proto__: null,
+name: test.name,
+nesting: test.nesting,
+file: test.loc?.file,
+line: test.loc?.line,
+column: test.loc?.column,
+});
+}
+}
+returnrunning;
+};
+
 constterminationHandler=async()=>{
+construnningTests=findRunningTests(root);
+if(runningTests.length>0){
+root.reporter.interrupted(runningTests);
+// Allow the reporter stream to process the interrupted event
+awaitnewPromise((resolve)=>setImmediate(resolve));
+}
 awaitexitHandler(true);
 process.exit();
 };

lib/internal/test_runner/reporter/spec.js

@@ -106,8 +106,31 @@ class SpecReporter extends Transform {
 break;
 case'test:watch:restarted':
 return`\nRestarted at ${DatePrototypeToLocaleString(newDate())}\n`;
+case'test:interrupted':
+returnthis.#formatInterruptedTests(data.tests);
 }
 }
+ #formatInterruptedTests(tests){
+if(tests.length===0){
+return'';
+}
+
+constresults=[
+`\n${colors.yellow}Interrupted while running:${colors.white}\n`,
+];
+
+for(leti=0;i<tests.length;i++){
+consttest=tests[i];
+letmsg=`${indent(test.nesting)}${reporterUnicodeSymbolMap['warning:alert']}${test.name}`;
+if(test.file){
+constrelPath=relative(this.#cwd,test.file);
+msg+=` ${colors.gray}(${relPath}:${test.line}:${test.column})${colors.white}`;
+}
+ArrayPrototypePush(results,msg);
+}
+
+returnArrayPrototypeJoin(results,'\n')+'\n';
+}
 _transform({ type, data },encoding,callback){
 callback(null,this.#handleEvent({__proto__: null, type, data }));
 }

lib/internal/test_runner/reporter/tap.js

@@ -61,6 +61,16 @@ async function * tapReporter(source) {
 case'test:coverage':
 yieldgetCoverageReport(indent(data.nesting),data.summary,'# ','',true);
 break;
+case'test:interrupted':
+for(leti=0;i<data.tests.length;i++){
+consttest=data.tests[i];
+letmsg=`Interrupted while running: ${test.name}`;
+if(test.file){
+msg+=` at ${test.file}:${test.line}:${test.column}`;
+}
+yield`# ${tapEscape(msg)}\n`;
+}
+break;
 }
 }
 }

lib/internal/test_runner/tests_stream.js

@@ -149,6 +149,13 @@ class TestsStream extends Readable {
 });
 }
 
+interrupted(tests){
+this[kEmitMessage]('test:interrupted',{
+__proto__: null,
+ tests,
+});
+}
+
 end(){
 this.#tryPush(null);
 }

test/parallel/test-runner-exit-code.js

@@ -6,7 +6,7 @@ const { spawnSync, spawn } = require('child_process');
 const{ once }=require('events');
 const{ finished }=require('stream/promises');
 
-asyncfunctionrunAndKill(file){
+asyncfunctionrunAndKill(file,expectedTestName){
 if(common.isWindows){
 common.printSkipMessage(`signals are not supported in windows, skipping ${file}`);
 return;
@@ -21,6 +21,9 @@ async function runAndKill(file) {
 const[code,signal]=awaitonce(child,'exit');
 awaitfinished(child.stdout);
 assert(stdout.startsWith('TAP version 13\n'));
+// Verify interrupted test message
+assert(stdout.includes(`Interrupted while running: ${expectedTestName}`),
+`Expected output to contain interrupted test name`);
 assert.strictEqual(signal,null);
 assert.strictEqual(code,1);
 }
@@ -67,6 +70,10 @@ if (process.argv[2] === 'child') {
 assert.strictEqual(child.status,1);
 assert.strictEqual(child.signal,null);
 
-runAndKill(fixtures.path('test-runner','never_ending_sync.js')).then(common.mustCall());
-runAndKill(fixtures.path('test-runner','never_ending_async.js')).then(common.mustCall());
+// With process isolation (default), the test name shown is the file path
+// because the parent runner only knows about file-level tests
+constneverEndingSync=fixtures.path('test-runner','never_ending_sync.js');
+constneverEndingAsync=fixtures.path('test-runner','never_ending_async.js');
+runAndKill(neverEndingSync,neverEndingSync).then(common.mustCall());
+runAndKill(neverEndingAsync,neverEndingAsync).then(common.mustCall());
 }