Files
node/test/common/debugger.js
T
Joyee Cheung 684c3b31f0 test: capture stack trace in debugger timeout errors
Otherwise when the expected prompt does not show up in the
session and the debugger tests time out, there is not enough
information to figure out exactly which line in the test
is causing the timeout.

PR-URL: https://github.com/nodejs/node/pull/60457
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
2025-10-31 13:18:50 +00:00

187 lines
4.8 KiB
JavaScript

'use strict';
const common = require('../common');
const spawn = require('child_process').spawn;
const BREAK_MESSAGE = new RegExp('(?:' + [
'assert', 'break', 'break on start', 'debugCommand',
'exception', 'other', 'promiseRejection', 'step',
].join('|') + ') in', 'i');
let TIMEOUT = common.platformTimeout(10000);
// Some macOS and Windows machines require more time to receive the outputs from the client.
// https://github.com/nodejs/build/issues/3014
if (common.isWindows || common.isMacOS) {
TIMEOUT = common.platformTimeout(15000);
}
function isPreBreak(output) {
return /Break on start/.test(output) && /1 \(function \(exports/.test(output);
}
function startCLI(args, flags = [], spawnOpts = {}, opts = { randomPort: true }) {
let stderrOutput = '';
const child = spawn(process.execPath, [
...flags,
'inspect',
...(opts.randomPort !== false ? ['--port=0'] : []),
...args,
], spawnOpts);
const outputBuffer = [];
function bufferOutput(chunk) {
if (this === child.stderr) {
stderrOutput += chunk;
}
outputBuffer.push(chunk);
}
function getOutput() {
return outputBuffer.join('\n').replaceAll('\b', '');
}
child.stdout.setEncoding('utf8');
child.stdout.on('data', bufferOutput);
child.stderr.setEncoding('utf8');
child.stderr.on('data', bufferOutput);
if (process.env.VERBOSE === '1') {
child.stdout.pipe(process.stdout);
child.stderr.pipe(process.stderr);
}
return {
flushOutput() {
const output = this.output;
outputBuffer.length = 0;
return output;
},
waitFor(pattern) {
function checkPattern(str) {
if (Array.isArray(pattern)) {
return pattern.every((p) => p.test(str));
}
return pattern.test(str);
}
return new Promise((resolve, reject) => {
function checkOutput() {
if (checkPattern(getOutput())) {
tearDown();
resolve();
}
}
function onChildClose(code, signal) {
tearDown();
let message = 'Child exited';
if (code) {
message += `, code ${code}`;
}
if (signal) {
message += `, signal ${signal}`;
}
message += ` while waiting for ${pattern}; found: ${this.output}`;
if (stderrOutput) {
message += `\n STDERR: ${stderrOutput}`;
}
reject(new Error(message));
}
// Capture stack trace here to show where waitFor was called from when it times out.
const timeoutErr = new Error(`Timeout (${TIMEOUT}) while waiting for ${pattern}`);
const timer = setTimeout(() => {
tearDown();
timeoutErr.output = this.output;
reject(timeoutErr);
}, TIMEOUT);
function tearDown() {
clearTimeout(timer);
child.stdout.removeListener('data', checkOutput);
child.removeListener('close', onChildClose);
}
child.on('close', onChildClose);
child.stdout.on('data', checkOutput);
checkOutput();
});
},
waitForPrompt() {
return this.waitFor(/>\s+$/);
},
async waitForInitialBreak() {
await this.waitFor(/break (?:on start )?in/i);
if (isPreBreak(this.output)) {
await this.command('next', false);
return this.waitFor(/break in/);
}
},
get breakInfo() {
const output = this.output;
const breakMatch =
output.match(/(step |break (?:on start )?)in ([^\n]+):(\d+)\n/i);
if (breakMatch === null) {
throw new Error(
`Could not find breakpoint info in ${JSON.stringify(output)}`);
}
return { filename: breakMatch[2], line: +breakMatch[3] };
},
ctrlC() {
return this.command('.interrupt');
},
get output() {
return getOutput();
},
get rawOutput() {
return outputBuffer.join('').toString();
},
parseSourceLines() {
return getOutput().split('\n')
.map((line) => line.match(/(?:\*|>)?\s*(\d+)/))
.filter((match) => match !== null)
.map((match) => +match[1]);
},
writeLine(input, flush = true) {
if (flush) {
this.flushOutput();
}
if (process.env.VERBOSE === '1') {
process.stderr.write(`< ${input}\n`);
}
child.stdin.write(input);
child.stdin.write('\n');
},
command(input, flush = true) {
this.writeLine(input, flush);
return this.waitForPrompt();
},
stepCommand(input) {
this.writeLine(input, true);
return this
.waitFor(BREAK_MESSAGE)
.then(() => this.waitForPrompt());
},
quit() {
return new Promise((resolve) => {
child.stdin.end();
child.on('close', resolve);
});
},
};
}
module.exports = startCLI;