mirror of
https://github.com/oven-sh/bun
synced 2026-02-09 18:38:55 +00:00
403 lines
13 KiB
TypeScript
403 lines
13 KiB
TypeScript
import { afterEach, beforeEach, describe, expect, test } from "bun:test";
|
|
import inspector from "node:inspector";
|
|
import inspectorPromises from "node:inspector/promises";
|
|
|
|
describe("node:inspector", () => {
|
|
describe("Session", () => {
|
|
let session: inspector.Session;
|
|
|
|
beforeEach(() => {
|
|
session = new inspector.Session();
|
|
});
|
|
|
|
afterEach(() => {
|
|
try {
|
|
session.disconnect();
|
|
} catch {
|
|
// Ignore if already disconnected
|
|
}
|
|
});
|
|
|
|
test("Session is a constructor", () => {
|
|
expect(inspector.Session).toBeInstanceOf(Function);
|
|
expect(session).toBeInstanceOf(inspector.Session);
|
|
});
|
|
|
|
test("Session extends EventEmitter", () => {
|
|
expect(typeof session.on).toBe("function");
|
|
expect(typeof session.emit).toBe("function");
|
|
expect(typeof session.removeListener).toBe("function");
|
|
});
|
|
|
|
test("connect() establishes connection", () => {
|
|
expect(() => session.connect()).not.toThrow();
|
|
});
|
|
|
|
test("connect() throws if already connected", () => {
|
|
session.connect();
|
|
expect(() => session.connect()).toThrow("already connected");
|
|
});
|
|
|
|
test("connectToMainThread() works like connect()", () => {
|
|
expect(() => session.connectToMainThread()).not.toThrow();
|
|
});
|
|
|
|
test("disconnect() closes connection cleanly", () => {
|
|
session.connect();
|
|
expect(() => session.disconnect()).not.toThrow();
|
|
});
|
|
|
|
test("disconnect() is a no-op if not connected", () => {
|
|
expect(() => session.disconnect()).not.toThrow();
|
|
});
|
|
|
|
test("post() throws if not connected", () => {
|
|
expect(() => session.post("Profiler.enable")).toThrow("not connected");
|
|
});
|
|
|
|
test("post() with callback calls callback with error if not connected", async () => {
|
|
const { promise, resolve, reject } = Promise.withResolvers<Error>();
|
|
session.post("Profiler.enable", err => {
|
|
if (err) resolve(err);
|
|
else reject(new Error("Expected error"));
|
|
});
|
|
const error = await promise;
|
|
expect(error.message).toContain("not connected");
|
|
});
|
|
});
|
|
|
|
describe("Profiler", () => {
|
|
let session: inspector.Session;
|
|
|
|
beforeEach(() => {
|
|
session = new inspector.Session();
|
|
session.connect();
|
|
});
|
|
|
|
afterEach(() => {
|
|
try {
|
|
session.disconnect();
|
|
} catch {
|
|
// Ignore
|
|
}
|
|
});
|
|
|
|
test("Profiler.enable succeeds", () => {
|
|
const result = session.post("Profiler.enable");
|
|
expect(result).toEqual({});
|
|
});
|
|
|
|
test("Profiler.disable succeeds", () => {
|
|
session.post("Profiler.enable");
|
|
const result = session.post("Profiler.disable");
|
|
expect(result).toEqual({});
|
|
});
|
|
|
|
test("Profiler.start without enable throws", () => {
|
|
expect(() => session.post("Profiler.start")).toThrow("not enabled");
|
|
});
|
|
|
|
test("Profiler.start after enable succeeds", () => {
|
|
session.post("Profiler.enable");
|
|
const result = session.post("Profiler.start");
|
|
expect(result).toEqual({});
|
|
});
|
|
|
|
test("Profiler.stop without start throws", () => {
|
|
session.post("Profiler.enable");
|
|
expect(() => session.post("Profiler.stop")).toThrow("not started");
|
|
});
|
|
|
|
test("Profiler.stop returns valid profile", () => {
|
|
session.post("Profiler.enable");
|
|
session.post("Profiler.start");
|
|
|
|
// Do some work to generate profile data
|
|
let sum = 0;
|
|
for (let i = 0; i < 10000; i++) {
|
|
sum += Math.sqrt(i);
|
|
}
|
|
|
|
const result = session.post("Profiler.stop");
|
|
|
|
expect(result).toHaveProperty("profile");
|
|
const profile = result.profile;
|
|
|
|
// Validate profile structure
|
|
expect(profile).toHaveProperty("nodes");
|
|
expect(profile).toHaveProperty("startTime");
|
|
expect(profile).toHaveProperty("endTime");
|
|
expect(profile).toHaveProperty("samples");
|
|
expect(profile).toHaveProperty("timeDeltas");
|
|
|
|
expect(profile.nodes).toBeArray();
|
|
expect(profile.nodes.length).toBeGreaterThanOrEqual(1);
|
|
|
|
// First node should be (root)
|
|
const rootNode = profile.nodes[0];
|
|
expect(rootNode).toHaveProperty("id", 1);
|
|
expect(rootNode).toHaveProperty("callFrame");
|
|
expect(rootNode.callFrame).toHaveProperty("functionName", "(root)");
|
|
expect(rootNode.callFrame).toHaveProperty("scriptId", "0");
|
|
expect(rootNode.callFrame).toHaveProperty("url", "");
|
|
expect(rootNode.callFrame).toHaveProperty("lineNumber", -1);
|
|
expect(rootNode.callFrame).toHaveProperty("columnNumber", -1);
|
|
});
|
|
|
|
test("complete enable->start->stop workflow", () => {
|
|
// Enable profiler
|
|
const enableResult = session.post("Profiler.enable");
|
|
expect(enableResult).toEqual({});
|
|
|
|
// Start profiling
|
|
const startResult = session.post("Profiler.start");
|
|
expect(startResult).toEqual({});
|
|
|
|
// Do some work
|
|
function fibonacci(n: number): number {
|
|
if (n <= 1) return n;
|
|
return fibonacci(n - 1) + fibonacci(n - 2);
|
|
}
|
|
fibonacci(20);
|
|
|
|
// Stop profiling
|
|
const stopResult = session.post("Profiler.stop");
|
|
expect(stopResult).toHaveProperty("profile");
|
|
|
|
// Disable profiler
|
|
const disableResult = session.post("Profiler.disable");
|
|
expect(disableResult).toEqual({});
|
|
});
|
|
|
|
test("samples and timeDeltas have same length", () => {
|
|
session.post("Profiler.enable");
|
|
session.post("Profiler.start");
|
|
|
|
// Do some work
|
|
let sum = 0;
|
|
for (let i = 0; i < 5000; i++) {
|
|
sum += Math.sqrt(i);
|
|
}
|
|
|
|
const result = session.post("Profiler.stop");
|
|
const profile = result.profile;
|
|
|
|
expect(profile.samples.length).toBe(profile.timeDeltas.length);
|
|
});
|
|
|
|
test("samples reference valid node IDs", () => {
|
|
session.post("Profiler.enable");
|
|
session.post("Profiler.start");
|
|
|
|
// Do some work
|
|
let sum = 0;
|
|
for (let i = 0; i < 5000; i++) {
|
|
sum += Math.sqrt(i);
|
|
}
|
|
|
|
const result = session.post("Profiler.stop");
|
|
const profile = result.profile;
|
|
|
|
const nodeIds = new Set(profile.nodes.map((n: any) => n.id));
|
|
for (const sample of profile.samples) {
|
|
expect(nodeIds.has(sample)).toBe(true);
|
|
}
|
|
});
|
|
|
|
test("Profiler.setSamplingInterval works", () => {
|
|
session.post("Profiler.enable");
|
|
const result = session.post("Profiler.setSamplingInterval", { interval: 500 });
|
|
expect(result).toEqual({});
|
|
});
|
|
|
|
test("Profiler.setSamplingInterval throws if profiler is running", () => {
|
|
session.post("Profiler.enable");
|
|
session.post("Profiler.start");
|
|
expect(() => session.post("Profiler.setSamplingInterval", { interval: 500 })).toThrow(
|
|
"Cannot change sampling interval while profiler is running",
|
|
);
|
|
session.post("Profiler.stop");
|
|
});
|
|
|
|
test("Profiler.setSamplingInterval requires positive interval", () => {
|
|
session.post("Profiler.enable");
|
|
expect(() => session.post("Profiler.setSamplingInterval", { interval: 0 })).toThrow();
|
|
expect(() => session.post("Profiler.setSamplingInterval", { interval: -1 })).toThrow();
|
|
});
|
|
|
|
test("double Profiler.start is a no-op", () => {
|
|
session.post("Profiler.enable");
|
|
session.post("Profiler.start");
|
|
const result = session.post("Profiler.start");
|
|
expect(result).toEqual({});
|
|
session.post("Profiler.stop");
|
|
});
|
|
|
|
test("profiler can be restarted after stop", () => {
|
|
// First run
|
|
session.post("Profiler.enable");
|
|
session.post("Profiler.start");
|
|
let sum = 0;
|
|
for (let i = 0; i < 1000; i++) sum += i;
|
|
const result1 = session.post("Profiler.stop");
|
|
expect(result1).toHaveProperty("profile");
|
|
|
|
// Second run
|
|
session.post("Profiler.start");
|
|
for (let i = 0; i < 1000; i++) sum += i;
|
|
const result2 = session.post("Profiler.stop");
|
|
expect(result2).toHaveProperty("profile");
|
|
|
|
// Both profiles should be valid
|
|
expect(result1.profile.nodes.length).toBeGreaterThanOrEqual(1);
|
|
expect(result2.profile.nodes.length).toBeGreaterThanOrEqual(1);
|
|
});
|
|
|
|
test("disconnect() stops running profiler", () => {
|
|
session.post("Profiler.enable");
|
|
session.post("Profiler.start");
|
|
session.disconnect();
|
|
|
|
// Create new session and verify profiler was stopped
|
|
const session2 = new inspector.Session();
|
|
session2.connect();
|
|
session2.post("Profiler.enable");
|
|
|
|
// This should work without error (profiler is not running)
|
|
const result = session2.post("Profiler.setSamplingInterval", { interval: 500 });
|
|
expect(result).toEqual({});
|
|
session2.disconnect();
|
|
});
|
|
});
|
|
|
|
describe("callback API", () => {
|
|
test("post() with callback receives result", async () => {
|
|
const session = new inspector.Session();
|
|
session.connect();
|
|
|
|
const { promise, resolve } = Promise.withResolvers<any>();
|
|
session.post("Profiler.enable", (err, result) => {
|
|
resolve({ err, result });
|
|
});
|
|
|
|
const { err, result } = await promise;
|
|
expect(err).toBeNull();
|
|
expect(result).toEqual({});
|
|
session.disconnect();
|
|
});
|
|
|
|
test("post() with callback receives error", async () => {
|
|
const session = new inspector.Session();
|
|
session.connect();
|
|
|
|
const { promise, resolve } = Promise.withResolvers<any>();
|
|
session.post("Profiler.start", (err, result) => {
|
|
resolve({ err, result });
|
|
});
|
|
|
|
const { err, result } = await promise;
|
|
expect(err).toBeInstanceOf(Error);
|
|
expect(err.message).toContain("not enabled");
|
|
session.disconnect();
|
|
});
|
|
});
|
|
|
|
describe("unsupported methods", () => {
|
|
test("unsupported method throws", () => {
|
|
const session = new inspector.Session();
|
|
session.connect();
|
|
expect(() => session.post("Runtime.evaluate")).toThrow("not supported");
|
|
session.disconnect();
|
|
});
|
|
|
|
test("coverage APIs throw not supported", () => {
|
|
const session = new inspector.Session();
|
|
session.connect();
|
|
session.post("Profiler.enable");
|
|
expect(() => session.post("Profiler.getBestEffortCoverage")).toThrow("not supported");
|
|
expect(() => session.post("Profiler.startPreciseCoverage")).toThrow("not supported");
|
|
expect(() => session.post("Profiler.stopPreciseCoverage")).toThrow("not supported");
|
|
expect(() => session.post("Profiler.takePreciseCoverage")).toThrow("not supported");
|
|
session.disconnect();
|
|
});
|
|
});
|
|
|
|
describe("exports", () => {
|
|
test("url() returns undefined", () => {
|
|
expect(inspector.url()).toBeUndefined();
|
|
});
|
|
|
|
test("console is exported", () => {
|
|
expect(inspector.console).toBeObject();
|
|
expect(inspector.console.log).toBe(globalThis.console.log);
|
|
});
|
|
|
|
test("open() throws not implemented", () => {
|
|
expect(() => inspector.open()).toThrow();
|
|
});
|
|
|
|
test("close() throws not implemented", () => {
|
|
expect(() => inspector.close()).toThrow();
|
|
});
|
|
|
|
test("waitForDebugger() throws not implemented", () => {
|
|
expect(() => inspector.waitForDebugger()).toThrow();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("node:inspector/promises", () => {
|
|
test("Session is exported", () => {
|
|
expect(inspectorPromises.Session).toBeInstanceOf(Function);
|
|
});
|
|
|
|
test("post() returns a Promise", async () => {
|
|
const session = new inspectorPromises.Session();
|
|
session.connect();
|
|
|
|
const result = session.post("Profiler.enable");
|
|
expect(result).toBeInstanceOf(Promise);
|
|
|
|
await expect(result).resolves.toEqual({});
|
|
session.disconnect();
|
|
});
|
|
|
|
test("post() rejects on error", async () => {
|
|
const session = new inspectorPromises.Session();
|
|
session.connect();
|
|
|
|
await expect(session.post("Profiler.start")).rejects.toThrow("not enabled");
|
|
session.disconnect();
|
|
});
|
|
|
|
test("complete profiling workflow with promises", async () => {
|
|
const session = new inspectorPromises.Session();
|
|
session.connect();
|
|
|
|
await session.post("Profiler.enable");
|
|
await session.post("Profiler.start");
|
|
|
|
// Do some work
|
|
function work(n: number): number {
|
|
if (n <= 1) return n;
|
|
return work(n - 1) + work(n - 2);
|
|
}
|
|
work(15);
|
|
|
|
const result = await session.post("Profiler.stop");
|
|
expect(result).toHaveProperty("profile");
|
|
expect(result.profile.nodes).toBeArray();
|
|
|
|
await session.post("Profiler.disable");
|
|
session.disconnect();
|
|
});
|
|
|
|
test("other exports are the same as node:inspector", () => {
|
|
expect(inspectorPromises.url).toBe(inspector.url);
|
|
expect(inspectorPromises.console).toBe(inspector.console);
|
|
expect(inspectorPromises.open).toBe(inspector.open);
|
|
expect(inspectorPromises.close).toBe(inspector.close);
|
|
expect(inspectorPromises.waitForDebugger).toBe(inspector.waitForDebugger);
|
|
});
|
|
});
|