Vitest retry feature and file‑system write operations: handling duplicate writes

Short answer

No. As of the Vitest 1.x/2.x public API, there is no hook that runs specifically between retry attempts, no way to restrict a retry to only the assertion portion of a test, and no built-in side-effect isolation. When you set retry: n, Vitest re-executes the entire test function — including any inline setup that writes files — and it also re-runs the surrounding beforeEach/afterEach hooks on every attempt. Cleanup between attempts is your responsibility.

What is confirmed vs. assumed

Confirmed behavior (stable, well-documented): the retry option re-runs the whole test closure per attempt, and beforeEach/afterEach fire per attempt. The retry mechanism has no concept of "setup vs. assertion" — it simply invokes the test function again after a failure.

Likely, but worth verifying against your exact version: hook ordering around retries and how task results are reported differed between the 1.x and 2.x lines, and there is no shipped automatic reset of file-system state, module state, or snapshot caches between attempts. Treat any claim about a future isolation feature as unverified until you check the current changelog and open GitHub discussions for your version.

Practical patterns for this case

Since you cannot skip setup on retries, make the writes safe to repeat:

• Write to unique paths per attempt. Include the attempt index or a random suffix in the filename so retries never collide. Vitest exposes retry context on the test task; a simpler portable option is a module-level counter or expect.getState().currentTestName plus a timestamp.
• Reset in beforeEach. Because hooks run per attempt, deleting the target file or truncating a log in beforeEach gives you an effective "between attempts" cleanup point:

import { beforeEach, it } from 'vitest';
import { rmSync } from 'node:fs';

beforeEach(() => {
  rmSync('out/artifact.log', { force: true });
});

it('flaky writer', { retry: 2 }, () => {
  // writes to out/artifact.log — safe now, each attempt starts clean
});

• Make writes idempotent. Prefer overwrite (writeFileSync) over append (appendFileSync) for anything a retry might repeat. Append-mode logs are the most common source of duplicated CI noise.
• Move one-time setup out of the test. If a snapshot or fixture only needs to exist once, create it in beforeAll (which runs once per file, not per attempt) rather than inside the test body.

Verify the behavior yourself

A two-minute experiment settles it for your installed version: create a test with retry: 2 that appends a line to a file and fails on the first attempt, then count the lines. Also log inside beforeEach to confirm it fires per attempt. If line count equals attempt count, you have confirmed there is no isolation and the patterns above apply.

On a future built-in feature

Community interest in retry isolation exists, but no automatic side-effect reset between attempts is known in core Vitest as of this writing. Check the release notes and the vitest-dev GitHub discussions for your version before designing around an assumed upcoming API.