diff options
Diffstat (limited to 'test/sequential/test-inspector-async-hook-setup-at-signal.js')
-rw-r--r-- | test/sequential/test-inspector-async-hook-setup-at-signal.js | 81 |
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(); |