mirror of
https://github.com/hanzoai/dev-desktop.git
synced 2026-11-20 01:07:23 +00:00
150 lines
6.0 KiB
TypeScript
150 lines
6.0 KiB
TypeScript
// @effect-diagnostics nodeBuiltinImport:off -- Runs the profiling preload in a real Node subprocess.
|
|
import * as NodeChildProcess from "node:child_process";
|
|
import * as NodeFS from "node:fs";
|
|
import * as NodeOS from "node:os";
|
|
import * as NodePath from "node:path";
|
|
import * as NodeURL from "node:url";
|
|
import * as Schema from "effect/Schema";
|
|
import { expect, it } from "vite-plus/test";
|
|
|
|
const decodeTrace = Schema.decodeUnknownSync(
|
|
Schema.fromJsonString(
|
|
Schema.Struct({
|
|
traceEvents: Schema.Array(
|
|
Schema.Struct({
|
|
name: Schema.String,
|
|
ts: Schema.Number,
|
|
dur: Schema.Number,
|
|
args: Schema.optional(
|
|
Schema.Struct({
|
|
stage: Schema.optional(Schema.String),
|
|
url: Schema.optional(Schema.String),
|
|
parentURL: Schema.optional(Schema.String),
|
|
importedBy: Schema.optional(Schema.String),
|
|
installed: Schema.optional(Schema.Boolean),
|
|
}),
|
|
),
|
|
}),
|
|
),
|
|
}),
|
|
),
|
|
);
|
|
|
|
const decodeRunner = Schema.decodeUnknownSync(
|
|
Schema.fromJsonString(Schema.Struct({ pid: Schema.Number, args: Schema.Array(Schema.String) })),
|
|
);
|
|
|
|
it("attributes ESM and CommonJS imports without changing module execution", () => {
|
|
const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "hanzo-startup-profile-"));
|
|
try {
|
|
NodeFS.writeFileSync(NodePath.join(directory, "package.json"), '{"type":"module"}');
|
|
const fixtures = {
|
|
"root.mjs": `
|
|
import { value } from './dependency.mjs';
|
|
import strict from './strict.cjs';
|
|
import loose from './loose.cjs';
|
|
import interop from './interop.cjs';
|
|
if (value !== 42 || strict !== undefined || loose !== true || interop !== 9) {
|
|
throw Error('Profiling changed module semantics');
|
|
}
|
|
`,
|
|
"dependency.mjs": "export const value = 42;",
|
|
"strict.cjs": `/* retain the directive */\n"use strict"; module.exports = (function () { return this; })();`,
|
|
"loose.cjs": "module.exports = (function () { return this; })() === globalThis;",
|
|
"interop.cjs": "module.exports = require('./required.js').value;",
|
|
"required.js": "export const value = 9;",
|
|
};
|
|
for (const [name, source] of Object.entries(fixtures)) {
|
|
NodeFS.writeFileSync(NodePath.join(directory, name), source);
|
|
}
|
|
const output = NodePath.join(directory, "capture");
|
|
const root = NodeURL.pathToFileURL(
|
|
NodeFS.realpathSync(NodePath.join(directory, "root.mjs")),
|
|
).href;
|
|
NodeChildProcess.execFileSync(
|
|
process.execPath,
|
|
[
|
|
"--no-node-snapshot",
|
|
"--import",
|
|
NodeURL.pathToFileURL(NodePath.join(import.meta.dirname, "profile-startup.mjs")).href,
|
|
"--input-type=module",
|
|
"-e",
|
|
`await import(${JSON.stringify(root)})`,
|
|
],
|
|
{ env: { ...process.env, NODE_OPTIONS: "", HANZO_DEV_STARTUP_PROFILE_DIR: output } },
|
|
);
|
|
const spans = NodeFS.readdirSync(output)
|
|
.filter((name) => name.endsWith(".modules.json"))
|
|
.flatMap(
|
|
(name) => decodeTrace(NodeFS.readFileSync(NodePath.join(output, name), "utf8")).traceEvents,
|
|
);
|
|
expect(spans.some((span) => span.args?.installed === true)).toBe(true);
|
|
for (const name of Object.keys(fixtures)) {
|
|
const url = NodeURL.pathToFileURL(NodeFS.realpathSync(NodePath.join(directory, name))).href;
|
|
const stages = spans.filter((span) => span.args?.url === url).map((span) => span.args?.stage);
|
|
expect(stages, name).toEqual(
|
|
expect.arrayContaining(
|
|
name === "required.js" ? ["link", "require-esm"] : ["prepare", "evaluate"],
|
|
),
|
|
);
|
|
}
|
|
const prepared = spans.find(
|
|
(span) => span.args?.url === root && span.args?.stage === "prepare",
|
|
);
|
|
const linked = spans.find((span) => span.args?.url === root && span.args?.stage === "link");
|
|
if (!prepared || !linked) throw Error("Missing root module preparation/link boundaries");
|
|
expect(prepared.ts + prepared.dur).toBeLessThanOrEqual(linked.ts);
|
|
const dependency = NodeURL.pathToFileURL(
|
|
NodeFS.realpathSync(NodePath.join(directory, "dependency.mjs")),
|
|
).href;
|
|
expect(
|
|
spans.find((span) => span.args?.url === dependency && span.args?.stage === "link")?.args
|
|
?.importedBy,
|
|
).toBe(root);
|
|
} finally {
|
|
NodeFS.rmSync(directory, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("captures only the dev runner and preserves its exit status", () => {
|
|
const directory = NodeFS.mkdtempSync(NodePath.join(NodeOS.tmpdir(), "hanzo-startup-launcher-"));
|
|
try {
|
|
NodeFS.mkdirSync(NodePath.join(directory, "scripts"));
|
|
NodeFS.writeFileSync(
|
|
NodePath.join(directory, "scripts/dev-runner.ts"),
|
|
"console.log(JSON.stringify({ pid: process.pid, args: process.argv.slice(2) }));",
|
|
);
|
|
const output = NodePath.join(directory, "capture");
|
|
const stdout = NodeChildProcess.execFileSync(
|
|
process.execPath,
|
|
[NodePath.join(import.meta.dirname, "profile-startup.mjs"), "--no-seed"],
|
|
{
|
|
cwd: directory,
|
|
env: { ...process.env, NODE_OPTIONS: "", HANZO_DEV_STARTUP_PROFILE_DIR: output },
|
|
encoding: "utf8",
|
|
},
|
|
);
|
|
const runner = decodeRunner(stdout.trim().split("\n").at(-1));
|
|
expect(runner.args).toEqual(["dev", "--no-seed"]);
|
|
expect(NodeFS.readdirSync(output).sort()).toEqual(
|
|
["cpuprofile", "modules.json", "process.json"].map((suffix) => `${runner.pid}-0.${suffix}`),
|
|
);
|
|
NodeFS.writeFileSync(
|
|
NodePath.join(directory, "scripts/dev-runner.ts"),
|
|
"process.kill(process.pid, 'SIGTERM');",
|
|
);
|
|
const interrupted = NodeChildProcess.spawnSync(
|
|
process.execPath,
|
|
[NodePath.join(import.meta.dirname, "profile-startup.mjs")],
|
|
{
|
|
cwd: directory,
|
|
env: { ...process.env, NODE_OPTIONS: "", HANZO_DEV_STARTUP_PROFILE_DIR: output },
|
|
},
|
|
);
|
|
expect(interrupted.error).toBeUndefined();
|
|
expect(interrupted.status).toBe(1);
|
|
} finally {
|
|
NodeFS.rmSync(directory, { recursive: true, force: true });
|
|
}
|
|
});
|