fix(bunfig): fix and test preloads (#16329)

test/config/bunfig/fixtures/preload/mixed/bunfig.toml

@@ -0,0 +1,4 @@
+preload = "./preload-run.ts"
+
+[test]
+preload = "./preload-test.ts"

test/config/bunfig/fixtures/preload/mixed/index.fixture-test.ts

@@ -0,0 +1,5 @@
+it("the correct file was preloaded", () => {
+  expect(globalThis.preload).toBeDefined();
+  expect(globalThis.preload).toBeArrayOfSize(1);
+  expect(globalThis.preload[0]).toEqual("mixed/preload-test.ts");
+});

test/config/bunfig/fixtures/preload/mixed/index.ts

@@ -0,0 +1,2 @@
+import assert from "node:assert";
+assert.deepStrictEqual(globalThis.preload, ["mixed/preload-run.ts"]);

test/config/bunfig/fixtures/preload/mixed/preload-run.ts

@@ -0,0 +1,2 @@
+// this file's name so we know the right file was loaded
+(globalThis.preload ??= []).push("mixed/preload-run.ts");

test/config/bunfig/fixtures/preload/mixed/preload-test.ts

@@ -0,0 +1,2 @@
+// this file's name so we know the right file was loaded
+(globalThis.preload ??= []).push("mixed/preload-test.ts");

test/config/bunfig/fixtures/preload/mixed/readme.md

@@ -0,0 +1,2 @@
+preloads in `[test]` should not be loaded by `bun run`. `bun test` should use both
+top-level and `[test]` preloads.

test/config/bunfig/fixtures/preload/multi/bunfig.toml

@@ -0,0 +1 @@
+preload = ["./preload1.ts", "./preload2.ts"]

test/config/bunfig/fixtures/preload/multi/cli-merge.ts

@@ -0,0 +1,2 @@
+import assert from "node:assert";
+assert.deepStrictEqual(globalThis.preload, ["multi/preload1.ts", "multi/preload2.ts", "multi/preload3.ts"]);

test/config/bunfig/fixtures/preload/multi/empty.ts

@@ -0,0 +1,3 @@
+// `bun --config=bunfig.empty.toml run index.ts`
+import assert from "node:assert";
+assert.strictEqual(globalThis.preload, undefined);

test/config/bunfig/fixtures/preload/multi/index.ts

@@ -0,0 +1,2 @@
+import assert from "node:assert";
+assert.deepStrictEqual(globalThis.preload, ["multi/preload1.ts", "multi/preload2.ts"]);

test/config/bunfig/fixtures/preload/multi/preload1.ts

@@ -0,0 +1 @@
+(globalThis.preload ??= []).push("multi/preload1.ts");

test/config/bunfig/fixtures/preload/multi/preload2.ts

@@ -0,0 +1 @@
+(globalThis.preload ??= []).push("multi/preload2.ts");

test/config/bunfig/fixtures/preload/multi/preload3.ts

@@ -0,0 +1 @@
+(globalThis.preload ??= []).push("multi/preload3.ts");

test/config/bunfig/fixtures/preload/multi/readme.md

@@ -0,0 +1,7 @@
+Used to test 3 behaviors:
+
+1. `preload` can be an array
+2. When a bunfig is specified via `--config=<path>`, the "default" bunfig (i.e.
+   `bunfig.toml` in the same dir as cwd) is not loaded.
+3. Using `--preload <file>` adds `<file>` to the preload list without clobbering
+   existing preloads.

test/config/bunfig/fixtures/preload/parent/foo/bunfig.toml

@@ -0,0 +1 @@
+preload = "../preload.ts"

test/config/bunfig/fixtures/preload/parent/foo/index.ts

@@ -0,0 +1,2 @@
+import assert from "node:assert";
+assert.equal(globalThis.preload, "parent/preload.ts");

test/config/bunfig/fixtures/preload/parent/preload.ts

@@ -0,0 +1 @@
+globalThis.preload = "parent/preload.ts";

test/config/bunfig/fixtures/preload/plugin/bunfig.toml

@@ -0,0 +1 @@
+preload = "bun-plugin-yaml"

test/config/bunfig/fixtures/preload/plugin/foo.yaml

@@ -0,0 +1,2 @@
+foo:
+  bar: "baz"

test/config/bunfig/fixtures/preload/plugin/index.ts

@@ -0,0 +1,4 @@
+import assert from "node:assert";
+import foo from "./foo.yaml";
+assert(foo);
+assert.equal(typeof foo, "object");

test/config/bunfig/fixtures/preload/relative/bunfig.toml

@@ -0,0 +1,2 @@
+# no "./", should be treated as a relative path
+preload = "preload.ts"

test/config/bunfig/fixtures/preload/relative/index.fixture-test.ts

@@ -0,0 +1,3 @@
+it("the correct file was preloaded", () => {
+  expect(globalThis.preload).toBe("simple/preload.ts");
+});

test/config/bunfig/fixtures/preload/relative/index.ts

@@ -0,0 +1,2 @@
+import assert from "node:assert";
+assert.strictEqual(globalThis.preload, "simple/preload.ts");

test/config/bunfig/fixtures/preload/relative/preload.ts

@@ -0,0 +1,2 @@
+// this file's name so we know the right file was loaded
+globalThis.preload = "simple/preload.ts";

test/config/bunfig/fixtures/preload/simple/bunfig.toml

@@ -0,0 +1 @@
+preload = "./preload.ts"

test/config/bunfig/fixtures/preload/simple/index.fixture-test.ts

@@ -0,0 +1,3 @@
+it("the correct file was preloaded", () => {
+  expect(globalThis.preload).toBe("simple/preload.ts");
+});

test/config/bunfig/fixtures/preload/simple/index.ts

@@ -0,0 +1,2 @@
+import assert from "node:assert";
+assert.strictEqual(globalThis.preload, "simple/preload.ts");

test/config/bunfig/fixtures/preload/simple/preload.ts

@@ -0,0 +1,2 @@
+// this file's name so we know the right file was loaded
+globalThis.preload = "simple/preload.ts";

test/config/bunfig/preload.test.ts

@@ -0,0 +1,136 @@
+import { join, resolve } from "path";
+import { bunExe, bunEnv } from "harness";
+import type { SpawnOptions } from "bun";
+
+const fixturePath = (...segs: string[]) => resolve(import.meta.dirname, "fixtures", "preload", ...segs);
+
+type Opts = {
+  args?: string[];
+  cwd?: string;
+};
+type Out = [stdout: string, stderr: string, exitCode: number];
+const run = (file: string, { args = [], cwd }: Opts = {}): Promise<Out> => {
+  const res = Bun.spawn([bunExe(), ...args, file], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: bunEnv,
+  } satisfies SpawnOptions.OptionsObject<"ignore", "pipe", "pipe">);
+
+  return Promise.all([
+    new Response(res.stdout).text().then(s => s.trim()),
+    new Response(res.stderr).text().then(s => s.trim()),
+    res.exited,
+  ]);
+};
+
+describe("Given a single universal preload", () => {
+  const dir = fixturePath("simple");
+
+  // `bun run` looks for a `bunfig.toml` in the current directory by default
+  it("When `bun run` is run and `bunfig.toml` is implicitly loaded, preloads are run", async () => {
+    // `bun run index.ts`
+    const [out, err, code] = await run("index.ts", { cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+
+  // FIXME: relative paths are being resolved to cwd, not the file's directory
+  it.skip("When `bun run` is run from a different directory but bunfig.toml is explicitly used, preloads are run", async () => {
+    // `bun run index.ts`
+    const [out, err, code] = await run(join(dir, "index.ts"), {
+      args: [`--config=${join(dir, "bunfig.toml")}`],
+      cwd: process.cwd(),
+    });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+}); // </given a single universal preload>
+
+describe("Given a bunfig.toml with both universal and test-only preloads", () => {
+  const dir = fixturePath("mixed");
+
+  it("`bun run index.ts` only loads the universal preload", async () => {
+    const [out, err, code] = await run("index.ts", { cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+
+  it("`bun test` only loads test-only preloads, clobbering the universal ones", async () => {
+    const [out, err, code] = await run("./index.fixture-test.ts", { args: ["test"], cwd: dir });
+    // note: err has test report, out has "bun test <version>"
+
+    expect(code).toBe(0);
+  });
+}); // </given a bunfig.toml with both universal and test-only preloads>
+
+describe("Given a `bunfig.toml` with a list of preloads", () => {
+  const dir = fixturePath("multi");
+
+  it("When `bun run` is run, preloads are run", async () => {
+    const [out, err, code] = await run("index.ts", { cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+
+  it("when passed `--config=bunfig.empty.toml`, preloads are not run", async () => {
+    const [out, err, code] = await run("empty.ts", { args: ["--config=bunfig.empty.toml"], cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+
+  it.each([
+    //
+    "--preload ./preload3.ts",
+    "--preload=./preload3.ts",
+    // FIXME: Tests are failing due to active bugs
+    // "--preload ./preload3.ts run",
+    // "--preload=./preload3.ts run",
+    // "run --preload ./preload3.ts",
+    // "run --preload=./preload3.ts",
+  ])("When `bun %s cli-merge.ts` is run, `--preload` adds the target file to the list of preloads", async args => {
+    const [out, err, code] = await run("cli-merge.ts", { args: args.split(" "), cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+}); // </given a `bunfig.toml` with a list of preloads>
+
+describe("Given a `bunfig.toml` with a plugin preload", () => {
+  const dir = fixturePath("plugin");
+
+  it.todo("When `bun run` is run, preloads are run", async () => {
+    const [out, err, code] = await run("index.ts", { cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+}); // </given a `bunfig.toml` with a plugin preload>
+
+describe("Given a `bunfig.toml` file with a relative path to a preload in a parent directory", () => {
+  const dir = fixturePath("parent", "foo");
+
+  // FIXME
+  it("When `bun run` is run, preloads are run", async () => {
+    const [out, err, code] = await run("index.ts", { cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+}); // </given a `bunfit.toml` file with a relative path to a preload in a parent directory>
+
+describe("Given a `bunfig.toml` file with a relative path without a leading './'", () => {
+  const dir = fixturePath("relative");
+
+  // FIXME: currently treaded as an import to an external package
+  it.skip("preload = 'preload.ts' is treated like a relative path and loaded", async () => {
+    const [out, err, code] = await run("index.ts", { cwd: dir });
+    expect(err).toBeEmpty();
+    expect(out).toBeEmpty();
+    expect(code).toBe(0);
+  });
+}); // </given a `bunfig.toml` file with a relative path without a leading './'>