chore: run some test cases in bun in CI

.github/workflows/ci.yml

@@ -102,6 +102,32 @@ jobs:
       - name: Run tests
         run: deno task test:node
 
+  test-bun:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 30
+    strategy:
+      fail-fast: false
+      matrix:
+        bun:
+          - latest
+        os:
+          - ubuntu-latest
+
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v4
+
+      - name: Set up Deno
+        uses: denoland/setup-deno@v2
+
+      - name: Set up Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: ${{ matrix.node }}
+
+      - name: Run tests
+        run: deno task test:bun
+
   lint:
     runs-on: ${{ matrix.os }}
     timeout-minutes: 30

.gitignore

@@ -17,3 +17,6 @@ coverage/
 .vim
 _tmp/
 !_tmp/.keep
+
+# tsconfig for bun
+/tsconfig.json

_tools/node_test_runner/.gitignore

@@ -1,2 +1,3 @@
 node_modules
 package-lock.json
+bun.lock

_tools/node_test_runner/run_test.mjs

@@ -75,5 +75,9 @@ import "../../fs/unstable_umask_test.ts";
 import "../../fs/unstable_utime_test.ts";
 
 for (const testDef of testDefinitions) {
-  test(testDef.name, testDef.fn);
+  if (testDef.ignore) {
+    test.skip(testDef.name, testDef.fn);
+  } else {
+    test(testDef.name, testDef.fn);
+  }
 }

_tools/node_test_runner/tsconfig_for_bun.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "paths": {
+      "@std/assert": ["./assert/mod.ts"],
+      "@std/assert/greater-or-equal": ["./assert/greater_or_equal.ts"],
+      "@std/path": ["./path/mod.ts"],
+      "@std/internal/format": ["./internal/format.ts"],
+      "@std/internal/styles": ["./internal/styles.ts"],
+      "@std/internal/build-message": ["./internal/build_message.ts"],
+      "@std/internal/diff": ["./internal/diff.ts"],
+      "@std/internal/diff-str": ["./internal/diff_str.ts"],
+      "@std/semver": ["./semver/mod.ts"],
+    }
+  }
+}

collections/invert_test.ts

