1
// Copyright (c) 2025 Cloudflare, Inc.
2
// Licensed under the Apache 2.0 license found in the LICENSE file or at:
3
//     https://opensource.org/licenses/Apache-2.0
4
import inspector from 'node:inspector';
5
import assert from 'node:assert';
6
import { EventEmitter } from 'node:events';
7
import promises from 'node:inspector/promises';
8
 
9
export const inspectorClose = {
10
  test() {
11
    assert.doesNotThrow(() => inspector.close());
12
    assert.strictEqual(inspector.close(), undefined);
13
  },
14
};
15
 
16
export const inspectorConsole = {
17
  test() {
18
    assert.strictEqual(typeof inspector.console, 'object');
19
 
20
    const consoleMethods = [
21
      'debug',
22
      'error',
23
      'info',
24
      'log',
25
      'warn',
26
      'dir',
27
      'dirxml',
28
      'table',
29
      'trace',
30
      'group',
31
      'groupCollapsed',
32
      'groupEnd',
33
      'clear',
34
      'count',
35
      'countReset',
36
      'assert',
37
      'profile',
38
      'profileEnd',
39
      'time',
40
      'timeLog',
41
      'timeStamp',
42
    ];
43
 
44
    for (const method of consoleMethods) {
45
      assert.strictEqual(typeof inspector.console[method], 'function');
46
      assert.doesNotThrow(() => inspector.console[method]());
47
      assert.strictEqual(inspector.console[method](), undefined);
48
      assert.strictEqual(inspector.console[method]('test'), undefined);
49
      assert.strictEqual(inspector.console[method]('test', 'args'), undefined);
50
    }
51
  },
52
};
53
 
54
export const inspectorOpen = {
55
  test() {
56
    const disposable = inspector.open();
57
    assert.strictEqual(typeof disposable, 'object');
58
    assert.strictEqual(typeof disposable[Symbol.dispose], 'function');
59
 
60
    const disposePromise = disposable[Symbol.dispose]();
61
    assert.strictEqual(disposePromise instanceof Promise, true);
62
 
63
    disposable[Symbol.dispose]().then((result) => {
64
      assert.strictEqual(result, undefined);
65
    });
66
 
67
    assert.doesNotThrow(() => inspector.open(9229));
68
    assert.doesNotThrow(() => inspector.open(9229, 'localhost'));
69
    assert.doesNotThrow(() => inspector.open(9229, 'localhost', true));
70
    assert.doesNotThrow(() => inspector.open(undefined, undefined, false));
71
  },
72
};
73
 
74
export const inspectorUrl = {
75
  test() {
76
    assert.strictEqual(inspector.url(), undefined);
77
    assert.strictEqual(typeof inspector.url(), 'undefined');
78
  },
79
};
80
 
81
export const inspectorWaitForDebugger = {
82
  test() {
83
    assert.doesNotThrow(() => inspector.waitForDebugger());
84
    assert.strictEqual(inspector.waitForDebugger(), undefined);
85
  },
86
};
87
 
88
export const inspectorSession = {
89
  test() {
90
    assert.throws(() => new inspector.Session(), {
91
      code: 'ERR_METHOD_NOT_IMPLEMENTED',
92
      message: /Session/,
93
    });
94
 
95
    assert.strictEqual(typeof inspector.Session, 'function');
96
  },
97
};
98
 
99
export const inspectorSessionMethods = {
100
  test() {
101
    let _session;
102
    try {
103
      _session = new inspector.Session();
104
    } catch (_e) {
105
      const SessionProto = inspector.Session.prototype;
106
 
107
      assert.strictEqual(typeof SessionProto.connect, 'function');
108
      assert.strictEqual(typeof SessionProto.connectToMainThread, 'function');
109
      assert.strictEqual(typeof SessionProto.disconnect, 'function');
110
      assert.strictEqual(typeof SessionProto.post, 'function');
111
 
112
      assert.strictEqual(typeof SessionProto.on, 'function');
113
      assert.strictEqual(typeof SessionProto.emit, 'function');
114
      assert.strictEqual(typeof SessionProto.once, 'function');
115
      assert.strictEqual(typeof SessionProto.removeListener, 'function');
116
    }
117
  },
118
};
119
 
120
export const inspectorNetwork = {
121
  test() {
122
    assert.strictEqual(typeof inspector.Network, 'object');
123
 
124
    assert.throws(() => inspector.Network.requestWillBeSent({}), {
125
      code: 'ERR_METHOD_NOT_IMPLEMENTED',
126
      message: /Network\.requestWillBeSent/,
127
    });
128
 
129
    assert.throws(() => inspector.Network.dataReceived({}), {
130
      code: 'ERR_METHOD_NOT_IMPLEMENTED',
131
      message: /Network\.dataReceived/,
132
    });
133
 
134
    assert.throws(() => inspector.Network.responseReceived({}), {
135
      code: 'ERR_METHOD_NOT_IMPLEMENTED',
136
      message: /Network\.responseReceived/,
137
    });
138
 
139
    assert.throws(() => inspector.Network.loadingFinished({}), {
140
      code: 'ERR_METHOD_NOT_IMPLEMENTED',
141
      message: /Network\.loadingFinished/,
142
    });
143
 
144
    assert.throws(() => inspector.Network.loadingFailed({}), {
145
      code: 'ERR_METHOD_NOT_IMPLEMENTED',
146
      message: /Network\.loadingFailed/,
147
    });
148
  },
149
};
150
 
