bun test: Vitest compatibility

.prettierignore

@@ -1,5 +1,7 @@
 vendor
 test/snapshots
+# written by Jest and Vitest, and compared byte for byte
+test/js/bun/test/snapshot-tests/formats
 test/bundler/transpiler/react-compiler-fixtures
 src/**/*.generated.rs
 test/js/deno

docs/bundler/css.mdx

@@ -882,6 +882,8 @@ This outputs:
 
 The class names are unique to each file, so they don't collide.
 
+Importing a CSS module at runtime (`bun run`, `bun test`) gives you the same object. Server-rendered markup and component tests see the same class names the bundler emits, as long as both run from the same working directory.
+
 ### Composition
 
 CSS modules can compose class selectors together to reuse style rules across multiple classes.

docs/guides/test/migrate-from-jest.mdx

@@ -64,13 +64,15 @@ Bun implements most of Jest's matchers, but compatibility isn't 100%. See the co
 
 ---
 
-If you use `testEnvironment: "jsdom"` to run your tests in a browser-like environment, follow the [DOM testing with Bun and happy-dom](/guides/test/happy-dom) guide to inject browser APIs into the global scope. That guide uses [`happy-dom`](https://github.com/capricorn86/happy-dom), a leaner and faster alternative to [`jsdom`](https://github.com/jsdom/jsdom).
+Replace `testEnvironment: "jsdom"` in your Jest config with `environment` in `bunfig.toml`, and install `jsdom` itself (`bun add -d jsdom`). [`happy-dom`](https://github.com/capricorn86/happy-dom) is a leaner and faster alternative.
 
 ```toml bunfig.toml icon="settings"
 [test]
-preload = ["./happydom.ts"]
+environment = "jsdom"
 ```
 
+`@jest-environment jsdom` and `@jest-environment node` comments in test files work as-is. If a comment uses a name Bun doesn't support, such as `jest-environment-jsdom`, Bun prints a warning and runs the file without a DOM. Change it to `jsdom` or `node`. See [DOM testing](/test/dom#test-environments).
+
 ---
 
 Replace `bail` in your Jest config with the `--bail` CLI flag.

docs/project/benchmarking.mdx

@@ -250,6 +250,7 @@ BUN_OPTIONS="--cpu-prof-md" bun script.js
 ```sh terminal icon="terminal"
 bun --cpu-prof --cpu-prof-name my-profile.cpuprofile script.js
 bun --cpu-prof --cpu-prof-dir ./profiles script.js
+bun test --cpu-prof --cpu-prof-dir ./profiles # with --parallel, one profile for each worker
 ```
 
 | Flag                         | Description                                                 |

docs/project/bindgen.mdx

@@ -653,6 +653,7 @@ is collected, make the class [`refCounted`](#refcounted).
 | `final`          | `false` lets a class with `extends`, or hand-written C++, subclass `JSName`                    |
 | `overridesToJS`  | with `refCounted`: `impl JsClass` is not generated; write it by hand with `js_Name::to_js`     |
 | `forBind`        | the receiver of every member is [a function bound to an instance](#forbind)                    |
+| `protoCaller`    | the method that [calls every native function of `proto`](#protocaller)                         |
 | `rustTraits`     | traits to bring into scope, for members that are trait methods                                 |
 | `prototypeBase`  | `"Error"`: the prototype inherits from `Error.prototype`, and its `name` is the class's        |
 | `configurable`   | `true` makes the native properties configurable                                                |
@@ -662,6 +663,7 @@ is collected, make the class [`refCounted`](#refcounted).
 | `estimatedSize`  | [`fn estimated_size(&self) -> usize`](#memory), for the GC                                     |
 | `construct`      | `new Name(..)`. Without it JavaScript cannot make one; Rust can, with `payload.into_js(heap)`. |
 | `call`           | `Name(..)` without `new`, which otherwise throws. It is `fn call(..)`, with no receiver.       |
+| `callInstance`   | `instance(..)`. It is `fn call_instance(&self, ..)`, and `typeof instance` is `"function"`.    |
 | `internalFields` | JS values the object holds                                                                     |
 | `proto`          | properties of the prototype                                                                    |
 | `static`         | properties of the constructor: native functions and accessors without `cache`                  |
@@ -950,6 +952,28 @@ When the size grows, the member that grew it calls `heap.report_extra_memory(thi
 instance, with the class's prototype as its prototype. With `forBind: true`, members are called with
 that function as `this`, and `&self` is its `boundThis`. The prototype inherits from `Function.prototype`.
 
+### `protoCaller`
+
+Every `expect()` matcher needs the same work done before and after it. With `protoCaller: "call_matcher"`, calling a
+native function of `proto` calls `call_matcher` instead, which receives a pointer to the function:
+
+```rust
+pub(crate) fn call_matcher<'a>(
+    &self,
+    this_value: JsWrapper<'a, Self>,
+    cx: &mut JsScope<'a>,
+    callee: JsLocal<'a>,
+    arguments: &'a [JsLocal<'a>],
+    matcher: fn(JsWrapper<'a, Self>, &mut JsScope<'a>, &'a [JsLocal<'a>]) -> JsResult<JSValue>,
+) -> JsResult<JSValue> {
+    matcher(this_value, cx, arguments)
+}
+```
+
+`callee` is the JS function that was called, and `arguments` is everything it was called with. The function takes its
+own arguments out of that list, so they're all `b.any`, the last one possibly `.variadic`. It also needs
+`capability: "js"`, `throws: true` and `returns: b.any`, and can't have overloads. The class can't be `refCounted`.
+
 ## What the compiler reads
 
 `bun build --compile --aot` knows every native function from one table, which `src/codegen/builtins` generates.

docs/runtime/bunfig.mdx

@@ -194,6 +194,47 @@ Same as the top-level `preload` field, but only applies to `bun test`.
 preload = ["./setup.ts"]
 ```
 
+### `test.environment`
+
+The DOM that test files run with. One of `"happy-dom"`, `"jsdom"`, or `"node"` for no DOM. Default `"node"`. A `// @vitest-environment <name>` comment in a test file overrides it. See [DOM testing](/test/dom#test-environments).
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+environment = "happy-dom"
+```
+
+Equivalent CLI flag: `--environment`. It overrides the `bunfig.toml` value.
+
+### `test.globals`
+
+Which module `test`, `expect` and the other globals come from. Default `"bun"`.
+
+- `"bun"`: a file that imports anything from `"vitest"` gets them from `"vitest"`. Any other file gets them from `"bun:test"`.
+- `"vitest"`: every file gets them from `"vitest"`, like `globals: true` in a Vitest project.
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+globals = "vitest"
+```
+
+Equivalent CLI flag: `--globals`. It overrides the `bunfig.toml` value.
+
+### `test.reactCompiler`
+
+Compile components and hooks with Bun's built-in React Compiler. Default `false`. Experimental.
+
+- `true`: every JavaScript and TypeScript file, except test files, preload scripts and `node_modules`.
+- An array of folders or glob patterns: only the files in them.
+- A table with `include` and `exclude`: the files that `include` matches and `exclude` doesn't.
+
+```toml title="bunfig.toml" icon="settings"
+[test.reactCompiler]
+include = ["src", "packages/ui"]
+exclude = ["**/*.stories.*"]
+```
+
+Equivalent CLI flag: `--react-compiler`. See [React Compiler](/test/configuration#react-compiler).
+
 ### `test.pathIgnorePatterns`
 
 Exclude files and directories from test discovery using glob patterns. The test runner prunes matched directories during scanning, so it never traverses their contents. Use this when your project contains submodules or vendored code with `*.test.ts` files that you don't want `bun test` to pick up.
@@ -346,6 +387,17 @@ retry = 3
 
 The `--retry` CLI flag overrides this setting.
 
+### `test.clearMocks`
+
+Clear every mock function's calls and results before each test. Default `false`, or `true` for tests that use `test` from `"vitest"`.
+
+```toml title="bunfig.toml" icon="settings"
+[test]
+clearMocks = true
+```
+
+`mockReset`, `restoreMocks`, `unstubEnvs` and `unstubGlobals` work the same way. They call `vi.resetAllMocks()`, `vi.restoreAllMocks()`, `vi.unstubAllEnvs()` and `vi.unstubAllGlobals()` before each test. Default `false`.
+
 ### `test.concurrentTestGlob`
 
 Test files matching this glob pattern run all of their tests concurrently, as if you passed the `--concurrent` flag.
@@ -394,6 +446,21 @@ junit = "test-results.xml"
 
 CI systems and other tools can consume the report.
 
+#### `test.reporter.junitSuites`
+
+How the JUnit report represents `describe` blocks. Default `"nested"`.
+
+- `"nested"`: each block gets its own `<testsuite>` inside its file's `<testsuite>`.
+- `"flat"`: each file gets one `<testsuite>`, and each test's name is prefixed with the names of its blocks.
+
+```toml title="bunfig.toml" icon="settings"
+[test.reporter]
+junit = "test-results.xml"
+junitSuites = "flat"
+```
+
+Equivalent to the `--reporter-junit-suites` flag.
+
 ## Linter
 
 The `[lint]` section configures [`bun lint`](/lint). Run `bun lint --init` to add it.

docs/runtime/environment-variables.mdx

@@ -173,6 +173,8 @@ Bun.env.API_TOKEN; // => "secret"
 import.meta.env.API_TOKEN; // => "secret"
 ```
 
+In `bun test`, `import.meta.env` also has [Vite's `MODE`, `DEV`, `PROD`, `SSR` and `BASE_URL`](/test/runtime-behavior#import-meta-env).
+
 To print all currently-set environment variables, run `bun --print process.env`.
 
 ```sh

docs/runtime/file-types.mdx

@@ -487,6 +487,16 @@ import "./styles.css";
 
 The import returns no value; it's only used for its side effects.
 
+Importing a [CSS module](/bundler/css#css-modules) (`.module.css`) returns an object that maps each class name to its unique identifier. This works in the bundler and at runtime (`bun run`, `bun test`).
+
+```ts
+import styles from "./styles.module.css";
+
+console.log(styles.button); // "button_123"
+```
+
+At runtime, CSS that the bundler would reject doesn't fail the import. Invalid rules and declarations are skipped, like in a browser.
+
 ### `sh` loader
 
 **Bun Shell loader**. Default for `.sh` files

docs/runtime/module-graph.mdx

@@ -5,7 +5,7 @@ description: Run many instances of one app in a single process with Bun.ModuleGr
 
 <Warning>`Bun.ModuleGraph` is experimental.</Warning>
 
-A `Bun.ModuleGraph` loads modules into the current global another time. Each graph has its own module instances, its own `require.cache`, and its own values for the names you pass as `globals`. Parsed code and bytecode are shared between graphs; ES modules share JIT-compiled code too. The first module a graph `import()`s is that graph's main module: `import.meta.main` and `require.main === module` are true in it, and in no other module of the graph.
+A `Bun.ModuleGraph` loads modules into the current global another time. Each graph has its own module instances, its own `require.cache`, and its own values for the names you pass as `globals`. Parsed code, bytecode and JIT-compiled code are shared between graphs, for as long as a graph that ran the code is reachable. The first module a graph `import()`s is that graph's main module: `import.meta.main` and `require.main === module` are true in it, and in no other module of the graph.
 
 ```ts host.ts icon="/icons/typescript.svg"
 // A `process` of the tenant's own: its module code sees this one.