@@ -29,7 +29,7 @@ Deno.test("invert() handles nested input", () => {
   // @ts-expect-error - testing invalid input
   invertTest({ a: "x", b: Object }, {
     "x": "a",
-    "function Object() { [native code] }": "b",
+    [Object.toString()]: "b",
   });
   // @ts-expect-error - testing invalid input
   invertTest({ a: "x", b: ["y", "z"] }, { "x": "a", "y,z": "b" });

deno.json

@@ -12,6 +12,7 @@
     "test:with-unsafe-proto": "deno test --unstable-http --unstable-webgpu --unstable-fs --unstable-unsafe-proto --doc --allow-all --parallel --coverage --trace-leaks --clean",
     "test:browser": "git grep --name-only \"This module is browser compatible.\" | grep -v deno.json | grep -v .github/workflows | grep -v _tools | grep -v encoding/README.md | grep -v media_types/vendor/update.ts | xargs deno check --config browser-compat.tsconfig.json",
     "test:node": "(cd _tools/node_test_runner && npm install) && node --import ./_tools/node_test_runner/register_deno_shim.mjs ./_tools/node_test_runner/run_test.mjs",
+    "test:bun": "(cd _tools/node_test_runner && bun install) && cp _tools/node_test_runner/tsconfig_for_bun.json ./tsconfig.json && bun test --require ./_tools/node_test_runner/register_deno_shim.mjs _tools/node_test_runner/run_test.mjs && rm tsconfig.json",
     "fmt:licence-headers": "deno run --allow-read --allow-write ./_tools/check_licence.ts",
     "lint:circular": "deno run --allow-env --allow-read --allow-write --allow-net=deno.land,jsr.io ./_tools/check_circular_package_dependencies.ts",
     "lint:mod-exports": "deno run --allow-env --allow-read ./_tools/check_mod_exports.ts",

fs/_node_fs_file_test.ts

@@ -13,6 +13,7 @@ import { fileURLToPath } from "node:url";
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const testdataDir = resolve(moduleDir, "testdata");
 const readTestFile = join(testdataDir, "copy_file.txt");
+const isBun = navigator.userAgent.includes("Bun/");
 
 Deno.test("FsFile object writes to a newly created file", async () => {
   const tempDirPath = await makeTempDir({ prefix: "FsFile_write_" });
@@ -126,39 +127,47 @@ Deno.test("FsFile object returns the 'stat' of the file handle", async () => {
   fh.close();
 });
 
-Deno.test("FsFile object handles a ReadableStream", async () => {
-  const fh = await open(readTestFile);
-  assert(fh.readable instanceof ReadableStream);
-  const chunks = [];
-  for await (const chunk of fh.readable) {
-    chunks.push(chunk);
-  }
-  assertEquals(chunks.length, 1);
-  if (chunks[0] != null) {
-    assertEquals(chunks[0].byteLength, 3);
-  }
-});
-
-Deno.test("FsFile object handles a WritableStream", async () => {
-  const tempDirPath = await makeTempDir({ prefix: "FsFile_WritableStream_" });
-  const testFile = join(tempDirPath, "testFile.txt");
-  const fh = await open(testFile, { create: true, write: true });
-  assert(fh.writable instanceof WritableStream);
-  const rs = new ReadableStream({
-    start(controller) {
-      const encoder = new TextEncoder();
-      controller.enqueue(encoder.encode("Hello,"));
-      controller.enqueue(encoder.encode(" Standard"));
-      controller.enqueue(encoder.encode(" Library"));
-      controller.close();
-    },
-  });
-  await rs.pipeTo(fh.writable);
-  const readText = await readTextFile(testFile);
-  assertEquals(readText, "Hello, Standard Library");
-
-  await remove(tempDirPath, { recursive: true });
-});
+Deno.test(
+  "FsFile object handles a ReadableStream",
+  { ignore: isBun },
+  async () => {
+    const fh = await open(readTestFile);
+    assert(fh.readable instanceof ReadableStream);
+    const chunks = [];
+    for await (const chunk of fh.readable) {
+      chunks.push(chunk);
+    }
+    assertEquals(chunks.length, 1);
+    if (chunks[0] != null) {
+      assertEquals(chunks[0].byteLength, 3);
+    }
+  },
+);
+
+Deno.test(
+  "FsFile object handles a WritableStream",
+  { ignore: isBun },
+  async () => {
+    const tempDirPath = await makeTempDir({ prefix: "FsFile_WritableStream_" });
+    const testFile = join(tempDirPath, "testFile.txt");
+    const fh = await open(testFile, { create: true, write: true });
+    assert(fh.writable instanceof WritableStream);
+    const rs = new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+        controller.enqueue(encoder.encode("Hello,"));
+        controller.enqueue(encoder.encode(" Standard"));
+        controller.enqueue(encoder.encode(" Library"));
+        controller.close();
+      },
+    });
+    await rs.pipeTo(fh.writable);
+    const readText = await readTextFile(testFile);
+    assertEquals(readText, "Hello, Standard Library");
+
+    await remove(tempDirPath, { recursive: true });
+  },
+);
 
 Deno.test("FsFile object changes access and modification times with utime", async () => {
   const tempFile = await makeTempFile({ prefix: "FsFile_utime_" });
@@ -232,28 +241,32 @@ Deno.test("FsFile object synchronously reads from an existing file", () => {
   fh.close();
 });
 
-Deno.test("FsFile object synchronously truncates a file to zero", () => {
-  const tempDirPath = makeTempDirSync({ prefix: "FsFile_truncateSync_" });
-  const testFile = join(tempDirPath, "testFile.txt");
-  let fh = openSync(testFile, { read: true, write: true, create: true });
-
-  const encoder = new TextEncoder();
-  const data = encoder.encode("Hello, Standard Library");
-  const writeBytes = fh.writeSync(data);
-  assertEquals(writeBytes, 23);
-  fh.close();
+Deno.test(
+  "FsFile object synchronously truncates a file to zero",
+  { ignore: isBun },
+  () => {
+    const tempDirPath = makeTempDirSync({ prefix: "FsFile_truncateSync_" });
+    const testFile = join(tempDirPath, "testFile.txt");
+    let fh = openSync(testFile, { read: true, write: true, create: true });
+
+    const encoder = new TextEncoder();
+    const data = encoder.encode("Hello, Standard Library");
+    const writeBytes = fh.writeSync(data);
+    assertEquals(writeBytes, 23);
+    fh.close();
 
-  fh = openSync(testFile, { read: true, write: true });
-  fh.truncateSync();
+    fh = openSync(testFile, { read: true, write: true });
+    fh.truncateSync();
 
-  const buf = new Uint8Array(10);
-  const readBytes = fh.readSync(buf);
-  // Reading a 0 byte file should return null at EOF.
-  assertEquals(readBytes, null);
-  fh.close();
+    const buf = new Uint8Array(10);
+    const readBytes = fh.readSync(buf);
+    // Reading a 0 byte file should return null at EOF.
+    assertEquals(readBytes, null);
+    fh.close();
 
-  removeSync(tempDirPath, { recursive: true });
-});
+    removeSync(tempDirPath, { recursive: true });
+  },
+);
 
 Deno.test("FsFile object synchronously truncates files to multiple sizes", () => {
   const tempDirPath = makeTempDirSync({ prefix: "FsFile_truncateSync_" });

fs/unstable_chown_test.ts

@@ -8,6 +8,8 @@ import { remove, removeSync } from "./unstable_remove.ts";
 import { platform } from "node:os";
 import { spawn } from "node:child_process";
 
+const isBun = navigator.userAgent.includes("Bun/");
+
 type IdResult = {
   id: string;
   code: number;
@@ -64,7 +66,7 @@ async function getUidAndGid(): Promise<{ uid: number; gid: number }> {
 
 Deno.test({
   name: "chown() changes user and group ids",
-  ignore: platform() === "win32",
+  ignore: platform() === "win32" || isBun,
   fn: async () => {
     const { uid, gid } = await getUidAndGid();
     const tempFile = await makeTempFile({ prefix: "chown_" });
@@ -78,7 +80,7 @@ Deno.test({
 
 Deno.test({
   name: "chown() handles `null` id arguments",
-  ignore: platform() === "win32",
+  ignore: platform() === "win32" || isBun,
   fn: async () => {
     const { uid, gid } = await getUidAndGid();
     const tempFile = await makeTempFile({ prefix: "chown_" });
@@ -115,7 +117,7 @@ Deno.test({
 
 Deno.test({
   name: "chownSync() changes user and group ids",
-  ignore: platform() === "win32",
+  ignore: platform() === "win32" || isBun,
   fn: async () => {
     const { uid, gid } = await getUidAndGid();
     const tempFile = makeTempFileSync({ prefix: "chownSync_ " });
@@ -130,7 +132,7 @@ Deno.test({
 
 Deno.test({
   name: "chownSync() handles `null` id arguments",
-  ignore: platform() === "win32",
+  ignore: platform() === "win32" || isBun,
   fn: async () => {
     const { uid, gid } = await getUidAndGid();
     const tempFile = makeTempFileSync({ prefix: "chownSync_" });

fs/unstable_read_file_test.ts

@@ -13,6 +13,8 @@ import { isDeno } from "./_utils.ts";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
+const isBun = navigator.userAgent.includes("Bun/");
+
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const testdataDir = resolve(moduleDir, "testdata");
 const testFile = join(testdataDir, "copy_file.txt");
@@ -47,39 +49,47 @@ Deno.test("readFile() handles an AbortSignal", async () => {
   assertEquals(error.name, "AbortError");
 });
 
-Deno.test("readFile() handles an AbortSignal with a reason", async () => {
-  const ac = new AbortController();
-  const reasonErr = new Error();
-  queueMicrotask(() => ac.abort(reasonErr));
-
-  const error = await assertRejects(async () => {
-    await readFile(testFile, { signal: ac.signal });
-  }, Error);
-
-  if (isDeno) {
-    assertEquals(error, ac.signal.reason);
-  } else {
-    assertEquals(error.cause, ac.signal.reason);
-  }
-});
+Deno.test(
+  "readFile() handles an AbortSignal with a reason",
+  { ignore: isBun },
+  async () => {
+    const ac = new AbortController();
+    const reasonErr = new Error();
+    queueMicrotask(() => ac.abort(reasonErr));
 
-Deno.test("readFile() handles an AbortSignal with a primitive reason value", async () => {
-  const ac = new AbortController();
-  const reasonErr = "Some string";
-  queueMicrotask(() => ac.abort(reasonErr));
+    const error = await assertRejects(async () => {
+      await readFile(testFile, { signal: ac.signal });
+    }, Error);
 
-  try {
-    await readFile(testFile, { signal: ac.signal });
-    unreachable();
-  } catch (error) {
     if (isDeno) {
       assertEquals(error, ac.signal.reason);
     } else {
-      const errorValue = error as Error;
-      assertEquals(errorValue.cause, ac.signal.reason);
+      assertEquals(error.cause, ac.signal.reason);
     }
-  }
-});
+  },
+);
+
+Deno.test(
+  "readFile() handles an AbortSignal with a primitive reason value",
+  { ignore: isBun },
+  async () => {
+    const ac = new AbortController();
+    const reasonErr = "Some string";
+    queueMicrotask(() => ac.abort(reasonErr));
+
+    try {
+      await readFile(testFile, { signal: ac.signal });
+      unreachable();
+    } catch (error) {
+      if (isDeno) {
+        assertEquals(error, ac.signal.reason);
+      } else {
+        const errorValue = error as Error;
+        assertEquals(errorValue.cause, ac.signal.reason);
+      }
+    }
+  },
+);
 
 Deno.test("readFile() handles cleanup of an AbortController", async () => {
   const ac = new AbortController();