Test Bun compatibility in CI

.github/workflows/checks.yml

@@ -146,25 +146,60 @@ jobs:
         env:
           DEBUG: "testcontainers*"
 
-  test:
+  test-docker:
     if: ${{ needs.detect-modules.outputs.modules_count != '0' }}
-    name: Tests
+    name: Tests (Docker)
     needs:
       - detect-modules
       - lint
       - compile
     strategy:
       fail-fast: false
-      max-parallel: 20
       matrix:
         module: ${{ fromJSON(needs.detect-modules.outputs.modules) }}
         node-version: [22.x, 24.x]
-        container-runtime: [docker, podman]
     uses: ./.github/workflows/test-template.yml
     with:
       runner: ubuntu-24.04
       node-version: ${{ matrix.node-version }}
-      container-runtime: ${{ matrix.container-runtime }}
+      container-runtime: docker
+      workspace: "${{ matrix.module }}"
+
+  test-podman:
+    if: ${{ needs.detect-modules.outputs.modules_count != '0' }}
+    name: Tests (Podman)
+    needs:
+      - detect-modules
+      - lint
+      - compile
+    strategy:
+      fail-fast: false
+      matrix:
+        module: ${{ fromJSON(needs.detect-modules.outputs.modules) }}
+        node-version: [22.x, 24.x]
+    uses: ./.github/workflows/test-template.yml
+    with:
+      runner: ubuntu-24.04
+      node-version: ${{ matrix.node-version }}
+      container-runtime: podman
+      workspace: "${{ matrix.module }}"
+
+  test-bun:
+    if: ${{ needs.detect-modules.outputs.modules_count != '0' }}
+    name: Tests (Bun)
+    needs:
+      - detect-modules
+      - lint
+      - compile
+    strategy:
+      fail-fast: false
+      matrix:
+        module: ${{ fromJSON(needs.detect-modules.outputs.modules) }}
+    uses: ./.github/workflows/test-template.yml
+    with:
+      runner: ubuntu-24.04
+      bun-version: canary
+      container-runtime: docker
       workspace: "${{ matrix.module }}"
 
   end:
@@ -175,7 +210,9 @@ jobs:
       - lint
       - compile
       - smoke-test
-      - test
+      - test-docker
+      - test-podman
+      - test-bun
     runs-on: ubuntu-24.04
     steps:
       - name: Check if any jobs failed

.github/workflows/test-template.yml

@@ -5,8 +5,13 @@ on:
         required: true
         type: string
       node-version:
-        required: true
+        required: false
+        type: string
+        default: 24.x
+      bun-version:
+        required: false
         type: string
+        default: ""
       container-runtime:
         required: true
         type: string
@@ -18,6 +23,7 @@ jobs:
   test:
     name: "Run"
     runs-on: ${{ inputs.runner }}
+    timeout-minutes: 20
     steps:
       - name: Code checkout
         uses: actions/checkout@v7
@@ -34,7 +40,26 @@ jobs:
           node-version: ${{ inputs.node-version }}
           workspace: "${{ inputs.workspace }}"
 
-      - name: Run tests
+      - name: Install Bun ${{ inputs.bun-version }}
+        if: ${{ inputs.bun-version != '' }}
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: ${{ inputs.bun-version }}
+
+      - name: Run tests with Node
+        if: ${{ inputs.bun-version == '' }}
         run: npm run test:ci -- --coverage.include="${{ steps.npm-install.outputs.workspace_path }}/**/*.ts" ${{ steps.npm-install.outputs.workspace_path }}
         env:
           CI: true
+
+      # Vitest's V8 coverage provider requires node:inspector coverage APIs that Bun does not support.
+      # https://github.com/oven-sh/bun/issues/4145
+      - name: Run tests with Bun
+        if: ${{ inputs.bun-version != '' }}
+        run: bun run --bun vitest run ${{ steps.npm-install.outputs.workspace_path }}
+        env:
+          CI: true
+          BUN_CI: true
+          # Concurrent Ryuk usage leaves Bun alive after the core suite completes.
+          # https://github.com/oven-sh/bun/issues/23776
+          TESTCONTAINERS_RYUK_DISABLED: ${{ inputs.workspace == 'testcontainers' && 'true' || '' }}

