test: unflake debugger and REPL tests

lib/internal/debugger/inspect_repl.js

@@ -386,7 +386,6 @@ function createRepl(inspector) {
   let exitDebugRepl;
   let contextLineNumber = 2;
   let initialBreakRender;
-  let waitForInitialBreakRender = false;
 
   function resetOnStart() {
     knownScripts = {};
@@ -897,13 +896,6 @@ function createRepl(inspector) {
       });
   }
 
-  function createInitialBreakRenderPromise(pauseRender) {
-    const { promise, resolve, reject } = PromiseWithResolvers();
-    initialBreakRender = promise;
-    PromisePrototypeThen(pauseRender, resolve, reject);
-    return promise;
-  }
-
   Debugger.on('paused', ({ callFrames, reason /* , hitBreakpoints */ }) => {
     if (process.env.NODE_INSPECT_RESUME_ON_START === '1' &&
         reason === 'Break on start') {
@@ -934,8 +926,10 @@ function createRepl(inspector) {
           print(`${header}\n${breakContext}`);
         }));
 
-    if (waitForInitialBreakRender && !initialBreakRender) {
-      createInitialBreakRenderPromise(pauseRender);
+    if (initialBreakRender) {
+      const { resolve, reject } = initialBreakRender;
+      initialBreakRender = null;
+      PromisePrototypeThen(pauseRender, resolve, reject);
     }
   });
 
@@ -1204,23 +1198,36 @@ function createRepl(inspector) {
   }
 
   async function initAfterStart() {
-    waitForInitialBreakRender =
+    const waitForInitialBreakRender =
       !!inspector.options?.script &&
       process.env.NODE_INSPECT_RESUME_ON_START !== '1';
-    await Runtime.enable();
-    await Profiler.enable();
-    await Profiler.setSamplingInterval({ interval: 100 });
-    await Debugger.enable();
-    await Debugger.setAsyncCallStackDepth({ maxDepth: 0 });
-    await Debugger.setBlackboxPatterns({ patterns: [] });
-    await Debugger.setPauseOnExceptions({ state: pauseOnExceptionState });
-    await restoreBreakpoints();
-    await Runtime.runIfWaitingForDebugger();
-    await PromiseResolve();
-    waitForInitialBreakRender = false;
-    const initialBreakRenderPromise = initialBreakRender;
-    initialBreakRender = null;
-    await initialBreakRenderPromise;
+    const initialBreak = waitForInitialBreakRender ?
+      PromiseWithResolvers() : null;
+    initialBreakRender = initialBreak;
+    const onClientClose = initialBreak?.resolve;
+    if (onClientClose) {
+      inspector.client.once('close', onClientClose);
+    }
+
+    try {
+      await Runtime.enable();
+      await Profiler.enable();
+      await Profiler.setSamplingInterval({ interval: 100 });
+      await Debugger.enable();
+      await Debugger.setAsyncCallStackDepth({ maxDepth: 0 });
+      await Debugger.setBlackboxPatterns({ patterns: [] });
+      await Debugger.setPauseOnExceptions({ state: pauseOnExceptionState });
+      await restoreBreakpoints();
+      await Runtime.runIfWaitingForDebugger();
+      await initialBreak?.promise;
+    } finally {
+      if (onClientClose) {
+        inspector.client.removeListener('close', onClientClose);
+      }
+      if (initialBreakRender === initialBreak) {
+        initialBreakRender = null;
+      }
+    }
   }
 
   return async function startRepl() {

test/parallel/test-debugger-run-restart-init.js

@@ -56,7 +56,8 @@ function evalCommand(repl, command) {
   });
 }
 
