summaryrefslogtreecommitdiff
path: root/test/sequential/test-inspector-async-call-stack.js
blob: f050487da7a5e5aad701f683e85b0b34009aeb5c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
// Flags: --expose-internals
'use strict';
const common = require('../common');
common.skipIfInspectorDisabled();
common.skipIf32Bits();

const assert = require('assert');
const { internalBinding } = require('internal/test/binding');
const { async_hook_fields, constants } = internalBinding('async_wrap');
const { kTotals } = constants;
const inspector = require('inspector');

const setDepth = 'Debugger.setAsyncCallStackDepth';

function verifyAsyncHookDisabled(message) {
  assert.strictEqual(async_hook_fields[kTotals], 0,
                     `${async_hook_fields[kTotals]} !== 0: ${message}`);
}

function verifyAsyncHookEnabled(message) {
  assert.strictEqual(async_hook_fields[kTotals], 4,
                     `${async_hook_fields[kTotals]} !== 4: ${message}`);
}

// By default inspector async hooks should not have been installed.
verifyAsyncHookDisabled('inspector async hook should be disabled at startup');

const session = new inspector.Session();
verifyAsyncHookDisabled('creating a session should not enable async hooks');

session.connect();
verifyAsyncHookDisabled('connecting a session should not enable async hooks');

session.post('Debugger.enable', () => {
  verifyAsyncHookDisabled('enabling debugger should not enable async hooks');

  session.post(setDepth, { invalid: 'message' }, () => {
    verifyAsyncHookDisabled('invalid message should not enable async hooks');

    session.post(setDepth, { maxDepth: 'five' }, () => {
      verifyAsyncHookDisabled('invalid maxDepth (string) should not enable ' +
                              'async hooks');

      session.post(setDepth, { maxDepth: NaN }, () => {
        verifyAsyncHookDisabled('invalid maxDepth (NaN) should not enable ' +
                                'async hooks');

        session.post(setDepth, { maxDepth: 10 }, () => {
          verifyAsyncHookEnabled('valid message should enable async hooks');

          session.post(setDepth, { maxDepth: 0 }, () => {
            verifyAsyncHookDisabled('Setting maxDepth to 0 should disable ' +
                                    'async hooks');

            runTestSet2(session);
          });
        });
      });
    });
  });
});

function runTestSet2(session) {
  session.post(setDepth, { maxDepth: 32 }, () => {
    verifyAsyncHookEnabled('valid message should enable async hooks');

    session.post('Debugger.disable', () => {
      verifyAsyncHookDisabled('Debugger.disable should disable async hooks');

      session.post('Debugger.enable', () => {
        verifyAsyncHookDisabled('Enabling debugger should not enable hooks');

        session.post(setDepth, { maxDepth: 64 }, () => {
          verifyAsyncHookEnabled('valid message should enable async hooks');

          session.disconnect();
          verifyAsyncHookDisabled('Disconnecting session should disable ' +
                                  'async hooks');
        });
      });
    });
  });
}