test: fix inspector tests

The inspector tests should not be in the parallel directory as they
likely all (or certainly almost all) use static ports, so port
collisions will happen.

This moves them all to sequential. We can move them back on a
case-by-case basis. They were run sequentially when they were in the
inspector directory which they were only moved from very recently.

PR-URL: https://github.com/nodejs/node/pull/16281
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Yuta Hiroto <hello@about-hiroppy.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Bryan English <bryan@bryanenglish.com>

1 files changed, 81 insertions, 0 deletions

diff --git a/test/sequential/test-inspector-async-hook-setup-at-signal.js b/test/sequential/test-inspector-async-hook-setup-at-signal.js
new file mode 100644
index 0000000000..96e8b28a7a
--- /dev/null
+++ b/test/sequential/test-inspector-async-hook-setup-at-signal.js
@@ -0,0 +1,81 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+common.skipIf32Bits();
+common.crashOnUnhandledRejection();
+const { NodeInstance } = require('../common/inspector-helper.js');
+const assert = require('assert');
+
+const script = `
+process._rawDebug('Waiting until a signal enables the inspector...');
+let waiting = setInterval(waitUntilDebugged, 50);
+
+function waitUntilDebugged() {
+  if (!process.binding('inspector').isEnabled()) return;
+  clearInterval(waiting);
+  // At this point, even though the Inspector is enabled, the default async
+  // call stack depth is 0. We need a chance to call
+  // Debugger.setAsyncCallStackDepth *before* activating the actual timer for
+  // async stack traces to work. Directly using a debugger statement would be
+  // too brittle, and using a longer timeout would unnecesarily slow down the
+  // test on most machines. Triggering a debugger break through an interval is
+  // a faster and more reliable way.
+  process._rawDebug('Signal received, waiting for debugger setup');
+  waiting = setInterval(() => { debugger; }, 50);
+}
+
+// This function is called by the inspector client (session)
+function setupTimeoutWithBreak() {
+  clearInterval(waiting);
+  process._rawDebug('Debugger ready, setting up timeout with a break');
+  setTimeout(() => { debugger; }, 50);
+}
+`;
+
+async function waitForInitialSetup(session) {
+  console.error('[test]', 'Waiting for initial setup');
+  await session.waitForBreakOnLine(15, '[eval]');
+}
+
+async function setupTimeoutForStackTrace(session) {
+  console.error('[test]', 'Setting up timeout for async stack trace');
+  await session.send([
+    { 'method': 'Runtime.evaluate',
+      'params': { expression: 'setupTimeoutWithBreak()' } },
+    { 'method': 'Debugger.resume' }
+  ]);
+}
+
+async function checkAsyncStackTrace(session) {
+  console.error('[test]', 'Verify basic properties of asyncStackTrace');
+  const paused = await session.waitForBreakOnLine(22, '[eval]');
+  assert(paused.params.asyncStackTrace,
+         `${Object.keys(paused.params)} contains "asyncStackTrace" property`);
+  assert(paused.params.asyncStackTrace.description, 'Timeout');
+  assert(paused.params.asyncStackTrace.callFrames
+           .some((frame) => frame.functionName === 'setupTimeoutWithBreak'));
+}
+
+async function runTests() {
+  const instance = await NodeInstance.startViaSignal(script);
+  const session = await instance.connectInspectorSession();
+  await session.send([
+    { 'method': 'Runtime.enable' },
+    { 'method': 'Debugger.enable' },
+    { 'method': 'Debugger.setAsyncCallStackDepth',
+      'params': { 'maxDepth': 10 } },
+    { 'method': 'Debugger.setBlackboxPatterns',
+      'params': { 'patterns': [] } },
+    { 'method': 'Runtime.runIfWaitingForDebugger' }
+  ]);
+
+  await waitForInitialSetup(session);
+  await setupTimeoutForStackTrace(session);
+  await checkAsyncStackTrace(session);
+
+  console.error('[test]', 'Stopping child instance');
+  session.disconnect();
+  instance.kill();
+}
+
+runTests();