test: allow onTestFinished() and expect.assertions() in concurrent tests

docs/test/lifecycle.mdx

@@ -106,7 +106,7 @@ test("cleanup after test", () => {
 });
 ```
 
-Not supported in concurrent tests; use `test.serial` instead.
+Works inside concurrent tests — each call is attached to the specific concurrent test whose body is currently executing.
 
 ## Global Setup and Teardown
 

packages/bun-types/test.d.ts

@@ -378,7 +378,9 @@
    * This is useful for cleanup tasks that need to run at the very end of a test,
    * after all other hooks have completed.
    *
-   * Can only be called inside a test, not in describe blocks.
+   * Can only be called inside a test, not in describe blocks. Works inside
+   * concurrent tests — each call is attached to the specific concurrent test
+   * whose body is currently executing.
    *
    * @example
    * test("my test", () => {

src/bun.js/test/Execution.zig

@@ -397,6 +397,16 @@ fn stepSequenceOne(buntest_strong: bun_test.BunTestPtr, globalThis: *jsc.JSGloba
         };
         groupLog.log("runSequence queued callback: {f}", .{callback_data});
 
+        // Mark this sequence/entry as the synchronously-executing callback
+        // so that hooks called from user code (onTestFinished,
+        // expect.assertions) can look up which concurrent sequence they
+        // belong to. Any awaited microtasks that are drained by
+        // `runCallbackWithResultAndForcefullyDrainMicrotasks` also see this
+        // context. The context is popped once the JS call returns, even if
+        // the returned promise is still pending.
+        buntest.pushCurrentCallback(callback_data);
+        defer buntest.popCurrentCallback();
+
         if (BunTest.runTestCallback(buntest_strong, globalThis, cb.get(), next_item.has_done_parameter, callback_data, &next_item.timespec) != null) {
             now.* = bun.timespec.now(.force_real_time);
             _ = next_item.evaluateTimeout(sequence, now);

src/bun.js/test/bun_test.zig

@@ -219,6 +219,15 @@ pub const BunTest = struct {
     first_last: BunTestRoot.FirstLast,
     extra_execution_entries: std.array_list.Managed(*ExecutionEntry),
     wants_wakeup: bool = false,
+    /// Stack of concurrent-sequence contexts whose JS callback is currently
+    /// being executed synchronously. Pushed by `Execution.stepSequenceOne`
+    /// before invoking `runTestCallback` and popped after it returns.
+    ///
+    /// During synchronous JS execution (including drained microtasks), the
+    /// top of this stack tells `getCurrentStateData` which concurrent
+    /// sequence the calling code belongs to, so hooks like `onTestFinished`
+    /// and `expect.assertions` resolve to the correct test.
+    current_callback_stack: std.array_list.Managed(RefDataValue),
 
     phase: enum {
         collection,
@@ -253,6 +262,7 @@ pub const BunTest = struct {
             .default_concurrent = default_concurrent,
             .first_last = first_last,
             .extra_execution_entries = .init(this.gpa),
+            .current_callback_stack = .init(this.gpa),
         };
     }
     pub fn deinit(this: *BunTest) void {
@@ -268,6 +278,7 @@ pub const BunTest = struct {
             entry.destroy(this.gpa);
         }
         this.extra_execution_entries.deinit();
+        this.current_callback_stack.deinit();
 
         this.execution.deinit();
         this.collection.deinit();
@@ -350,6 +361,16 @@ pub const BunTest = struct {
         return switch (this.phase) {
             .collection => .{ .collection = .{ .active_scope = this.collection.active_scope } },
             .execution => blk: {
+                // If a JS callback is currently executing synchronously (including
+                // during drained microtasks), the innermost push on
+                // `current_callback_stack` tells us exactly which sequence/entry
+                // we're inside. This disambiguates the concurrent case, where
+                // multiple sequences may be in-flight at the same time.
+                if (this.current_callback_stack.items.len > 0) {
+                    const top = this.current_callback_stack.items[this.current_callback_stack.items.len - 1];
+                    if (top == .execution) break :blk top;
+                }
+
                 const active_group = this.execution.activeGroup() orelse {
                     bun.debugAssert(false); // should have switched phase if we're calling getCurrentStateData, but it could happen with re-entry maybe
                     break :blk .{ .done = .{} };
@@ -384,6 +405,25 @@ pub const BunTest = struct {
             .done => .{ .done = .{} },
         };
     }
+
+    /// Push an entry onto the callback-execution stack. Must be paired with
+    /// `popCurrentCallback`. Call this immediately before invoking user JS
+    /// from a concurrent-safe context so nested hooks (`onTestFinished`,
+    /// `expect.assertions`) can recover which sequence they belong to.
+    pub fn pushCurrentCallback(this: *BunTest, data: RefDataValue) void {
+        bun.handleOom(this.current_callback_stack.append(data));
+    }
+
+    /// Pop the innermost callback-execution entry. Cheaply tolerates an
+    /// out-of-order pop during teardown — the only correct caller is the
+    /// defer that paired a preceding `pushCurrentCallback`.
+    pub fn popCurrentCallback(this: *BunTest) void {
+        if (this.current_callback_stack.items.len == 0) {
+            bun.debugAssert(false);
+            return;
+        }
+        _ = this.current_callback_stack.pop();
+    }
     pub fn ref(this_strong: BunTestPtr, phase: RefDataValue) *RefData {
         group.begin(@src());
         defer group.end();

test/js/bun/test/bun_test.fixture.ts

@@ -137,12 +137,14 @@ test.failing("expect.assertions", () => {
   expect.hasAssertions(); // make sure this doesn't overwrite the assertions count, matching existing behaviour
 });
 
-test.concurrent.failing("expect.assertions not yet supported in concurrent tests", () => {
-  expect.hasAssertions(); // this call will fail because expect.hasAssertions is not yet supported in concurrent tests
+// https://github.com/oven-sh/bun/issues/29236 — expect.hasAssertions and
+// expect.assertions resolve to the currently executing concurrent test.
+test.concurrent("expect.hasAssertions works in concurrent tests", () => {
+  expect.hasAssertions();
   expect(true).toBe(true);
 });
-test.concurrent.failing("expect.assertions not yet supported in concurrent tests", () => {
-  expect.assertions(1); // this call will fail because expect.assertions is not yet supported in concurrent tests
+test.concurrent("expect.assertions works in concurrent tests", () => {
+  expect.assertions(1);
   expect(true).toBe(true);
 });
 

test/js/bun/test/bun_test.test.ts

@@ -63,8 +63,8 @@ test("describe/test", async () => {
     (pass) addition 3 + 4 = 7
     AssertionError: expected 1 assertion, but test ended with 0 assertions
     (fail) expect.assertions
-    (pass) expect.assertions not yet supported in concurrent tests
-    (pass) expect.assertions not yet supported in concurrent tests
+    (pass) expect.hasAssertions works in concurrent tests
+    (pass) expect.assertions works in concurrent tests
     (pass) expect.assertions works
     (fail) expect.assertions combined with timeout
       ^ this test timed out after 1ms.

test/js/bun/test/test-on-test-finished.test.ts

@@ -68,26 +68,32 @@
   });
 });
 
-// Test that onTestFinished throws proper error in concurrent tests
-describe("onTestFinished errors", () => {
-  test.concurrent("cannot be called in concurrent test 1", () => {
-    expect(() => {
-      onTestFinished(() => {
-        console.log("should not run");
-      });
-    }).toThrow(
-      "Cannot call onTestFinished() here. It cannot be called inside a concurrent test. Use test.serial or remove test.concurrent.",
-    );
-  });
-
-  test.concurrent("cannot be called in concurrent test 2", () => {
-    expect(() => {
-      onTestFinished(() => {
-        console.log("should not run");
-      });
-    }).toThrow(
-      "Cannot call onTestFinished() here. It cannot be called inside a concurrent test. Use test.serial or remove test.concurrent.",
-    );
+// https://github.com/oven-sh/bun/issues/29236 — onTestFinished() is
+// callable from inside a concurrent test. Each sequence accumulates its
+// own hooks and runs them at the end of that sequence.
+describe("onTestFinished in concurrent tests", () => {
+  const a_output: string[] = [];
+  const b_output: string[] = [];
+
+  test.concurrent("test a", async () => {
+    onTestFinished(() => {
+      a_output.push("a-finished");
+    });
+    await new Promise(resolve => setTimeout(resolve, 5));
+    a_output.push("a-body");
+  });
+
+  test.concurrent("test b", async () => {
+    onTestFinished(() => {
+      b_output.push("b-finished");
+    });
+    await new Promise(resolve => setTimeout(resolve, 5));
+    b_output.push("b-body");
+  });
+
+  test("verify each sequence ran its own hook", () => {
+    expect(a_output).toEqual(["a-body", "a-finished"]);
+    expect(b_output).toEqual(["b-body", "b-finished"]);
   });
 });
 

test/regression/issue/29236.test.ts

@@ -0,0 +1,94 @@
+// https://github.com/oven-sh/bun/issues/29236
+//
+// onTestFinished() must be usable from inside a concurrent test, just like
+// a plain try/finally cleanup block is. Before the fix, any onTestFinished()
+// call from a concurrent test threw:
+//
+//   Cannot call onTestFinished() here. It cannot be called inside a
+//   concurrent test. Use test.serial or remove test.concurrent.
+//
+// because the hook lookup couldn't resolve which sequence owned the call
+// when more than one concurrent sequence was active.
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+
+test("onTestFinished works inside concurrent tests", async () => {
+  using dir = tempDir("issue-29236-on-test-finished-concurrent", {
+    "concurrent.test.ts": /* ts */ `
+      import { expect, onTestFinished, test } from "bun:test";
+
+      const runs: string[] = [];
+
+      test.concurrent("a", async () => {
+        onTestFinished(() => { runs.push("a-finished"); });
+        await new Promise<void>(r => setTimeout(r, 10));
+        expect(1).toBe(1);
+      });
+
+      test.concurrent("b", async () => {
+        onTestFinished(() => { runs.push("b-finished"); });
+        await new Promise<void>(r => setTimeout(r, 10));
+        expect(1).toBe(1);
+      });
+
+      test.concurrent("c", async () => {
+        onTestFinished(() => { runs.push("c-finished"); });
+        await new Promise<void>(r => setTimeout(r, 10));
+        expect(1).toBe(1);
+      });
+
+      test("report", () => {
+        runs.sort();
+        expect(runs).toEqual(["a-finished", "b-finished", "c-finished"]);
+      });
+    `,
+  });
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "test", "concurrent.test.ts"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const output = stdout + stderr;
+  expect(output).not.toContain("Cannot call onTestFinished");
+  expect(output).toContain("4 pass");
+  expect(output).toContain("0 fail");
+  expect(exitCode).toBe(0);
+});
+
+test("onTestFinished works inside concurrent tests via --concurrent flag", async () => {
+  using dir = tempDir("issue-29236-on-test-finished-cli", {
+    "plain.test.ts": /* ts */ `
+      import { expect, onTestFinished, test } from "bun:test";
+
+      test("one", async () => {
+        onTestFinished(() => {});
+        await new Promise<void>(r => setTimeout(r, 5));
+        expect(1).toBe(1);
+      });
+
+      test("two", async () => {
+        onTestFinished(() => {});
+        await new Promise<void>(r => setTimeout(r, 5));
+        expect(1).toBe(1);
+      });
+    `,
+  });
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "test", "--concurrent", "plain.test.ts"],
+    env: bunEnv,
+    cwd: String(dir),
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const output = stdout + stderr;
+  expect(output).not.toContain("Cannot call onTestFinished");
+  expect(output).toContain("2 pass");
+  expect(output).toContain("0 fail");
+  expect(exitCode).toBe(0);
+});