-async function assertCommandWaitsForInit(repl, command, gate, calls) {
+async function assertCommandWaitsForInit(
+  repl, command, initGate, pauseGate, renderGate, calls) {
   let settled = false;
   const promise = evalCommand(repl, command).then(() => {
     settled = true;
@@ -69,7 +70,23 @@ async function assertCommandWaitsForInit(repl, command, gate, calls) {
     `${command} resolved before post-connect initialization completed: ${calls}`,
   );
 
-  gate.resolve();
+  initGate.resolve();
+  await new Promise(setImmediate);
+  assert.strictEqual(
+    settled,
+    false,
+    `${command} resolved before the initial break was rendered: ${calls}`,
+  );
+
+  pauseGate.resolve();
+  await new Promise(setImmediate);
+  assert.strictEqual(
+    settled,
+    false,
+    `${command} resolved before the initial break render completed: ${calls}`,
+  );
+
+  renderGate.resolve();
   await promise;
   assert.strictEqual(settled, true);
 }
@@ -79,27 +96,67 @@ async function assertCommandWaitsForInit(repl, command, gate, calls) {
   const runGate = createGate();
   const restartGate = createGate();
   const gates = [null, runGate, restartGate];
+  const initialRenderGate = createGate();
+  const runRenderGate = createGate();
+  const restartRenderGate = createGate();
+  const renderGates = [initialRenderGate, runRenderGate, restartRenderGate];
   const inspector = {
     client: new EventEmitter(),
     domainNames: ['Debugger', 'HeapProfiler', 'Profiler', 'Runtime'],
+    options: { script: 'fixture.js' },
     stdin: new PassThrough(),
     stdout: new PassThrough(),
     run: common.mustCall(async () => {
       calls.push('inspector.run');
     }, 2),
+    print(text, addNewline = true) {
+      this.stdout.write(`${text}${addNewline ? '\n' : ''}`);
+    },
     suspendReplWhile(fn) {
       return fn();
     },
   };
 
+  const pausedEvent = {
+    callFrames: [{
+      functionName: '',
+      location: { scriptId: '1', lineNumber: 0, columnNumber: 0 },
+      scopeChain: [],
+    }],
+    reason: 'other',
+  };
   for (const domain of inspector.domainNames) {
     inspector[domain] = createAgent(domain, calls, gates);
   }
-
-  const repl = await createRepl(inspector)();
-
-  await assertCommandWaitsForInit(repl, 'run', runGate, calls);
-  await assertCommandWaitsForInit(repl, 'restart', restartGate, calls);
+  inspector.Debugger.getScriptSource = async () => {
+    await renderGates.shift().promise;
+    return { scriptSource: 'const value = 1;\n' };
+  };
+  const emitPause = common.mustCall(() => {
+    inspector.Debugger.emit('paused', pausedEvent);
+  }, 3);
+  const initialPauseGate = { resolve: emitPause };
+  const runPauseGate = { resolve: emitPause };
+  const restartPauseGate = { resolve: emitPause };
+
+  let replSettled = false;
+  const replPromise = createRepl(inspector)().then((repl) => {
+    replSettled = true;
+    return repl;
+  });
+  await new Promise(setImmediate);
+  assert.strictEqual(replSettled, false);
+  initialPauseGate.resolve();
+  await new Promise(setImmediate);
+  assert.strictEqual(replSettled, false);
+  initialRenderGate.resolve();
+  const repl = await replPromise;
+
+  await assertCommandWaitsForInit(
+    repl, 'run', runGate, runPauseGate, runRenderGate, calls);
+  await assertCommandWaitsForInit(
+    repl, 'restart', restartGate, restartPauseGate,
+    restartRenderGate, calls);
 
   assert.deepStrictEqual(
     calls.filter((call) => (

test/parallel/test-repl-user-error-handler.js

@@ -6,9 +6,18 @@ const { PassThrough } = require('node:stream');
 const { once } = require('node:events');
 const test = require('node:test');
 const { spawn } = require('node:child_process');
+const vm = require('node:vm');
 
 common.skipIfInspectorDisabled();
 
+function evaluate(code, context, filename, callback) {
+  try {
+    callback(null, vm.runInContext(code, context, { filename }));
+  } catch (err) {
+    callback(err);
+  }
+}
+
 function* generateCases() {
   for (const async of [false, true]) {
     for (const handleErrorReturn of ['ignore', 'print', 'unhandled', 'badvalue']) {
@@ -23,13 +32,12 @@ function* generateCases() {
 
 for (const { async, handleErrorReturn } of generateCases()) {
   test(`async: ${async}, handleErrorReturn: ${handleErrorReturn}`, async () => {
-    let err;
     const options = {
       input: new PassThrough(),
       output: new PassThrough().setEncoding('utf8'),
-      handleError: common.mustCall((e) => {
-        err = e;
-        queueMicrotask(() => repl.emit('handled-error'));
+      eval: evaluate,
+      handleError: common.mustCall((err) => {
+        queueMicrotask(() => repl.emit('handled-error', err));
         return handleErrorReturn;
       })
     };
@@ -45,13 +53,16 @@ for (const { async, handleErrorReturn } of generateCases()) {
     let outputString = '';
     options.output.on('data', (chunk) => { outputString += chunk; });
 
-    const inputString = async ?
-      'setImmediate(() => { throw new Error("testerror") })\n42\n' :
-      'throw new Error("testerror")\n42\n';
-    options.input.end(inputString);
+    const errorInput = async ?
+      'setImmediate(() => { throw new Error("testerror") })\n' :
+      'throw new Error("testerror")\n';
+    const handledErrorEvent = once(repl, 'handled-error');
+    options.input.write(errorInput);
 
-    await once(repl, 'handled-error');
+    const [err] = await handledErrorEvent;
     assert.strictEqual(err.message, 'testerror');
+    const exitEvent = once(repl, 'exit');
+    options.input.end('42\n');
     while (!/42/.test(outputString)) {
       await once(options.output, 'data');
     }
@@ -66,6 +77,7 @@ for (const { async, handleErrorReturn } of generateCases()) {
       const [uncaughtErr] = await uncaughtExceptionEvent;
       assert.strictEqual(uncaughtErr, err);
     }
+    await exitEvent;
   });
 }