bun test: Infinity means no timeout in test(), hooks, setDefaultTimeout() and jest.setTimeout()

docs/test/runtime-behavior.mdx

@@ -124,6 +124,8 @@ test("test without timeout", async () => {
 }, 0);
 ```
 
+A timeout of 4294967295 ms (about 49.7 days) or more also disables it. A test without a timeout still fails when nothing left on the event loop could settle it. See [Unsettled Top-Level Await](#unsettled-top-level-await).
+
 ## Timers
 
 Like Node.js, Bun makes a `setTimeout()` delay under 1 ms wait for 1 ms. In `bun test` it doesn't wait: when the event loop has nothing else to do, `setTimeout(callback, 0)` runs at once. Messages and immediates that are already queued run first, and so does a timer that was due before it, as in Node.js. Testing Library and user-event await such a timer after every step, so in a test that clicks and types those milliseconds add up.
@@ -190,7 +192,7 @@ note: the event loop is empty, so nothing can settle it anymore
 note: unsettled top-level await in "/path/to/test.ts"
 ```
 
-The same applies to `--preload` scripts, async `describe()` callbacks, and tests or hooks with a timeout of `0`. An open timer, socket, subprocess or worker counts as something that could still settle the promise, even after `.unref()`.
+The same applies to `--preload` scripts, async `describe()` callbacks, and tests or hooks with a timeout of `0` or `Infinity`. An open timer, socket, subprocess or worker counts as something that could still settle the promise, even after `.unref()`. A listener for a signal doesn't count. If a test waits for a signal from another process, keep a timer open until the signal arrives, or give the test a timeout.
 
 ### Custom Error Handling
 

packages/bun-types/test.d.ts

