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"; import { selectRepositoryPaths } from "../../scripts/lib/repository-layout.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 * `/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