Files
clean-architecture-frontend…/tests/unit/fixture-node-modules.test.ts
T
donghyeon-kaandClaude Opus 5.5 a8520f6dfb fix(fixtures): keep pnpm in a linked fixture from installing (F-4)
pnpm verifies the install before a script, and a fixture running it with
CI=true against an install made without CI saw other settings and installed
through the linked .pnpm and .bin, rewriting the shared lock.yaml and shims.
Every fixture pnpm run now turns that check off; a test pins it for all.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-27 13:20:12 +09:00

288 lines
11 KiB
TypeScript

import { spawnSync } from "node:child_process";
import {
copyFile,
lstat,
mkdtemp,
mkdir,
readdir,
readFile,
rm,
stat,
writeFile,
} from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
import { afterEach, describe, expect, it } from "vitest";
import {
FIXTURE_PNPM_ENVIRONMENT,
linkFixtureNodeModules,
} from "../../scripts/lib/fixture-node-modules.ts";
/**
* A removal or provider fixture runs `pnpm` inside a throwaway copy of the
* repository. pnpm does not recognise the modules directory it finds there and
* purges it, and with `CI=true` it does so without a prompt. When
* `<fixture>/node_modules` was a single directory symlink, that purge followed
* the link and deleted the repository's own installed dependencies mid-run —
* a test suite uninstalling the workspace it was running in.
*/
describe("fixture node_modules linking", () => {
async function sourceTree() {
const source = await mkdtemp(path.join(tmpdir(), "fixture-source-"));
const modules = path.join(source, "node_modules");
await mkdir(path.join(modules, "left", "lib"), { recursive: true });
await mkdir(path.join(modules, "@scope", "right"), { recursive: true });
await mkdir(path.join(modules, ".bin"), { recursive: true });
await writeFile(path.join(modules, "left", "lib", "index.js"), "export default 1;\n");
await writeFile(path.join(modules, "@scope", "right", "package.json"), "{}\n");
await writeFile(path.join(modules, ".modules.yaml"), "{}\n");
return source;
}
it("survives a recursive delete of the fixture's node_modules", async () => {
const source = await sourceTree();
const fixture = await mkdtemp(path.join(tmpdir(), "fixture-root-"));
try {
await linkFixtureNodeModules(fixture, source);
// The fixture resolves the same packages...
expect(
await readFile(
path.join(fixture, "node_modules/left/lib/index.js"),
"utf8",
),
).toContain("export default 1;");
expect(
(await readdir(path.join(fixture, "node_modules"))).sort(),
).toEqual([".bin", ".modules.yaml", "@scope", "left"]);
// ...and this is exactly what pnpm's purge does.
await rm(path.join(fixture, "node_modules"), {
recursive: true,
force: true,
});
// The repository's real dependencies are untouched.
expect(
await readFile(
path.join(source, "node_modules/left/lib/index.js"),
"utf8",
),
).toContain("export default 1;");
expect(
await stat(path.join(source, "node_modules/@scope/right/package.json")),
).toBeDefined();
expect(
(await readdir(path.join(source, "node_modules"))).sort(),
).toEqual([".bin", ".modules.yaml", "@scope", "left"]);
} finally {
await rm(source, { recursive: true, force: true });
await rm(fixture, { recursive: true, force: true });
}
});
// pnpm rewrites `.pnpm-workspace-state-v1.json` in place when it runs inside
// the fixture. Through a symlink that write landed in the repository's own
// state file, so the next pnpm command there re-verified the install.
it("copies the pnpm state files instead of linking them", async () => {
const source = await sourceTree();
const fixture = await mkdtemp(path.join(tmpdir(), "fixture-root-"));
const stateFiles = [".modules.yaml", ".package-map.json", ".pnpm-workspace-state-v1.json"];
try {
for (const file of stateFiles) {
await writeFile(path.join(source, "node_modules", file), `{"projects":{"${source}":{}}}\n`);
}
await linkFixtureNodeModules(fixture, source);
for (const file of stateFiles) {
const copied = path.join(fixture, "node_modules", file);
expect((await lstat(copied)).isSymbolicLink(), file).toBe(false);
await writeFile(copied, `{"projects":{"${fixture}":{}}}\n`);
expect(await readFile(path.join(source, "node_modules", file), "utf8"), file)
.toBe(`{"projects":{"${source}":{}}}\n`);
}
} finally {
await rm(source, { recursive: true, force: true });
await rm(fixture, { recursive: true, force: true });
}
});
// A copied state file still names the repository as the validated project,
// so pnpm inside the fixture re-verified the install and started one through
// the linked directories. Pointing it at the fixture keeps pnpm from
// installing into a tree whose packages are shared with the repository.
it("points the copied workspace state at the fixture root", async () => {
const source = await sourceTree();
const fixture = await mkdtemp(path.join(tmpdir(), "fixture-root-"));
const statePath = ".pnpm-workspace-state-v1.json";
try {
await writeFile(
path.join(source, "node_modules", statePath),
JSON.stringify({
lastValidatedTimestamp: 1,
projects: { [source]: { name: "template", version: "0.1.0" } },
settings: { dev: true },
}),
);
const before = Date.now();
await linkFixtureNodeModules(fixture, source);
const state = JSON.parse(
await readFile(path.join(fixture, "node_modules", statePath), "utf8"),
);
expect(state.projects).toEqual({
[fixture]: { name: "template", version: "0.1.0" },
});
expect(state.lastValidatedTimestamp).toBeGreaterThanOrEqual(before);
expect(state.settings).toEqual({ dev: true });
} finally {
await rm(source, { recursive: true, force: true });
await rm(fixture, { recursive: true, force: true });
}
});
it("creates node_modules as a real directory, never a symlink", async () => {
const source = await sourceTree();
const fixture = await mkdtemp(path.join(tmpdir(), "fixture-root-"));
try {
await linkFixtureNodeModules(fixture, source);
const entry = await lstat(path.join(fixture, "node_modules"));
expect(entry.isSymbolicLink()).toBe(false);
expect(entry.isDirectory()).toBe(true);
expect(
(await lstat(path.join(fixture, "node_modules/left"))).isSymbolicLink(),
).toBe(true);
} finally {
await rm(source, { recursive: true, force: true });
await rm(fixture, { recursive: true, force: true });
}
});
});
/**
* F-4. pnpm 11 verifies the install before it runs a script and, finding the
* fixture's copied state unfamiliar, installs. `.pnpm` and `.bin` are
* directory links into the repository's own node_modules, so that install
* rewrote the shared `.pnpm/lock.yaml` and bin shims. A fixture launched
* through `pnpm <script>` inherited `pnpm_config_verify_deps_before_run=false`
* from pnpm and was safe; the same fixture started directly
* (`node scripts/run-vitest.ts run <file>`) was not.
*/
describe("pnpm inside a linked fixture (F-4)", () => {
const scratch: string[] = [];
afterEach(async () => {
await Promise.all(
scratch.splice(0).map((root) => rm(root, { recursive: true, force: true })),
);
});
/** A tiny installed workspace standing in for the repository, offline. */
async function installedSource() {
const root = await mkdtemp(path.join(tmpdir(), "fixture-pnpm-"));
scratch.push(root);
const tool = path.join(root, "tool");
const source = path.join(root, "source");
await mkdir(tool, { recursive: true });
await mkdir(source, { recursive: true });
await writeFile(
path.join(tool, "package.json"),
JSON.stringify({ name: "tool", version: "1.0.0", bin: { tool: "cli.js" } }),
);
await writeFile(path.join(tool, "cli.js"), "#!/usr/bin/env node\n");
await writeFile(
path.join(source, "package.json"),
JSON.stringify({
name: "fixture-source",
version: "1.0.0",
private: true,
packageManager: "pnpm@11.17.0",
scripts: { hello: "echo hello-from-fixture" },
dependencies: { tool: "file:../tool" },
}),
);
await writeFile(path.join(source, "pnpm-workspace.yaml"), "allowBuilds: {}\n");
const environment: NodeJS.ProcessEnv = {
...pnpmFreeEnvironment(),
pnpm_config_store_dir: path.join(root, "store"),
};
// Installed on a developer machine (no CI); the fixtures then run pnpm
// with CI=true, which pnpm reads as different settings and reinstalls.
const { CI: _ci, ...developer } = environment;
const install = spawnSync("corepack", ["pnpm", "install", "--offline"], {
cwd: source,
encoding: "utf8",
env: developer,
});
expect(install.status, install.stdout + install.stderr).toBe(0);
return { root, source, environment };
}
// The test runner itself may run under pnpm, which exports the setting.
function pnpmFreeEnvironment(): NodeJS.ProcessEnv {
const environment: NodeJS.ProcessEnv = { ...process.env, CI: "true" };
delete environment.pnpm_config_verify_deps_before_run;
return environment;
}
async function sharedState(source: string) {
const lock = await stat(path.join(source, "node_modules/.pnpm/lock.yaml"));
const bin = await stat(path.join(source, "node_modules/.bin/tool"));
return [lock.mtimeMs, lock.ino, bin.mtimeMs, bin.ino];
}
async function runInFixture(
root: string,
source: string,
environment: NodeJS.ProcessEnv,
) {
const fixture = path.join(root, `fixture-${scratch.length}-${Date.now()}`);
await mkdir(fixture);
for (const file of ["package.json", "pnpm-lock.yaml", "pnpm-workspace.yaml"]) {
await copyFile(path.join(source, file), path.join(fixture, file));
}
await linkFixtureNodeModules(fixture, source);
const before = await sharedState(source);
const result = spawnSync("corepack", ["pnpm", "hello"], {
cwd: fixture,
encoding: "utf8",
env: environment,
});
return { result, changed: (await sharedState(source)).join() !== before.join() };
}
it("installs through the linked directories unless told not to", async () => {
const { root, source, environment } = await installedSource();
// The hazard: the default re-verification installs into the shared tree.
expect((await runInFixture(root, source, environment)).changed).toBe(true);
const guarded = await runInFixture(root, source, {
...environment,
...FIXTURE_PNPM_ENVIRONMENT,
});
expect(guarded.result.status, guarded.result.stderr).toBe(0);
expect(guarded.result.stdout).toContain("hello-from-fixture");
expect(guarded.changed).toBe(false);
}, 60_000);
it("is used by every fixture that links node_modules and runs pnpm", async () => {
const listed = spawnSync(
"git",
["grep", "-l", "linkFixtureNodeModules(", "--", "scripts", "tests"],
{ encoding: "utf8" },
);
expect(listed.status, listed.stderr).toBe(0);
const offenders: string[] = [];
for (const file of listed.stdout.trim().split("\n")) {
if (file === "scripts/lib/fixture-node-modules.ts") continue;
if (file === "tests/unit/fixture-node-modules.test.ts") continue;
const source = await readFile(file, "utf8");
const runsPnpm = /\["pnpm"|\[pnpmCli\b/u.test(source);
if (runsPnpm && !source.includes("FIXTURE_PNPM_ENVIRONMENT")) offenders.push(file);
}
expect(offenders).toEqual([]);
});
});