@@ -903,7 +903,7 @@ declare module "bun:test" {
    * ```
    *
    * @param fn the function to run around each test
-   * @param options the timeout in milliseconds. 0 means no timeout
+   * @param options the timeout in milliseconds. `0` and `Infinity` mean no timeout
    */
   export function aroundEach(
     fn: (runTest: () => Promise<void>, context: TestContext, suite: TestSuite) => unknown | Promise<unknown>,
@@ -926,7 +926,7 @@ declare module "bun:test" {
    * ```
    *
    * @param fn the function to run around the tests
-   * @param options the timeout in milliseconds. 0 means no timeout
+   * @param options the timeout in milliseconds. `0` and `Infinity` mean no timeout
    */
   export function aroundAll(
     fn: (runSuite: () => Promise<void>, context: object, suite: TestSuite) => unknown | Promise<unknown>,
@@ -957,12 +957,13 @@ declare module "bun:test" {
    * Sets the default timeout for all tests in the current file. A timeout set on an
    * individual test overrides this value. The default timeout is 5000ms (5 seconds).
    *
-   * @param milliseconds the default timeout in milliseconds
+   * @param milliseconds the default timeout in milliseconds. `0` and `Infinity` mean no timeout
    */
   export function setDefaultTimeout(milliseconds: number): void;
   export interface TestOptions {
     /**
-     * Sets the timeout for the test in milliseconds.
+     * Sets the timeout for the test in milliseconds. `0` and `Infinity` mean no timeout: the test then fails only
+     * when nothing left on the event loop could settle it.
      *
      * If the test does not complete within this time, it fails with:
      * ```ts

src/js/node/test.ts

@@ -2539,8 +2539,8 @@ function bunTestOptions(options: TestOptions) {
   // about timeouts that extend past its 5s default.
   const { timeout } = options;
   if (timeout === Infinity) {
-    // Node's "no timeout" must override bun:test's default (bun saturates it).
-    return { timeout };
+    // Node waits without end. bun:test gets the longest timeout, because it fails a stuck test that has none.
+    return { timeout: kTimeoutMax };
   }
   if (typeof timeout === "number" && Number.isFinite(timeout)) {
     // Keep bun:test's watchdog at or above both the node-style timeout and

src/runtime/cli/test_command.rs

@@ -749,6 +749,7 @@ if (name === \"\\0never\") (globalThis as any)[name] = require(name);
 // usage (`bun_test::Execution::Result`, `bun_test::BasicResult`, …) without a
 // 2k-line body rewrite.
 use crate::test_runner::environment::Environment;
+use crate::test_runner::expect::expect_deferred::ExpectDeferred;
 use crate::test_runner::jest::{self, FileColumns as _, Summary, TestRunner};
 use crate::test_runner::snapshot::Snapshots;
 use bun_collections::index_sort;
@@ -4113,11 +4114,21 @@ impl TestCommand {
                     if buntest.timer.state != crate::timer::EventLoopTimerState::ACTIVE
                         && !vm.has_work_left()
                     {
+                        // The matchers are reported where they were called, and the file goes on.
+                        if ExpectDeferred::group_never_settles(&buntest_strong, global) {
+                            continue;
+                        }
                         let (what, waits_for) = Self::what_runner_waits_for(buntest);
                         let p = jsc::JSPromise::opaque_mut(Self::never_settled(
                             global, what, file_path,
                         ));
-                        vm.unhandled_rejection(global, p.result(global.vm()), p.to_js());
+                        // The runner's own error: a `process` listener of a Vitest test doesn't get to take it.
+                        vm.unhandled_error_counter += 1;
+                        jest::on_unhandled_rejection::on_unhandled_rejection(
+                            vm,
+                            global,
+                            p.result(global.vm()),
+                        );
                         vm.event_loop_ref().tick();
                         // The error ends a describe() or a test. Anything else stays stuck, so abandon the file.
                         if waits_for.is_none()

src/runtime/test_runner/Execution.rs

@@ -110,6 +110,8 @@ pub(crate) struct ConcurrentGroup {
     pub(crate) failure_skip_to: usize,
     /// Like `ExecutionSequence::pending_matchers`, for matchers whose calling sequence isn't known.
     pub(crate) pending_matchers: u32,
+    /// A test with no timeout was running when one of `pending_matchers` was called, so they have no deadline.
+    pub(crate) pending_matchers_have_no_deadline: bool,
 }
 
 impl ConcurrentGroup {
@@ -122,6 +124,7 @@ impl ConcurrentGroup {
             failure_skip_to: next_index,
             next_sequence_index: 0,
             pending_matchers: 0,
+            pending_matchers_have_no_deadline: false,
         }
     }
 
@@ -217,6 +220,14 @@ impl ExecutionSequence {
         self.callback_done
     }
 
+    /// The callback of its test has started, and the test has not ended.
+    pub(crate) fn runs_test_with_no_timeout(&self) -> bool {
+        self.executing
+            && self.active_entry == self.test_entry
+            // SAFETY: arena-owned entry, alive for the lifetime of BunTest which owns Execution
+            && self.test_entry.is_some_and(|entry| unsafe { entry.as_ref() }.timeout == 0)
+    }
+
     fn entry_mode(&self) -> ScopeMode {
         if let Some(entry) = self.test_entry {
             // SAFETY: arena-owned entry, alive for the lifetime of BunTest which owns Execution
@@ -453,7 +464,10 @@ impl Execution {
                     // SAFETY: arena-owned entry, alive for lifetime of BunTest
                     let entry = unsafe { entry.as_ref() };
                     let now = Timespec::now_force_real_time();
-                    if entry.timespec.order(&now) == core::cmp::Ordering::Less {
+                    // A stale file timer can fire while an unlimited entry is active.
+                    if !entry.timespec.eql(&Timespec::EPOCH)
+                        && entry.timespec.order(&now) == core::cmp::Ordering::Less
+                    {
                         // SAFETY: bun_vm() returns the live per-thread VM.
                         let kill_count = global_this.bun_vm().as_mut().auto_killer.kill();
                         if kill_count.processes > 0 {
@@ -1028,12 +1042,16 @@ fn step_group(
         let group = unsafe { &mut *group_ptr.as_ptr() };
         if group.pending_matchers > 0 {
             // Any test in the group may have called them, so wait until the latest test deadline.
-            let timeout = this.sequences[group.sequence_start..group.sequence_end]
-                .iter()
-                .filter_map(|sequence| sequence.test_entry)
-                // SAFETY: arena-owned entry
-                .map(|entry| unsafe { entry.as_ref() }.timespec)
-                .fold(Timespec::EPOCH, |latest, timespec| if timespec.order(&latest).is_gt() { timespec } else { latest });
+            let timeout = if group.pending_matchers_have_no_deadline {
+                Timespec::EPOCH
+            } else {
+                this.sequences[group.sequence_start..group.sequence_end]
+                    .iter()
+                    .filter_map(|sequence| sequence.test_entry)
+                    // SAFETY: arena-owned entry
+                    .map(|entry| unsafe { entry.as_ref() }.timespec)
+                    .fold(Timespec::EPOCH, |latest, timespec| if timespec.order(&latest).is_gt() { timespec } else { latest })
+            };
             if timeout.eql(&Timespec::EPOCH) || timeout.order(now).is_gt() {
                 return Ok(StepResult::Waiting { timeout });
             }

src/runtime/test_runner/ScopeFunctions.rs

@@ -1019,7 +1019,7 @@ pub(crate) fn parse_arguments<'a>(
         }
     };
 
-    let timeout_option_ms: Option<u32> = timeout_option.map(|timeout| timeout as u32);
+    let timeout_option_ms: Option<u32> = timeout_option.map(bun_test::timeout_ms);
     result.options.inherited = InheritedOptions {
         timeout: timeout_option_ms.or(cfg.inherited.timeout),
         retry: result.options.retry.or(cfg.inherited.retry),

src/runtime/test_runner/bun_test.rs

@@ -2333,6 +2333,15 @@ pub(crate) enum HookTag {
     AroundAll,
 }
 
+/// Like Vitest's timeouts, anything that isn't a positive finite number becomes 0, which means none.
+pub(crate) fn timeout_ms(number: f64) -> u32 {
+    if number > 0.0 && number < f64::from(u32::MAX) {
+        (number as u32).max(1)
+    } else {
+        0
+    }
+}
+
 #[derive(Copy, Clone, Default)]
 pub(crate) struct ExecutionEntryCfg {
     /// 0 = unlimited timeout

src/runtime/test_runner/expect_deferred.rs

@@ -8,6 +8,7 @@ use core::ptr::NonNull;
 use bun_core::{Timespec, TimespecMockMode};
 use bun_jsc::bindgen::{JsLocal, JsScope, JsWrapper};
 use bun_jsc::call_frame::CallerSrcLoc;
+use bun_jsc::event_loop::TopLevelWaitError;
 use bun_jsc::js_promise::{Status, UnwrapMode, Unwrapped};
 use bun_jsc::{
     AnyPromise, JSFunction, JSGlobalObject, JSHostFn, JSPromise, JSValue, JsCell,
@@ -190,6 +191,14 @@ impl RunningEntry {
             .is_some_and(|buntest| self.pending_matchers(&buntest).is_some())
     }
 
+    /// The concurrent group that holds the call, when no sequence of it does.
+    fn group_index(&self) -> Option<usize> {
+        match self.entry {
+            RefDataValue::Execution { group_index, entry_data: None } => Some(group_index),
+            _ => None,
+        }
+    }
+
     /// Checks the clock directly, because the runner only notices a timeout after the microtask queue drains.
     fn has_timed_out(&self) -> bool {
         let Some(buntest) = self.buntest.upgrade() else {
@@ -215,6 +224,13 @@ impl RunningEntry {
             // SAFETY: as in `pending_matchers`.
             unsafe { *pending_matchers.as_ptr() += 1 };
             self.unclaimed = Some(buntest.get().unclaimed.add(global, deferred));
+            if let Some(group_index) = self.group_index() {
+                let execution = &mut buntest.get().execution;
+                let sequences = execution.groups[group_index].sequences(execution);
+                // Such a test may be the caller, and the deadline of another test must not end its wait.
+                let may_have_no_timeout = sequences.iter().any(ExecutionSequence::runs_test_with_no_timeout);
+                execution.groups[group_index].pending_matchers_have_no_deadline |= may_have_no_timeout;
+            }
         }
         self
     }
@@ -243,6 +259,9 @@ impl RunningEntry {
             *pending_matchers.as_ptr() -= 1;
             *pending_matchers.as_ptr() == 0
         };
+        if let (true, Some(group_index)) = (none_left, self.group_index()) {
+            buntest.get().execution.groups[group_index].pending_matchers_have_no_deadline = false;
+        }
         let next = match self.sequence(&buntest) {
             Some(sequence) => {
                 // SAFETY: as in `pending_matchers`.
@@ -835,6 +854,33 @@ impl ExpectDeferred {
         );
     }
 
+    /// With nothing left on the event loop, gives up the calls that are all the active group still waits for, if any.
+    pub(crate) fn group_never_settles(buntest: &BunTestPtr, global: &JSGlobalObject) -> bool {
+        let this = buntest.get();
+        if this.phase != Phase::Execution {
+            return false;
+        }
+        let group_index = this.execution.group_index;
+        let Some(group) = this.execution.groups.get_mut(group_index) else {
+            return false;
+        };
+        if group.remaining_incomplete_entries > 0 || group.pending_matchers == 0 {
+            return false;
+        }
+        group.pending_matchers = 0;
+        Self::give_up(
+            buntest,
+            global,
+            Some(group_index),
+            format_args!(
+                "An un-awaited matcher in a concurrent test never settled\nnote: {}",
+                TopLevelWaitError::NothingLeft
+            ),
+        );
+        buntest.get().add_result(RefDataValue::Start);
+        true
+    }
+
     /// After a file's tests have run, keeps the file open until the calls it holds finish or time out.
     pub(crate) fn step_file_end(
         buntest: &BunTestPtr,

src/runtime/test_runner/jest.rs

@@ -172,10 +172,15 @@ impl<'a> TestRunner<'a> {
             if let Some(group) = active_file.execution.active_group_ref() {
                 let mut latest: Option<bun_core::Timespec> = None;
                 for seq in group.sequences_const(&active_file.execution) {
+                    // Not started yet: its `EPOCH` is "not set", not "no timeout".
+                    if !seq.executing {
+                        continue;
+                    }
                     let Some(entry) = seq.active_entry else { continue };
                     // SAFETY: arena-owned entry, alive for the lifetime of BunTest.
                     let ts = unsafe { entry.as_ref() }.timespec;
-                    if latest.is_none_or(|l| ts.order(&l) == core::cmp::Ordering::Greater) {
+                    // A running entry with no timeout (`EPOCH`) is the latest of all.
+                    if latest.is_none_or(|l| bun_core::Timespec::order_ignore_epoch(ts, l).is_gt()) {
                         latest = Some(ts);
                     }
                 }
@@ -613,10 +618,9 @@ pub(crate) fn asked_by_compiled_test_file(own_globals: bool) -> u32 {
 
 /// `setDefaultTimeout(milliseconds)` and `jest.setTimeout(milliseconds)`
 pub(crate) fn set_default_timeout(milliseconds: f64) {
-    let timeout_ms: u32 = u32::try_from((milliseconds as i32).max(0)).unwrap();
-
     if let Some(test_runner) = Jest::runner() {
-        test_runner.default_timeout_override = timeout_ms;
+        // Never `u32::MAX`, which means that no override is set.
+        test_runner.default_timeout_override = bun_test::timeout_ms(milliseconds);
     }
 }
 

src/runtime/test_runner/vi_utils.rs

@@ -2,6 +2,7 @@ use bun_jsc::bindgen::{JsLocal, JsScope};
 use bun_jsc::{JSFunction, JSGlobalObject, JSHostFn, JSValue, JsResult};
 use bun_options_types::context::RESETS_BEFORE_EACH_TEST;
 
+use super::bun_test;
 use super::jest::Jest;
 use crate::generated_bindgen::vi_utils as generated;
 
@@ -84,7 +85,7 @@ pub(crate) fn on_test_file_end(global: &JSGlobalObject, next_load_shares_global:
     ViUtils__forgetDynamicImports(global);
 }
 
-/// Like Vitest's timeouts, anything that isn't a positive finite number becomes 0, which means none.
+/// `maxConcurrency` is stored like a timeout: 0 means none.
 fn number_option(
     global: &JSGlobalObject,
     config: JSValue,
@@ -100,12 +101,7 @@ fn number_option(
             value,
         ));
     }
-    let number = value.as_number();
-    Ok(Some(if number > 0.0 && number < f64::from(u32::MAX) {
-        (number as u32).max(1)
-    } else {
-        0
-    }))
+    Ok(Some(bun_test::timeout_ms(value.as_number())))
 }
 
 /// Config set by a preload applies to every test file, like config set by a Vitest setup file.