From bd495e48354961bda6903c5be2e869459fc6da80 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Thu, 13 Aug 2026 22:15:29 +0000
Subject: [PATCH 1/2] test(install): give each long-label bun patch test its
 own install cache

The "packages whose label is longer than 1024 bytes" tests run
concurrently and two of them install `bar` from the identical spec. They
relied on the cache dir createTestDir writes to bunfig.toml to keep the
projects apart, but CI exports BUN_INSTALL_CACHE_DIR, which takes
precedence, so both installs published the same cache entry into one
shared cache at the same time. On Windows the install that publishes
second evicts the first one's entry while it is still being read, and
that install exits 1, which failed the test on both Windows lanes.

Pin BUN_INSTALL_CACHE_DIR per project, as the other install tests do, and
attach the install's stderr to the exit code assertion so a failing
install says why.
---
 test/cli/install/bun-patch.test.ts | 45 +++++++++++++++++-------------
 1 file changed, 26 insertions(+), 19 deletions(-)

diff --git a/test/cli/install/bun-patch.test.ts b/test/cli/install/bun-patch.test.ts
index ec6b0b5a061c..129280336d28 100644
--- a/test/cli/install/bun-patch.test.ts
+++ b/test/cli/install/bun-patch.test.ts
@@ -85,7 +85,12 @@ describe("packages whose label is longer than 1024 bytes", () => {
   // on every platform while the recorded spec stays long.
   const longSpec = (tarball: string) => `./${Buffer.alloc(1050, "x/../").toString()}${tarball}`;
 
-  async function createProject(tarball: string, packageJson: Record<string, unknown>) {
+  type Project = { packageDir: string; env: Record<string, string | undefined> };
+
+  // CI exports BUN_INSTALL_CACHE_DIR, which overrides the cache createTestDir writes to bunfig.toml.
+  // Two of these concurrent tests install `bar` from the identical spec, and two installs publishing
+  // the same entry into one shared cache at the same time fail on Windows, so pin a cache per project.
+  async function createProject(tarball: string, packageJson: Record<string, unknown>): Promise<Project> {
     const { packageDir } = await registry.createTestDir({
       bunfigOpts: { linker: "hoisted" },
       files: {
@@ -93,14 +98,14 @@ describe("packages whose label is longer than 1024 bytes", () => {
         [tarball]: readFileSync(join(import.meta.dir, tarball)),
       },
     });
-    return packageDir;
+    return { packageDir, env: { ...bunEnv, BUN_INSTALL_CACHE_DIR: join(packageDir, ".bun-cache") } };
   }
 
-  async function runBun(cwd: string, ...args: string[]) {
+  async function runBun({ packageDir, env }: Project, ...args: string[]) {
     await using proc = Bun.spawn({
       cmd: [bunExe(), ...args],
-      cwd,
-      env: bunEnv,
+      cwd: packageDir,
+      env,
       stdout: "pipe",
       stderr: "pipe",
     });
@@ -108,18 +113,18 @@ describe("packages whose label is longer than 1024 bytes", () => {
     return { stdout, stderr, exitCode };
   }
 
-  async function install(cwd: string) {
-    const { stderr, exitCode } = await runBun(cwd, "install");
+  async function install(project: Project) {
+    const { stderr, exitCode } = await runBun(project, "install");
     expect(stderr).not.toContain("error:");
-    expect(exitCode).toBe(0);
+    expect(exitCode, stderr).toBe(0);
   }
 
   test.concurrent("bun patch <name>@<label>", async () => {
     const spec = longSpec("bar-0.0.2.tgz");
-    const packageDir = await createProject("bar-0.0.2.tgz", { name: "foo", dependencies: { bar: spec } });
-    await install(packageDir);
+    const project = await createProject("bar-0.0.2.tgz", { name: "foo", dependencies: { bar: spec } });
+    await install(project);
 
-    const { stdout, stderr, exitCode } = await runBun(packageDir, "patch", `bar@${spec}`);
+    const { stdout, stderr, exitCode } = await runBun(project, "patch", `bar@${spec}`);
     expect(stderr).not.toContain("error:");
     expect(stdout).toContain("To patch bar, edit the following folder:\n\n  node_modules/bar\n");
     expect(exitCode).toBe(0);
@@ -130,20 +135,21 @@ describe("packages whose label is longer than 1024 bytes", () => {
   // The lockfile lists the long-labeled `bar` before `bar-from-npm`, so both commands
   // format the long label before reaching the package that matches.
   test.concurrent("bun patch <path> when another package with the same name has a long label", async () => {
-    const packageDir = await createProject("bar-0.0.2.tgz", {
+    const project = await createProject("bar-0.0.2.tgz", {
       name: "foo",
       dependencies: { "bar": longSpec("bar-0.0.2.tgz"), "bar-from-npm": "npm:bar@0.0.7" },
     });
-    await install(packageDir);
+    const { packageDir } = project;
+    await install(project);
 
-    const prepare = await runBun(packageDir, "patch", "node_modules/bar-from-npm");
+    const prepare = await runBun(project, "patch", "node_modules/bar-from-npm");
     expect(prepare.stderr).not.toContain("error:");
     expect(prepare.stdout).toContain("To patch bar, edit the following folder:\n\n  node_modules/bar-from-npm\n");
     expect(prepare.exitCode).toBe(0);
 
     await Bun.write(join(packageDir, "node_modules", "bar-from-npm", "index.js"), "module.exports = 'patched';\n");
 
-    const commit = await runBun(packageDir, "patch", "--commit", "node_modules/bar-from-npm");
+    const commit = await runBun(project, "patch", "--commit", "node_modules/bar-from-npm");
     expect(commit.stderr).not.toContain("error:");
     expect(commit.exitCode).toBe(0);
     expect((await Bun.file(join(packageDir, "package.json")).json()).patchedDependencies).toEqual({
@@ -159,16 +165,17 @@ describe("packages whose label is longer than 1024 bytes", () => {
   // system accepts at this length), so what is pinned here is that it fails at that step.
   test.concurrent("bun patch --commit of a long-labeled package exits 1 without recording a patch", async () => {
     const packageJson = { name: "foo", dependencies: { baz: longSpec("baz-0.0.3.tgz") } };
-    const packageDir = await createProject("baz-0.0.3.tgz", packageJson);
-    await install(packageDir);
+    const project = await createProject("baz-0.0.3.tgz", packageJson);
+    const { packageDir } = project;
+    await install(project);
 
-    const prepare = await runBun(packageDir, "patch", "node_modules/baz");
+    const prepare = await runBun(project, "patch", "node_modules/baz");
     expect(prepare.stderr).not.toContain("error:");
     expect(prepare.exitCode).toBe(0);
 
     await Bun.write(join(packageDir, "node_modules", "baz", "index.js"), "console.log('patched baz');\n");
 
-    const commit = await runBun(packageDir, "patch", "--commit", "node_modules/baz");
+    const commit = await runBun(project, "patch", "--commit", "node_modules/baz");
     expect(commit.stderr).toContain("failed renaming patch file to patches dir");
     expect(commit.exitCode).toBe(1);
     expect(await Bun.file(join(packageDir, "package.json")).json()).toEqual(packageJson);

From debec678c3437f92fa1de6f7a77dd9b1f8cb3659 Mon Sep 17 00:00:00 2001
From: robobun <117481402+robobun@users.noreply.github.com>
Date: Fri, 14 Aug 2026 05:43:12 +0000
Subject: [PATCH 2/2] test(install): return a per-project install env from
 createTestDir

The cache that createTestDir writes to bunfig.toml loses to the
BUN_INSTALL_CACHE_DIR the CI runner exports, and several install test
files re-pin the env var per project by hand to get the isolation back.
Return that env from createTestDir instead and have the long-label
bun patch tests use it, rather than adding another local copy.
---
 test/cli/install/bun-patch.test.ts | 12 +++++-------
 test/harness.ts                    | 10 +++++++++-
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/test/cli/install/bun-patch.test.ts b/test/cli/install/bun-patch.test.ts
index 129280336d28..ea9c81fbae6a 100644
--- a/test/cli/install/bun-patch.test.ts
+++ b/test/cli/install/bun-patch.test.ts
@@ -85,20 +85,18 @@ describe("packages whose label is longer than 1024 bytes", () => {
   // on every platform while the recorded spec stays long.
   const longSpec = (tarball: string) => `./${Buffer.alloc(1050, "x/../").toString()}${tarball}`;
 
-  type Project = { packageDir: string; env: Record<string, string | undefined> };
+  type Project = Awaited<ReturnType<VerdaccioRegistry["createTestDir"]>>;
 
-  // CI exports BUN_INSTALL_CACHE_DIR, which overrides the cache createTestDir writes to bunfig.toml.
-  // Two of these concurrent tests install `bar` from the identical spec, and two installs publishing
-  // the same entry into one shared cache at the same time fail on Windows, so pin a cache per project.
-  async function createProject(tarball: string, packageJson: Record<string, unknown>): Promise<Project> {
-    const { packageDir } = await registry.createTestDir({
+  // Two of these concurrent tests install `bar` from the identical spec, so every command runs with
+  // the project's own cache (`project.env`) rather than the cache CI shares across the whole file.
+  function createProject(tarball: string, packageJson: Record<string, unknown>): Promise<Project> {
+    return registry.createTestDir({
       bunfigOpts: { linker: "hoisted" },
       files: {
         "package.json": JSON.stringify(packageJson),
         [tarball]: readFileSync(join(import.meta.dir, tarball)),
       },
     });
-    return { packageDir, env: { ...bunEnv, BUN_INSTALL_CACHE_DIR: join(packageDir, ".bun-cache") } };
   }
 
   async function runBun({ packageDir, env }: Project, ...args: string[]) {
diff --git a/test/harness.ts b/test/harness.ts
index b3167919ec84..63f72b590dad 100644
--- a/test/harness.ts
+++ b/test/harness.ts
@@ -1999,7 +1999,15 @@ export class VerdaccioRegistry {
     const packageJson = join(packageDir, "package.json");
     await this.writeBunfig(packageDir, opts.bunfigOpts);
     this.users = {};
-    return { packageDir: String(packageDir), packageJson };
+    const dir = String(packageDir);
+    return {
+      packageDir: dir,
+      packageJson,
+      // The `install.cache` writeBunfig sets loses to the BUN_INSTALL_CACHE_DIR the CI runner exports, so
+      // projects spawned with plain bunEnv share one cache per test file. Projects that install concurrently
+      // spawn bun with this env instead: concurrent installs publishing the same entry fail on Windows (#28062).
+      env: { ...bunEnv, BUN_INSTALL_CACHE_DIR: join(dir, ".bun-cache") },
+    };
   }
 
   async writeBunfig(dir: string, opts: BunfigOpts = {}) {