packages/modules/couchbase/src/couchbase-container.test.ts

@@ -10,6 +10,8 @@ const ENTERPRISE_IMAGE = getImage(__dirname, 0);
 const COMMUNITY_IMAGE = getImage(__dirname, 1);
 
 describe("CouchbaseContainer", { timeout: 180_000 }, () => {
+  // https://github.com/oven-sh/bun/issues/12730
+  if (process.env.BUN_CI) return;
   const flushBucketAndCheckExists = async (
     cluster: Cluster,
     bucket: Bucket,

packages/modules/elasticsearch/src/elasticsearch-container.test.ts

@@ -5,7 +5,9 @@ import { ElasticsearchContainer } from "./elasticsearch-container";
 const IMAGE = getImage(__dirname);
 const images = ["elasticsearch:7.17.28", "elasticsearch:8.18.1", IMAGE];
 
+// https://github.com/oven-sh/bun/issues/24824
 describe("ElasticsearchContainer", { timeout: 180_000 }, () => {
+  if (process.env.BUN_CI) return;
   it.each(images)("should create an index with %s", async (image) => {
     // createIndex {
     await using container = await new ElasticsearchContainer(image).start();

packages/modules/k3s/src/k3s-container.test.ts

@@ -9,64 +9,67 @@ const KUBECTL_IMAGE = getImage(__dirname, 1);
 describe("K3sContainer", { timeout: 120_000 }, () => {
   // K3sContainer runs as a privileged container
   if (!process.env["CI_ROOTLESS"]) {
-    it("should start and have listable node", async () => {
-      // k3sListNodes {
-      await using container = await new K3sContainer(IMAGE).start();
+    // https://github.com/oven-sh/bun/issues/7332
+    if (!process.env.BUN_CI)
+      it("should start and have listable node", async () => {
+        // k3sListNodes {
+        await using container = await new K3sContainer(IMAGE).start();
 
-      const kubeConfig = new k8s.KubeConfig();
-      kubeConfig.loadFromString(container.getKubeConfig());
+        const kubeConfig = new k8s.KubeConfig();
+        kubeConfig.loadFromString(container.getKubeConfig());
 
-      const client = kubeConfig.makeApiClient(k8s.CoreV1Api);
-      const nodeList = await client.listNode();
+        const client = kubeConfig.makeApiClient(k8s.CoreV1Api);
+        const nodeList = await client.listNode();
 
-      expect(nodeList.items).toHaveLength(1);
-      // }
-    });
+        expect(nodeList.items).toHaveLength(1);
+        // }
+      });
 
-    it("should start a pod", async () => {
-      // k3sStartPod {
-      await using container = await new K3sContainer(IMAGE).start();
+    if (!process.env.BUN_CI)
+      it("should start a pod", async () => {
+        // k3sStartPod {
+        await using container = await new K3sContainer(IMAGE).start();
 
-      const kubeConfig = new k8s.KubeConfig();
-      kubeConfig.loadFromString(container.getKubeConfig());
+        const kubeConfig = new k8s.KubeConfig();
+        kubeConfig.loadFromString(container.getKubeConfig());
 
-      const pod = {
-        metadata: {
-          name: "helloworld",
-        },
-        spec: {
-          containers: [
-            {
-              name: "helloworld",
-              image: "testcontainers/helloworld:1.1.0",
-              ports: [
-                {
-                  containerPort: 8080,
-                },
-              ],
-              readinessProbe: {
-                tcpSocket: {
-                  port: 8080,
+        const pod = {
+          metadata: {
+            name: "helloworld",
+          },
+          spec: {
+            containers: [
+              {
+                name: "helloworld",
+                image: "testcontainers/helloworld:1.1.0",
+                ports: [
+                  {
+                    containerPort: 8080,
+                  },
+                ],
+                readinessProbe: {
+                  tcpSocket: {
+                    port: 8080,
+                  },
                 },
               },
-            },
-          ],
-        },
-      };
+            ],
+          },
+        };
 
-      const client = kubeConfig.makeApiClient(k8s.CoreV1Api);
-      await client.createNamespacedPod({ namespace: "default", body: pod });
+        const client = kubeConfig.makeApiClient(k8s.CoreV1Api);
+        await client.createNamespacedPod({ namespace: "default", body: pod });
 
-      await vi.waitFor(async () => {
-        const { status } = await client.readNamespacedPodStatus({ namespace: "default", name: "helloworld" });
+        await vi.waitFor(async () => {
+          const { status } = await client.readNamespacedPodStatus({ namespace: "default", name: "helloworld" });
 
-        return (
-          status?.phase === "Running" &&
-          status?.conditions?.some((cond) => cond.type === "Ready" && cond.status === "True")
-        );
-      }, 60_000);
-      // }
-    });
+          return (
+            status?.phase === "Running" &&
+            status?.conditions?.some((cond) => cond.type === "Ready" && cond.status === "True")
+          );
+        }, 60_000);
+        // }
+      });
 
     it("should expose kubeconfig for a network alias", async () => {
       // k3sAliasedKubeConfig {

packages/modules/kafka/src/kafka-container-7.test.ts

@@ -7,6 +7,8 @@ import { assertMessageProducedAndConsumed } from "./test-helper";
 const IMAGE = "confluentinc/cp-kafka:7.9.1";
 
 describe("KafkaContainer", { timeout: 240_000 }, () => {
+  // https://github.com/oven-sh/bun/issues/19337
+  if (process.env.BUN_CI) return;
   it("should connect using in-built zoo-keeper", async () => {
     // connectBuiltInZK {
     await using container = await new KafkaContainer(IMAGE).start();

packages/modules/kafka/src/kafka-container-latest.test.ts

@@ -8,6 +8,8 @@ import { assertMessageProducedAndConsumed } from "./test-helper";
 const IMAGE = getImage(__dirname);
 
 describe("KafkaContainer", { timeout: 240_000 }, () => {
+  // https://github.com/oven-sh/bun/issues/19337
+  if (process.env.BUN_CI) return;
   const certificatesDir = path.resolve(__dirname, "..", "test-certs");
 
   it("should connect", async () => {

packages/modules/kafka/src/test-helper.ts

@@ -1,4 +1,4 @@
-import { GlobalConfig, KafkaJS } from "@confluentinc/kafka-javascript";
+import type { GlobalConfig, KafkaJS } from "@confluentinc/kafka-javascript";
 import { StartedKafkaContainer } from "./kafka-container";
 
 // kafkaTestHelper {
@@ -7,10 +7,12 @@ export async function assertMessageProducedAndConsumed(
   additionalKafkaConfig: Partial<KafkaJS.KafkaConfig> = {},
   additionalGlobalConfig: Partial<GlobalConfig> = {}
 ) {
+  // Static loading crashes Bun before BUN_CI can skip the dependent tests.
+  const { KafkaJS: KafkaJSClient } = await import("@confluentinc/kafka-javascript");
   const brokers = [`${container.getHost()}:${container.getMappedPort(9093)}`];
-  const kafka = new KafkaJS.Kafka({
+  const kafka = new KafkaJSClient.Kafka({
     kafkaJS: {
-      logLevel: KafkaJS.logLevel.ERROR,
+      logLevel: KafkaJSClient.logLevel.ERROR,
       brokers,
       ...additionalKafkaConfig,
     },

packages/modules/mongodb/src/mongodb-atlas-local-container.test.ts

@@ -1,4 +1,3 @@
-import mongoose from "mongoose";
 import { IntervalRetry } from "../../../testcontainers/src/common";
 import { getImage } from "../../../testcontainers/src/utils/test-helper";
 import { MongoDBAtlasLocalContainer } from "./mongodb-atlas-local-container";
@@ -24,6 +23,9 @@ const ATLAS_SEARCH_INDEX = {
 };
 
 describe("MongoDBAtlasLocalContainer", { timeout: 240_000 }, () => {
+  // Static loading uses node:v8 APIs unsupported by Bun before this suite can return.
+  // https://github.com/oven-sh/bun/issues/32501
+  if (process.env.BUN_CI) return;
   it("should provide a connection string", async () => {
     // connectAtlasLocal {
     await using container = await new MongoDBAtlasLocalContainer(IMAGE).start();
@@ -61,7 +63,9 @@ describe("MongoDBAtlasLocalContainer", { timeout: 240_000 }, () => {
   it("should connect to mongodb atlas local", async () => {
     await using container = await new MongoDBAtlasLocalContainer(IMAGE).start();
 
-    const db = mongoose.createConnection(container.getConnectionString(), { directConnection: true });
+    const db = (await import("mongoose")).default.createConnection(container.getConnectionString(), {
+      directConnection: true,
+    });
 
     const obj = { value: 1 };
     const collection = db.collection("test");
@@ -79,7 +83,9 @@ describe("MongoDBAtlasLocalContainer", { timeout: 240_000 }, () => {
       .withPassword("customPassword")
       .start();
 
-    const db = mongoose.createConnection(container.getDatabaseConnectionString(), { directConnection: true });
+    const db = (await import("mongoose")).default.createConnection(container.getDatabaseConnectionString(), {
+      directConnection: true,
+    });
 
     const obj = { value: 1 };
     const collection = db.collection("test");
@@ -95,7 +101,7 @@ describe("MongoDBAtlasLocalContainer", { timeout: 240_000 }, () => {
     // createAtlasIndexAndSearchIt {
     await using atlasLocalContainer = await new MongoDBAtlasLocalContainer(IMAGE).start();
 
-    const db = mongoose.createConnection(atlasLocalContainer.getConnectionString(), {
+    const db = (await import("mongoose")).default.createConnection(atlasLocalContainer.getConnectionString(), {
       dbName: "test",
       directConnection: true,
     });

packages/modules/mongodb/src/mongodb-container.test.ts

@@ -1,15 +1,19 @@
-import mongoose from "mongoose";
 import { getImage } from "../../../testcontainers/src/utils/test-helper";
 import { MongoDBContainer } from "./mongodb-container";
 
 const IMAGE = getImage(__dirname);
 
 describe("MongoDBContainer", { timeout: 240_000 }, () => {
+  // Static loading uses node:v8 APIs unsupported by Bun before this suite can return.
+  // https://github.com/oven-sh/bun/issues/32501
+  if (process.env.BUN_CI) return;
   it.each([IMAGE, "mongo:6.0.25", "mongo:4.4.29"])("should work with %s", async (image) => {
     // connectMongo {
     await using container = await new MongoDBContainer(image).start();
 
-    const db = mongoose.createConnection(container.getConnectionString(), { directConnection: true });
+    const db = (await import("mongoose")).default.createConnection(container.getConnectionString(), {
+      directConnection: true,
+    });
 
     const obj = { value: 1 };
     const collection = db.collection("test");
@@ -30,7 +34,9 @@ describe("MongoDBContainer", { timeout: 240_000 }, () => {
       .start();
     // }
 
-    const db = mongoose.createConnection(container.getConnectionString(), { directConnection: true });
+    const db = (await import("mongoose")).default.createConnection(container.getConnectionString(), {
+      directConnection: true,
+    });
 
     const result = await db.collection("test").insertOne({ title: "test" });
     const resultId = result.insertedId.toString();