bun:test: don't block on pending promises in expect().resolves/.rejects

packages/bun-inspector-protocol/test/inspector/websocket.test.ts

@@ -7,69 +7,69 @@ let server: Server;
 let url: URL;
 
 describe("WebSocketInspector", () => {
-  test("fails without a URL", () => {
+  test("fails without a URL", async () => {
     const ws = new WebSocketInspector();
     const fn = mock(error => {
       expect(error).toBeInstanceOf(Error);
     });
     ws.on("Inspector.error", fn);
-    expect(ws.start()).resolves.toBeFalse();
+    await expect(ws.start()).resolves.toBeFalse();
     expect(fn).toHaveBeenCalled();
   });
 
-  test("fails with invalid URL", () => {
+  test("fails with invalid URL", async () => {
     const ws = new WebSocketInspector("notaurl");
     const fn = mock(error => {
       expect(error).toBeInstanceOf(Error);
     });
     ws.on("Inspector.error", fn);
-    expect(ws.start()).resolves.toBeFalse();
+    await expect(ws.start()).resolves.toBeFalse();
     expect(fn).toHaveBeenCalled();
   });
 
-  test("fails with valid URL but no server", () => {
+  test("fails with valid URL but no server", async () => {
     const ws = new WebSocketInspector("ws://localhost:0/doesnotexist/");
     const fn = mock(error => {
       expect(error).toBeInstanceOf(Error);
     });
     ws.on("Inspector.error", fn);
-    expect(ws.start()).resolves.toBeFalse();
+    await expect(ws.start()).resolves.toBeFalse();
     expect(fn).toHaveBeenCalled();
   });
 
-  test("fails with invalid upgrade response", () => {
+  test("fails with invalid upgrade response", async () => {
     const ws = new WebSocketInspector(new URL("/", url));
     const fn = mock(error => {
       expect(error).toBeInstanceOf(Error);
     });
     ws.on("Inspector.error", fn);
-    expect(ws.start()).resolves.toBeFalse();
+    await expect(ws.start()).resolves.toBeFalse();
     expect(fn).toHaveBeenCalled();
   });
 
-  test("can connect to a server", () => {
+  test("can connect to a server", async () => {
     const ws = new WebSocketInspector(url);
     const fn = mock(() => {
       expect(ws.closed).toBe(false);
     });
     ws.on("Inspector.connected", fn);
-    expect(ws.start()).resolves.toBeTrue();
+    await expect(ws.start()).resolves.toBeTrue();
     expect(fn).toHaveBeenCalled();
     ws.close();
   });
 
-  test("can disconnect from a server", () => {
+  test("can disconnect from a server", async () => {
     const ws = new WebSocketInspector(url);
     const fn = mock(() => {
       expect(ws.closed).toBeTrue();
     });
     ws.on("Inspector.disconnected", fn);
-    expect(ws.start()).resolves.toBeTrue();
+    await expect(ws.start()).resolves.toBeTrue();
     ws.close();
     expect(fn).toHaveBeenCalled();
   });
 
-  test("can connect to a server multiple times", () => {
+  test("can connect to a server multiple times", async () => {
     const ws = new WebSocketInspector(url);
     const fn0 = mock(() => {
       expect(ws.closed).toBeFalse();
@@ -80,14 +80,14 @@ describe("WebSocketInspector", () => {
     });
     ws.on("Inspector.disconnected", fn1);
     for (let i = 0; i < 3; i++) {
-      expect(ws.start()).resolves.toBeTrue();
+      await expect(ws.start()).resolves.toBeTrue();
       ws.close();
     }
     expect(fn0).toHaveBeenCalledTimes(3);
     expect(fn1).toHaveBeenCalledTimes(3);
   });
 
-  test("can send a request", () => {
+  test("can send a request", async () => {
     const ws = new WebSocketInspector(url);
     const fn0 = mock(request => {
       expect(request).toStrictEqual({
@@ -108,14 +108,14 @@ describe("WebSocketInspector", () => {
       });
     });
     ws.on("Inspector.response", fn1);
-    expect(ws.start()).resolves.toBeTrue();
-    expect(ws.send("Debugger.setPauseOnAssertions", { enabled: true })).resolves.toMatchObject({ ok: true });
+    await expect(ws.start()).resolves.toBeTrue();
+    await expect(ws.send("Debugger.setPauseOnAssertions", { enabled: true })).resolves.toMatchObject({ ok: true });
     expect(fn0).toHaveBeenCalled();
     expect(fn1).toHaveBeenCalled();
     ws.close();
   });
 
-  test("can send a request before connecting", () => {
+  test("can send a request before connecting", async () => {
     const ws = new WebSocketInspector(url);
     const fn0 = mock(request => {
       expect(request).toStrictEqual({
@@ -136,14 +136,14 @@ describe("WebSocketInspector", () => {
     });
     ws.on("Inspector.response", fn1);
     const request = ws.send("Runtime.enable");
-    expect(ws.start()).resolves.toBe(true);
-    expect(request).resolves.toMatchObject({ ok: true });
+    await expect(ws.start()).resolves.toBe(true);
+    await expect(request).resolves.toMatchObject({ ok: true });
     expect(fn0).toHaveBeenCalledTimes(2);
     expect(fn1).toHaveBeenCalled();
     ws.close();
   });
 
-  test("can receive an event", () => {
+  test("can receive an event", async () => {
     const ws = new WebSocketInspector(url);
     const fn = mock(event => {
       expect(event).toStrictEqual({
@@ -154,8 +154,8 @@ describe("WebSocketInspector", () => {
       });
     });
     ws.on("Inspector.event", fn);
-    expect(ws.start()).resolves.toBeTrue();
-    expect(ws.send("Debugger.enable")).resolves.toMatchObject({ ok: true });
+    await expect(ws.start()).resolves.toBeTrue();
+    await expect(ws.send("Debugger.enable")).resolves.toMatchObject({ ok: true });
     expect(fn).toHaveBeenCalled();
     ws.close();
   });

src/jsc/CallFrame.rs

@@ -259,6 +259,7 @@ impl<const MAX: usize> Arguments<MAX> {
     }
 }
 
+#[derive(Clone, Copy)]
 pub struct CallerSrcLoc {
     pub str: bun_core::String,
     pub line: c_uint,

src/jsc/bindings/ZigGlobalObject.cpp

@@ -3872,6 +3872,10 @@ GlobalObject::PromiseFunctions GlobalObject::promiseHandlerID(Zig::FFIFunction h
         return GlobalObject::PromiseFunctions::Bun__HTTPRequestContextDebugH3__onResolve;
     } else if (handler == Bun__HTTPRequestContextDebugH3__onResolveStream) {
         return GlobalObject::PromiseFunctions::Bun__HTTPRequestContextDebugH3__onResolveStream;
+    } else if (handler == Bun__Expect__PendingMatcher__onResolve) {
+        return GlobalObject::PromiseFunctions::Bun__Expect__PendingMatcher__onResolve;
+    } else if (handler == Bun__Expect__PendingMatcher__onReject) {
+        return GlobalObject::PromiseFunctions::Bun__Expect__PendingMatcher__onReject;
     } else {
         RELEASE_ASSERT_NOT_REACHED();
     }

src/jsc/bindings/ZigGlobalObject.h

@@ -412,8 +412,10 @@ class GlobalObject : public Bun::GlobalScope {
         Bun__HTTPRequestContextDebugH3__onRejectStream,
         Bun__HTTPRequestContextDebugH3__onResolve,
         Bun__HTTPRequestContextDebugH3__onResolveStream,
+        Bun__Expect__PendingMatcher__onResolve,
+        Bun__Expect__PendingMatcher__onReject,
     };
-    static constexpr size_t promiseFunctionsSize = 42;
+    static constexpr size_t promiseFunctionsSize = 44;
 
     static PromiseFunctions promiseHandlerID(SYSV_ABI EncodedJSValue (*handler)(JSC::JSGlobalObject* arg0, JSC::CallFrame* arg1));
 

src/jsc/lib.rs

@@ -1381,7 +1381,7 @@ pub use self::js_object::{ExternColumnIdentifier, ExternColumnIdentifierValue, J
 // ──────────────────────────────────────────────────────────────────────────
 #[path = "CallFrame.rs"]
 pub mod call_frame;
-pub use self::call_frame::{ArgumentsSlice, CallFrame};
+pub use self::call_frame::{ArgumentsSlice, CallFrame, CallerSrcLoc};
 
 /// Lives here (not in `bun_sys_jsc`) because the orphan
 /// rule requires either the trait or the type to be local; `FromJsEnum` is.