test_runner: support using --inspect with --test

PR-URL: #44520 Backport-PR-URL: #44873 Reviewed-By: Benjamin Gruenbaum <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]>

Author: MoLow

doc/api/test.md

@@ -338,6 +338,11 @@ added: REPLACEME
  fail after.
  If unspecified, subtests inherit this value from their parent.
 **Default:**`Infinity`.
+*`inspectPort`{number|Function} Sets inspector port of test child process.
+ This can be a number, or a function that takes no arguments and returns a
+ number. If a nullish value is provided, each process gets its own port,
+ incremented from the primary's `process.debugPort`.
+**Default:**`undefined`.
 * Returns:{TapStream}
 
 ```js

lib/internal/cluster/primary.js

@@ -120,6 +120,7 @@ function createWorkerProcess(id, env){
 constdebugArgRegex=/--inspect(?:-brk|-port)?|--debug-port/;
 constnodeOptions=process.env.NODE_OPTIONS||'';
 
+// TODO(MoLow): Use getInspectPort from internal/util/inspector
 if(ArrayPrototypeSome(execArgv,
 (arg)=>RegExpPrototypeExec(debugArgRegex,arg)!==null)||
 RegExpPrototypeExec(debugArgRegex,nodeOptions)!==null){

lib/internal/main/test_runner.js

@@ -2,12 +2,23 @@
 const{
  prepareMainThreadExecution,
 }=require('internal/bootstrap/pre_execution');
+const{ isUsingInspector }=require('internal/util/inspector');
 const{ run }=require('internal/test_runner/runner');
 
 prepareMainThreadExecution(false);
 markBootstrapComplete();
 
-consttapStream=run();
+letconcurrency=true;
+letinspectPort;
+
+if(isUsingInspector()){
+process.emitWarning('Using the inspector with --test forces running at a concurrency of 1. '+
+'Use the inspectPort option to run with concurrency');
+concurrency=1;
+inspectPort=process.debugPort;
+}
+
+consttapStream=run({ concurrency, inspectPort });
 tapStream.pipe(process.stdout);
 tapStream.once('test:fail',()=>{
 process.exitCode=1;

lib/internal/test_runner/runner.js

@@ -1,18 +1,22 @@
 'use strict';
 const{
  ArrayFrom,
- ArrayPrototypeConcat,
  ArrayPrototypeFilter,
  ArrayPrototypeIncludes,
  ArrayPrototypeJoin,
+ ArrayPrototypePop,
+ ArrayPrototypePush,
  ArrayPrototypeSlice,
  ArrayPrototypeSort,
  ObjectAssign,
  PromisePrototypeThen,
+ RegExpPrototypeSymbolSplit,
  SafePromiseAll,
  SafeSet,
+ StringPrototypeEndsWith,
 }=primordials;
 
+const{ Buffer }=require('buffer');
 const{ spawn }=require('child_process');
 const{ readdirSync, statSync }=require('fs');
 constconsole=require('internal/console/global');
@@ -22,6 +26,7 @@ const{
 },
 }=require('internal/errors');
 const{ validateArray }=require('internal/validators');
+const{ getInspectPort, isUsingInspector, isInspectorMessage }=require('internal/util/inspector');
 const{ kEmptyObject }=require('internal/util');
 const{ createTestTree }=require('internal/test_runner/harness');
 const{ kSubtestsFailed, Test }=require('internal/test_runner/test');
@@ -100,25 +105,59 @@ function filterExecArgv(arg){
 return!ArrayPrototypeIncludes(kFilterArgs,arg);
 }
 
-functionrunTestFile(path,root){
+functiongetRunArgs({ path, inspectPort }){
+constargv=ArrayPrototypeFilter(process.execArgv,filterExecArgv);
+if(isUsingInspector()){
+ArrayPrototypePush(argv,`--inspect-port=${getInspectPort(inspectPort)}`);
+}
+ArrayPrototypePush(argv,path);
+returnargv;
+}
+
+functionmakeStderrCallback(callback){
+if(!isUsingInspector()){
+returncallback;
+}
+letbuffer=Buffer.alloc(0);
+return(data)=>{
+callback(data);
+constnewData=Buffer.concat([buffer,data]);
+conststr=newData.toString('utf8');
+letlines=str;
+if(StringPrototypeEndsWith(lines,'\n')){
+buffer=Buffer.alloc(0);
+}else{
+lines=RegExpPrototypeSymbolSplit(/\r?\n/,str);
+buffer=Buffer.from(ArrayPrototypePop(lines),'utf8');
+lines=ArrayPrototypeJoin(lines,'\n');
+}
+if(isInspectorMessage(lines)){
+process.stderr.write(lines);
+}
+};
+}
+
+functionrunTestFile(path,root,inspectPort){
 constsubtest=root.createSubtest(Test,path,async(t)=>{
-constargs=ArrayPrototypeConcat(
-ArrayPrototypeFilter(process.execArgv,filterExecArgv),
-path);
+constargs=getRunArgs({ path, inspectPort });
 
 constchild=spawn(process.execPath,args,{signal: t.signal,encoding: 'utf8'});
 // TODO(cjihrig): Implement a TAP parser to read the child's stdout
 // instead of just displaying it all if the child fails.
 leterr;
+letstderr='';
 
 child.on('error',(error)=>{
 err=error;
 });
 
-const{0: {0: code,1: signal},1: stdout,2: stderr}=awaitSafePromiseAll([
+child.stderr.on('data',makeStderrCallback((data)=>{
+stderr+=data;
+}));
+
+const{0: {0: code,1: signal},1: stdout}=awaitSafePromiseAll([
 once(child,'exit',{signal: t.signal}),
 child.stdout.toArray({signal: t.signal}),
-child.stderr.toArray({signal: t.signal}),
 ]);
 
 if(code!==0||signal!==null){
@@ -128,7 +167,7 @@ function runTestFile(path, root){
 exitCode: code,
 signal: signal,
 stdout: ArrayPrototypeJoin(stdout,''),
-stderr: ArrayPrototypeJoin(stderr,''),
+ stderr,
 // The stack will not be useful since the failures came from tests
 // in a child process.
 stack: undefined,
@@ -145,7 +184,7 @@ function run(options){
 if(options===null||typeofoptions!=='object'){
 options=kEmptyObject;
 }
-const{ concurrency, timeout, signal, files }=options;
+const{ concurrency, timeout, signal, files, inspectPort}=options;
 
 if(files!=null){
 validateArray(files,'options.files');
@@ -154,7 +193,7 @@ function run(options){
 constroot=createTestTree({ concurrency, timeout, signal });
 consttestFiles=files??createTestFileList();
 
-PromisePrototypeThen(SafePromiseAll(testFiles,(path)=>runTestFile(path,root)),
+PromisePrototypeThen(SafePromiseAll(testFiles,(path)=>runTestFile(path,root,inspectPort)),
 ()=>root.postRun());
 
 returnroot.reporter;

lib/internal/test_runner/test.js

@@ -58,8 +58,6 @@ const kDefaultTimeout = null;
 constnoop=FunctionPrototype;
 constisTestRunner=getOptionValue('--test');
 consttestOnlyFlag=!isTestRunner&&getOptionValue('--test-only');
-// TODO(cjihrig): Use uv_available_parallelism() once it lands.
-constrootConcurrency=isTestRunner ? MathMax(cpus().length-1,1) : 1;
 constkShouldAbort=Symbol('kShouldAbort');
 constkRunHook=Symbol('kRunHook');
 constkHookNames=ObjectSeal(['before','after','beforeEach','afterEach']);
@@ -150,7 +148,7 @@ class Test extends AsyncResource{
 }
 
 if(parent===null){
-this.concurrency=rootConcurrency;
+this.concurrency=1;
 this.indent='';
 this.indentString=kDefaultIndent;
 this.only=testOnlyFlag;
@@ -180,6 +178,7 @@ class Test extends AsyncResource{
 
 case'boolean':
 if(concurrency){
+// TODO(cjihrig): Use uv_available_parallelism() once it lands.
 this.concurrency=parent===null ? MathMax(cpus().length-1,1) : Infinity;
 }else{
 this.concurrency=1;

lib/internal/util/inspector.js

@@ -2,12 +2,47 @@
 
 const{
  ArrayPrototypeConcat,
+ ArrayPrototypeSome,
  FunctionPrototypeBind,
  ObjectDefineProperty,
  ObjectKeys,
  ObjectPrototypeHasOwnProperty,
+ RegExpPrototypeExec,
 }=primordials;
 
+const{ validatePort }=require('internal/validators');
+
+constkMinPort=1024;
+constkMaxPort=65535;
+constkInspectArgRegex=/--inspect(?:-brk|-port)?|--debug-port/;
+constkInspectMsgRegex=/Debuggerlisteningonws:\/\/\[?(.+?)\]?:(\d+)\/|Debuggerattached|Waitingforthedebuggertodisconnect\.\.\./;
+
+let_isUsingInspector;
+functionisUsingInspector(){
+_isUsingInspector??=
+ArrayPrototypeSome(process.execArgv,(arg)=>RegExpPrototypeExec(kInspectArgRegex,arg)!==null)||
+RegExpPrototypeExec(kInspectArgRegex,process.env.NODE_OPTIONS)!==null;
+return_isUsingInspector;
+}
+
+letdebugPortOffset=1;
+functiongetInspectPort(inspectPort){
+if(!isUsingInspector()){
+returnnull;
+}
+if(typeofinspectPort==='function'){
+inspectPort=inspectPort();
+}elseif(inspectPort==null){
+inspectPort=process.debugPort+debugPortOffset;
+if(inspectPort>kMaxPort)
+inspectPort=inspectPort-kMaxPort+kMinPort-1;
+debugPortOffset++;
+}
+validatePort(inspectPort);
+
+returninspectPort;
+}
+
 letsession;
 functionsendInspectorCommand(cb,onError){
 const{ hasInspector }=internalBinding('config');
@@ -22,6 +57,10 @@ function sendInspectorCommand(cb, onError){
 }
 }
 
+functionisInspectorMessage(string){
+returnisUsingInspector()&&RegExpPrototypeExec(kInspectMsgRegex,string)!==null;
+}
+
 // Create a special require function for the inspector command line API
 functioninstallConsoleExtensions(commandLineApi){
 if(commandLineApi.require){return;}
@@ -65,7 +104,10 @@ function wrapConsole(consoleFromNode, consoleFromVM){
 // Stores the console from VM, should be set during bootstrap.
 letconsoleFromVM;
 module.exports={
+ getInspectPort,
  installConsoleExtensions,
+ isInspectorMessage,
+ isUsingInspector,
  sendInspectorCommand,
  wrapConsole,
 getconsoleFromVM(){

src/node_options.cc

@@ -161,9 +161,6 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors){
  errors->push_back("either --test or --watch can be used, not both");
  }
 
-if (debug_options_.inspector_enabled){
- errors->push_back("the inspector cannot be used with --test");
- }
 #ifndef ALLOW_ATTACHING_DEBUGGER_IN_TEST_RUNNER
  debug_options_.allow_attaching_debugger = false;
 #endif

test/common/index.mjs

@@ -52,6 +52,8 @@ const{
  spawnPromisified,
 }=common;
 
+constgetPort=()=>common.PORT;
+
 export{
 isMainThread,
 isWindows,
@@ -100,4 +102,5 @@ export{
 runWithInvalidFD,
 createRequire,
 spawnPromisified,
+getPort,
 };

test/fixtures/test-runner/run_inspect.js

@@ -0,0 +1,40 @@
+'use strict';
+
+constcommon=require('../../common');
+constfixtures=require('../../common/fixtures');
+const{ run }=require('node:test');
+constassert=require('node:assert');
+
+constbadPortError={name: 'RangeError',code: 'ERR_SOCKET_BAD_PORT'};
+letinspectPort='inspectPort'inprocess.env ? Number(process.env.inspectPort) : undefined;
+letexpectedError;
+
+if(process.env.inspectPort==='addTwo'){
+inspectPort=common.mustCall(()=>{returnprocess.debugPort+=2;});
+}elseif(process.env.inspectPort==='string'){
+inspectPort='string';
+expectedError=badPortError;
+}elseif(process.env.inspectPort==='null'){
+inspectPort=null;
+}elseif(process.env.inspectPort==='bignumber'){
+inspectPort=1293812;
+expectedError=badPortError;
+}elseif(process.env.inspectPort==='negativenumber'){
+inspectPort=-9776;
+expectedError=badPortError;
+}elseif(process.env.inspectPort==='bignumberfunc'){
+inspectPort=common.mustCall(()=>123121);
+expectedError=badPortError;
+}elseif(process.env.inspectPort==='strfunc'){
+inspectPort=common.mustCall(()=>'invalidPort');
+expectedError=badPortError;
+}
+
+conststream=run({files: [fixtures.path('test-runner/run_inspect_assert.js')], inspectPort });
+if(expectedError){
+stream.on('test:fail',common.mustCall(({ error })=>{
+assert.deepStrictEqual({name: error.cause.name,code: error.cause.code},expectedError);
+}));
+}else{
+stream.on('test:fail',common.mustNotCall());
+}

test/fixtures/test-runner/run_inspect_assert.js

@@ -0,0 +1,19 @@
+'use strict';
+
+constassert=require('node:assert');
+
+const{ expectedPort, expectedInitialPort, expectedHost }=process.env;
+constdebugOptions=
+require('internal/options').getOptionValue('--inspect-port');
+
+if('expectedPort'inprocess.env){
+assert.strictEqual(process.debugPort,+expectedPort);
+}
+
+if('expectedInitialPort'inprocess.env){
+assert.strictEqual(debugOptions.port,+expectedInitialPort);
+}
+
+if('expectedHost'inprocess.env){
+assert.strictEqual(debugOptions.host,expectedHost);
+}