bun test: drain the event loop for script files with no test() registrations

src/jsc/VirtualMachine.rs

@@ -1059,6 +1059,24 @@
             || !el.next_immediate_tasks.is_empty()
     }
 
+    /// Like [`is_event_loop_alive`] without the `unhandled_error_counter == 0`
+    /// gate: true iff there are ref'd handles or queued tasks keeping the loop
+    /// alive. Used by the test runner to drain a script file after tests finish.
+    pub fn event_loop_has_pending_work(&self) -> bool {
+        let el = self.event_loop_shared();
+        let active = self
+            .platform_loop_opt()
+            .map(|h| h.is_active())
+            .unwrap_or(false);
+        (active as usize)
+            + self.active_tasks
+            + el.tasks.readable_length()
+            + (el.has_pending_refs() as usize)
+            > 0
+            || !el.immediate_tasks.is_empty()
+            || !el.next_immediate_tasks.is_empty()
+    }
+
     pub fn wakeup(&mut self) {
         self.event_loop_mut().wakeup();
     }

src/runtime/cli/test_command.rs

@@ -3233,6 +3233,18 @@
                     }
                 }
 
+                // A file that registered no test()/describe() is a plain script:
+                // drain ref'd handles so late uncaught errors surface, like `bun <file>`.
+                if buntest.collection.root_scope.entries.is_empty() {
+                    let drain_base = vm.unhandled_error_counter;
+                    while drain_base == vm.unhandled_error_counter
+                        && vm.event_loop_has_pending_work()
+                    {
+                        vm.event_loop_ref().tick();
+                        vm.event_loop_ref().auto_tick();
+                    }
+                }
+
                 let el = vm.event_loop();
                 // SAFETY: el is the VM-owned event loop; vm is passed back as *mut.
                 unsafe { (*el).tick_immediate_tasks(vm) };

test/cli/test/bun-test.test.ts

@@ -1458,6 +1458,124 @@ describe("bun test", () => {
   });
 });
 
+// https://github.com/oven-sh/bun/issues/34859
+describe.concurrent("script files with no test() registrations", () => {
+  test("fails on a delayed unhandled rejection from an async IIFE", async () => {
+    using dir = tempDir("script-delayed-rejection", {
+      "delayed.test.js": `
+        'use strict';
+        (async () => {
+          await new Promise(r => setTimeout(r, 20));
+          throw new Error("delayed rejection should fail the test run");
+        })();
+      `,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test", "./delayed.test.js"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toContain("delayed rejection should fail the test run");
+    expect(stderr).toContain("Unhandled error between tests");
+    expect(stderr).toContain("1 error");
+    expect(exitCode).toBe(1);
+  });
+
+  test("fails on a delayed uncaught exception from a timer", async () => {
+    using dir = tempDir("script-delayed-throw", {
+      "delayed.test.js": `setTimeout(() => { throw new Error("boom from timer"); }, 20);`,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test", "./delayed.test.js"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toContain("boom from timer");
+    expect(stderr).toContain("Unhandled error between tests");
+    expect(exitCode).toBe(1);
+  });
+
+  test("waits for ref'd async work to complete", async () => {
+    using dir = tempDir("script-drain", {
+      "drain.test.js": `
+        const assert = require("assert");
+        (async () => {
+          await new Promise(r => setTimeout(r, 20));
+          assert.strictEqual(1, 1);
+          console.log("reached end of async iife");
+        })();
+      `,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test", "./drain.test.js"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stdout).toContain("reached end of async iife");
+    expect(stderr).toContain("0 fail");
+    expect(exitCode).toBe(0);
+  });
+
+  test("drains per file so a later script file's delayed rejection is caught", async () => {
+    using dir = tempDir("script-two-files", {
+      "a.test.js": `
+        (async () => {
+          await Promise.resolve();
+          throw new Error("file A microtask error");
+        })();
+      `,
+      "b.test.js": `
+        (async () => {
+          await new Promise(r => setTimeout(r, 20));
+          throw new Error("file B delayed error");
+        })();
+      `,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test", "./a.test.js", "./b.test.js"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toContain("file A microtask error");
+    expect(stderr).toContain("file B delayed error");
+    expect(exitCode).toBe(1);
+  });
+
+  test("does not drain when the file registered a test()", async () => {
+    // Files that use bun:test keep today's behavior: the runner does not
+    // block on leaked handles after the last test finishes.
+    using dir = tempDir("registered-test-no-drain", {
+      "with.test.js": `
+        const { test } = require("bun:test");
+        setInterval(() => {}, 60_000);
+        test("noop", () => {});
+      `,
+    });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "test", "./with.test.js"],
+      env: bunEnv,
+      cwd: String(dir),
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toContain("1 pass");
+    expect(exitCode).toBe(0);
+  });
+});
+
 function createTest(input?: string | (string | { filename: string; contents: string })[], filename?: string): string {
   const cwd = tmpdirSync();
   const inputs = Array.isArray(input) ? input : [input ?? ""];