151
export const inspectorNetworkMethods = {
152
  test() {
153
    const networkMethods = [
154
      'requestWillBeSent',
155
      'dataReceived',
156
      'responseReceived',
157
      'loadingFinished',
158
      'loadingFailed',
159
    ];
160
 
161
    for (const method of networkMethods) {
162
      assert.strictEqual(typeof inspector.Network[method], 'function');
163
      assert.throws(() => inspector.Network[method]({}), {
164
        code: 'ERR_METHOD_NOT_IMPLEMENTED',
165
      });
166
      assert.throws(() => inspector.Network[method](undefined), {
167
        code: 'ERR_METHOD_NOT_IMPLEMENTED',
168
      });
169
      assert.throws(() => inspector.Network[method](null), {
170
        code: 'ERR_METHOD_NOT_IMPLEMENTED',
171
      });
172
    }
173
  },
174
};
175
 
176
export const inspectorDefaultExport = {
177
  test() {
178
    assert.strictEqual(typeof inspector, 'object');
179
    assert.strictEqual(typeof inspector.Session, 'function');
180
    assert.strictEqual(typeof inspector.close, 'function');
181
    assert.strictEqual(typeof inspector.console, 'object');
182
    assert.strictEqual(typeof inspector.open, 'function');
183
    assert.strictEqual(typeof inspector.url, 'function');
184
    assert.strictEqual(typeof inspector.waitForDebugger, 'function');
185
    assert.strictEqual(typeof inspector.Network, 'object');
186
  },
187
};
188
 
189
export const inspectorModuleExports = {
190
  async test() {
191
    const inspectorModule = await import('node:inspector');
192
 
193
    assert.strictEqual(typeof inspectorModule.default, 'object');
194
    assert.strictEqual(typeof inspectorModule.Session, 'function');
195
    assert.strictEqual(typeof inspectorModule.close, 'function');
196
    assert.strictEqual(typeof inspectorModule.console, 'object');
197
    assert.strictEqual(typeof inspectorModule.open, 'function');
198
    assert.strictEqual(typeof inspectorModule.url, 'function');
199
    assert.strictEqual(typeof inspectorModule.waitForDebugger, 'function');
200
    assert.strictEqual(typeof inspectorModule.Network, 'object');
201
 
202
    assert.strictEqual(
203
      inspectorModule.default.Session,
204
      inspectorModule.Session
205
    );
206
    assert.strictEqual(inspectorModule.default.close, inspectorModule.close);
207
    assert.strictEqual(
208
      inspectorModule.default.console,
209
      inspectorModule.console
210
    );
211
    assert.strictEqual(inspectorModule.default.open, inspectorModule.open);
212
    assert.strictEqual(inspectorModule.default.url, inspectorModule.url);
213
    assert.strictEqual(
214
      inspectorModule.default.waitForDebugger,
215
      inspectorModule.waitForDebugger
216
    );
217
    assert.strictEqual(
218
      inspectorModule.default.Network,
219
      inspectorModule.Network
220
    );
221
  },
222
};
223
 
224
export const inspectorOpenReturnValue = {
225
  async test() {
226
    const disposable1 = inspector.open();
227
    const disposable2 = inspector.open(8080);
228
    const disposable3 = inspector.open(8080, '127.0.0.1');
229
    const disposable4 = inspector.open(8080, '127.0.0.1', false);
230
 
231
    for (const disposable of [
232
      disposable1,
233
      disposable2,
234
      disposable3,
235
      disposable4,
236
    ]) {
237
      assert.strictEqual(typeof disposable, 'object');
238
      assert.strictEqual(typeof disposable[Symbol.dispose], 'function');
239
 
240
      const result = await disposable[Symbol.dispose]();
241
      assert.strictEqual(result, undefined);
242
    }
243
  },
244
};
245
 
246
export const inspectorConsoleNoOp = {
247
  test() {
248
    const testArgs = [
249
      [],
250
      ['test'],
251
      ['test', 123],
252
      ['test', 123, { key: 'value' }],
253
      [null, undefined, NaN, Infinity],
254
      [() => {}, [], {}],
255
    ];
256
 
257
    const consoleMethods = Object.keys(inspector.console);
258
 
259
    for (const method of consoleMethods) {
260
      for (const args of testArgs) {
261
        assert.strictEqual(inspector.console[method](...args), undefined);
262
      }
263
    }
264
  },
265
};
266
 
267
export const inspectorSessionInheritance = {
268
  test() {
269
    assert.strictEqual(
270
      inspector.Session.prototype instanceof EventEmitter,
271
      true
272
    );
273
 
274
    const proto = inspector.Session.prototype;
275
    const eventMethods = [
276
      'on',
277
      'once',
278
      'emit',
279
      'removeListener',
280
      'removeAllListeners',
281
      'setMaxListeners',
282
      'getMaxListeners',
283
      'listeners',
284
      'rawListeners',
285
      'listenerCount',
286
      'prependListener',
287
      'prependOnceListener',
288
      'eventNames',
289
    ];
290
 
291
    for (const method of eventMethods) {
292
      assert.strictEqual(typeof proto[method], 'function');
293
    }
294
  },
295
};
296
 
297
export const inspectorPromises = {
298
  test() {
299
    assert.strictEqual(typeof promises, 'object');
300
    assert.strictEqual(typeof promises.Session, 'function');
301
  },
302
};