配置 Vitest

如果你正在使用 Vite 并且项目中存在 vite.config 文件，Vitest 会自动读取该文件，以确保测试环境与你的 Vite 应用的插件和设置保持一致。如果你需要为测试设置不同的配置，或者你的主应用不依赖于 Vite，你可以选择以下方式：

创建 vitest.config.ts 文件：该文件将具有更高的优先级，并会完全覆盖 vite.config.ts 中的配置（Vitest 支持所有常规的 JS 和 TS 扩展名，但不支持 json）。这意味着 vite.config 中的所有选项都将被忽略。
通过 CLI 传递 --config 选项：例如，运行 vitest --config ./path/to/vitest.config.ts。
在 vite.config.ts 中有条件地应用配置：利用 process.env.VITEST 或 defineConfig 上的 mode 属性（如果未通过 --mode 覆盖，该属性将设置为 test/benchmark）来实现。

要配置 vitest 本身，请在 Vite 配置中添加 test 属性。如果你是从 vite 导入 defineConfig，你还需要在配置文件顶部使用三斜杠指令添加对 Vitest 类型的引用。

配置示例

使用 vite 导出的 defineConfig，应遵循以下方式：

/// <reference types="vitest" />
import { defineConfig } from 'vite';

export default defineConfig({
  test: {
    // ... 在此处指定选项。
  },
});

<reference types="vitest" /> 将在 Vitest 4 中停止工作，但你现在就可以开始迁移到 vitest/config：

/// <reference types="vitest/config" />
import { defineConfig } from 'vite';

export default defineConfig({
  test: {
    // ... 在此处指定选项。
  },
});

使用 vitest/config 导出的 defineConfig，应遵循以下方式：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    // ... 在此处指定选项。
  },
});

如果需要，你可以获取 Vitest 的默认选项并进行扩展：

import { configDefaults, defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    exclude: [...configDefaults.exclude, 'packages/template/*'],
  },
});

当使用单独的 vitest.config.js 时，如果需要，你还可以从另一个配置文件中继承 Vite 的选项：

import { defineConfig, mergeConfig } from 'vitest/config';
import viteConfig from './vite.config';

export default mergeConfig(
  viteConfig,
  defineConfig({
    test: {
      exclude: ['packages/template/*'],
    },
  })
);

如果你的 Vite 配置定义为一个函数，你可以这样定义配置：

import { defineConfig, mergeConfig } from 'vitest/config';
import viteConfig from './vite.config';

export default defineConfig(configEnv =>
  mergeConfig(
    viteConfig(configEnv),
    defineConfig({
      test: {
        exclude: ['packages/template/*'],
      },
    })
  )
);

WARNING

本页上所有列出的选项都应放置在配置的 test 属性中：

export default defineConfig({
  test: {
    exclude: [],
  },
});

由于 Vitest 使用 Vite 配置，你也可以使用 Vite 中的任何配置选项。例如，define 用于定义全局变量，或 resolve.alias 用于定义别名——这些选项应定义在顶层，而不是在 test 属性中。

在项目配置中不支持的选项旁边有 * 标记。这意味着它们只能在根 Vitest 配置中设置。

include

类型: string[]
默认: ['**/*.{test,spec}.?(c|m)[jt]s?(x)']
CLI: vitest [...include], vitest **/*.test.js

匹配你的测试文件的通配符模式列表。

注意

当使用覆盖率时，Vitest 会自动将测试文件的 include 模式添加到覆盖率的默认 exclude 模式中。请参阅 coverage.exclude。

exclude

类型: string[]
默认: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**', '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*']
CLI: vitest --exclude "**/excluded-file"

应从你的测试文件中排除的通配符模式列表。

WARNING

此选项不影响覆盖率。如果你需要从覆盖率报告中移除某些文件，请使用 coverage.exclude。

这是唯一不会覆盖配置的选项，即使通过 CLI 标志提供。通过 --exclude 标志添加的所有通配符模式都将添加到配置的 exclude 中。

includeSource

类型: string[]
默认: []

用于源内测试文件的通配符模式。

定义后，Vitest 将运行所有匹配的、且内部包含 import.meta.vitest 的文件。

name

类型: string | { label: string, color?: LabelColor }

为测试项目或 Vitest 进程分配自定义名称。该名称将在 CLI 和 UI 中可见，并通过 project.name 在 Node.js API 中可用。

CLI 和 UI 使用的颜色可以通过提供一个带有 color 属性的对象来更改。

server

类型: { sourcemap?, deps?, ... }

Vite-Node 服务器选项。

server.sourcemap

类型: 'inline' | boolean
默认: 'inline'

将内联源映射注入模块。

server.debug

类型: { dumpModules?, loadDumppedModules? }

Vite-Node 调试器选项。

server.debug.dumpModules

类型: boolean | string

将转换后的模块转储到文件系统。传递字符串将转储到指定路径。

server.debug.loadDumppedModules

类型: boolean

只要存在，就从文件系统读取转储的模块。通过修改文件系统中的转储结果进行调试时很有用。

server.deps

类型: { external?, inline?, ... }

处理依赖项解析。

server.deps.external

类型: (string | RegExp)[]
默认: [/\/node_modules\//]

外部化意味着 Vite 将绕过对包的处理，直接交由原生 Node.js 处理。外部化的依赖项将不适用于 Vite 的转换器和解析器，因此它们在重新加载时不支持 HMR。默认情况下，node_modules 中的所有包都被外部化。

这些选项支持 node_modules 中存在的包名或 deps.moduleDirectories 中指定的包名。例如，位于 packages/some-name 中的包 @company/some-name 应指定为 some-name，并且 packages 应包含在 deps.moduleDirectories 中。基本上，Vitest 总是检查文件路径，而不是实际的包名。

如果使用正则表达式，Vitest 会将其应用于文件路径，而不是包名。

server.deps.inline

类型: (string | RegExp)[] | true
默认: []

Vite 将处理内联模块。这有助于处理以 ESM 格式（Node 无法处理）分发 .js 文件的包。

如果为 true，则所有依赖项都将内联。ssr.noExternal 中指定的所有依赖项将默认内联。

server.deps.fallbackCJS

类型 boolean
默认: false

当依赖项是有效的 ESM 包时，尝试根据路径猜测 CJS 版本。如果依赖项具有错误的 ESM 文件，这可能会有所帮助。

如果包在 ESM 和 CJS 模式下有不同的逻辑，这可能会导致一些偏差。

server.deps.cacheDir

类型 string
默认: 'node_modules/.vite'

保存缓存文件的目录。

deps

类型: { optimizer?, ... }

处理依赖项解析。

deps.optimizer

类型: { ssr?, web? }
另请参阅: 依赖优化选项

启用依赖优化。如果你的测试数量很多，这可能会提高它们的性能。

当 Vitest 遇到 include 中列出的外部库时，它将使用 esbuild 将其打包成一个文件并作为一个整体模块导入。这有几个优点：

导入包含大量依赖的包开销很大。通过将它们打包到一个文件中，我们可以节省大量时间。
导入 UI 库开销很大，因为它们不适合在 Node.js 中运行。
你的 alias 配置现在在打包的包中也能生效。
你的测试中的代码运行方式更接近于在浏览器中的实际运行方式。

请注意，只有 deps.optimizer?.[mode].include 选项中的包才会被打包（某些插件会自动填充此选项，例如 Svelte）。你可以在 Vite 文档中阅读有关可用选项的更多信息（Vitest 不支持 disable 和 noDiscovery 选项）。默认情况下，Vitest 对 jsdom 和 happy-dom 环境使用 optimizer.web，对 node 和 edge 环境使用 optimizer.ssr，但可以通过 transformMode 进行配置。

此选项还继承你的 optimizeDeps 配置（对于 web Vitest 将扩展 optimizeDeps，对于 ssr - ssr.optimizeDeps）。如果你在 deps.optimizer 中重新定义 include/exclude 选项，它将在运行测试时扩展你的 optimizeDeps。如果 include 中列出的选项在 exclude 中也列出，Vitest 会自动将其从 include 中移除。

TIP

你将无法编辑 node_modules 代码进行调试，因为代码实际上位于你的 cacheDir 或 test.cache.dir 目录中。如果你想使用 console.log 语句进行调试，请直接编辑缓存中的代码或使用 deps.optimizer?.[mode].force 选项强制重新打包。

deps.optimizer.{mode}.enabled

类型: boolean
默认: false

启用依赖优化。

deps.web

类型: { transformAssets?, ... }

当转换模式设置为 web 时应用于外部文件的选项。默认情况下，jsdom 和 happy-dom 使用 web 模式，而 node 和 edge 环境使用 ssr 转换模式，因此这些选项对这些环境中的文件没有影响。

通常，node_modules 中的文件是外部化的，但这些选项也会影响 server.deps.external 中指定的文件。

deps.web.transformAssets

类型: boolean
默认: true

Vitest 是否应该像 Vite 在浏览器中那样处理并解析资产（.png、.svg、.jpg 等）文件。

如果未指定查询，此模块将默认导出资产的路径。

WARNING

目前，此选项仅适用于 vmThreads 和 vmForks 池。

deps.web.transformCss

类型: boolean
默认: true

Vitest 是否应该像 Vite 在浏览器中那样处理并解析 CSS（.css、.scss、.sass 等）文件。

如果 CSS 文件被 css 选项禁用，此选项只会阻止 ERR_UNKNOWN_FILE_EXTENSION 错误的抛出。

WARNING

目前，此选项仅适用于 vmThreads 和 vmForks 池。

deps.web.transformGlobPattern

类型: RegExp | RegExp[]
默认: []

匹配应进行转换的外部模块的正则表达式模式。

默认情况下，node_modules 中的文件是外部化的，并且不会被转换，除非它是 CSS 或资产，并且相应的选项未被禁用。

WARNING

目前，此选项仅适用于 vmThreads 和 vmForks 池。

deps.interopDefault

类型: boolean
默认: true

将 CJS 模块的默认导出解释为命名导出。某些依赖项只打包 CJS 模块，并且不使用 Node.js 在通过 import 语法（而非 require）导入包时可以静态分析的命名导出。当在 Node 环境中使用命名导出导入此类依赖项时，你将看到此错误：

import { read } from 'fs-jetpack';
         ^^^^
SyntaxError: Named export 'read' not found. The requested module 'fs-jetpack' is a CommonJS module, which may not support all module.exports as named exports.
CommonJS modules can always be imported via the default export.

Vitest 不进行静态分析，并且在你的代码运行前不会报错，因此如果此功能被禁用，你很可能会在运行测试时看到此错误：

TypeError: createAsyncThunk is not a function
TypeError: default is not a function

默认情况下，Vitest 假定你正在使用打包器来解决此问题，并且不会报错，但如果你的代码未被处理，你可以手动禁用此行为。

deps.moduleDirectories

类型: string[]
默认: ['node_modules']

应被视为模块目录的目录列表。此配置选项会影响 vi.mock 的行为：当未提供工厂函数且要模拟的路径与 moduleDirectories 值之一匹配时，Vitest 将尝试通过在项目的根目录中查找 __mocks__ 文件夹来解析模拟。

此选项还会影响在外部化依赖项时，文件是否应被视为模块。默认情况下，Vitest 使用原生 Node.js 导入外部模块，绕过 Vite 转换步骤。

设置此选项将覆盖默认值。如果你希望仍然在 node_modules 中搜索包，请将其与其他选项一起包含：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    deps: {
      moduleDirectories: ['node_modules', path.resolve('../../packages')],
    },
  },
});

runner

类型: VitestRunnerConstructor
默认: node，运行测试时；benchmark，运行基准测试时

自定义测试运行器的路径。这是一个高级功能，应与自定义库的运行器一起使用。你可以在文档中阅读更多相关信息。

benchmark

类型: { include?, exclude?, ... }

运行 vitest bench 时使用的选项。

benchmark.include

类型: string[]
默认: ['**/*.{bench,benchmark}.?(c|m)[jt]s?(x)']

用于匹配基准测试文件的通配符模式。

benchmark.exclude

类型: string[]
默认: ['node_modules', 'dist', '.idea', '.git', '.cache']

用于排除基准测试文件的通配符模式。

benchmark.includeSource

类型: string[]
默认: []

用于源内基准测试文件的通配符模式。此选项类似于 includeSource。

定义后，Vitest 将运行所有匹配的、且内部包含 import.meta.vitest 的文件。

benchmark.reporters

类型: Arrayable<BenchmarkBuiltinReporters | Reporter>
默认: 'default'

自定义输出报告器。可以包含一个或多个内置报告器的名称、报告器实例和/或自定义报告器的路径。

benchmark.outputFile

已弃用，请改用 benchmark.outputJson。

benchmark.outputJson

类型: string | undefined
默认: undefined

存储基准测试结果的文件路径，可用于后续的 --compare 选项。

例如：

# 保存主分支的结果
git checkout main
vitest bench --outputJson main.json

# 切换分支并与主分支进行比较
git checkout feature
vitest bench --compare main.json

benchmark.compare

类型: string | undefined
默认: undefined

用于与当前运行进行比较的先前基准测试结果文件路径。

alias

类型: Record<string, string> | Array<{ find: string | RegExp, replacement: string, customResolver?: ResolverFunction | ResolverObject }>

在测试运行时定义自定义别名。它们将与 resolve.alias 中的别名合并。

WARNING

Vitest 使用 Vite SSR 原语来运行测试，这会带来一些注意事项。

别名仅影响由内联模块（所有源代码默认内联）直接通过 import 关键字导入的模块。
Vitest 不支持别名 require 调用。
如果你正在别名外部依赖项（例如，react -> preact），你可能希望直接别名 node_modules 中的实际包，以使其适用于外部化依赖项。 Yarn 和 pnpm 都支持通过 npm: 前缀进行别名。

globals

类型: boolean
默认: false
CLI: --globals, --globals=false

默认情况下，vitest 不提供全局 API，以保持代码的明确性。如果你更喜欢像 Jest 那样全局使用 API，你可以向 CLI 传递 --globals 选项或在配置中添加 globals: true。

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    globals: true,
  },
});

要使 TypeScript 与全局 API 配合使用，请将 vitest/globals 添加到你的 tsconfig.json 中的 types 字段：

json

{
  "compilerOptions": {
    "types": ["vitest/globals"]
  }
}

如果你已经重新定义了 typeRoots 以在编译中包含更多类型，你将不得不重新添加 node_modules，以便 vitest/globals 能够被发现。

json

{
  "compilerOptions": {
    "typeRoots": ["./types", "./node_modules/@types", "./node_modules"],
    "types": ["vitest/globals"]
  }
}

如果你已经在项目中使用 unplugin-auto-import，你也可以直接使用它来自动导入这些 API。

import { defineConfig } from 'vitest/config';
import AutoImport from 'unplugin-auto-import/vite';

export default defineConfig({
  plugins: [
    AutoImport({
      imports: ['vitest'],
      dts: true, // 生成 TypeScript 声明
    }),
  ],
});

environment

类型: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string
默认: 'node'
CLI: --environment=<env>

测试将运行的环境。Vitest 中的默认环境是 Node.js 环境。如果你正在构建 Web 应用程序，你可以通过 jsdom 或 happy-dom 使用类似浏览器的环境。

如果你正在构建边缘函数，你可以使用 edge-runtime 环境。

TIP

你还可以使用浏览器模式在浏览器中运行集成或单元测试，而无需模拟环境。

通过在文件顶部添加 @vitest-environment docblock 或注释，你可以为该文件中所有测试指定另一个环境：

Docblock 样式：

/**
 * @vitest-environment jsdom
 */

test('use jsdom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

注释样式：

// @vitest-environment happy-dom

test('use happy-dom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

为了与 Jest 兼容，还有一个 @jest-environment：

/**
 * @jest-environment jsdom
 */

test('use jsdom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});

如果你使用 --isolate=false 标志运行 Vitest，你的测试将按以下顺序运行：node、jsdom、happy-dom、edge-runtime、custom environments。这意味着，每个具有相同环境的测试都会被分组，但仍然是顺序运行。

从 0.23.0 开始，你还可以定义自定义环境。当使用非内置环境时，Vitest 将尝试加载包 vitest-environment-${name}。该包应导出一个具有 Environment 形状的对象：

import type { Environment } from 'vitest';

export default <Environment>{
  name: 'custom',
  transformMode: 'ssr',
  setup() {
    // 自定义设置
    return {
      teardown() {
        // 在所有使用此环境的测试运行后调用
      },
    };
  },
};

Vitest 还通过 vitest/environments 入口暴露 builtinEnvironments，以防你只想扩展它。你可以在我们的指南中阅读有关扩展环境的更多信息。

TIP

jsdom 环境暴露 jsdom 全局变量，其值等于当前的 JSDOM 实例。如果你希望 TypeScript 识别它，在使用此环境时，你可以将 vitest/jsdom 添加到你的 tsconfig.json 中：

json

{
  "compilerOptions": {
    "types": ["vitest/jsdom"]
  }
}

environmentOptions

类型: Record<'jsdom' | string, unknown>
默认: {}

这些选项会传递给当前 environment 的 setup 方法。默认情况下，如果你使用 JSDOM 作为测试环境，则只能配置 JSDOM 选项。

environmentMatchGlobs

类型: [string, EnvironmentName][]
默认: []

已弃用

此 API 在 Vitest 3 中已弃用。请改用 projects 来定义不同的配置。

export default defineConfig({
  test: {
    environmentMatchGlobs: [ 
      ['./*.jsdom.test.ts', 'jsdom'], 
    ], 
    projects: [ 
      { 
        extends: true, 
        test: { 
          environment: 'jsdom', 
        }, 
      }, 
    ], 
  },
})

根据通配符模式自动分配环境。Vitest 将使用第一个匹配项。

例如：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    environmentMatchGlobs: [
      // tests/dom 中的所有测试都将在 jsdom 中运行
      ['tests/dom/**', 'jsdom'],
      // tests/ 中所有以 .edge.test.ts 结尾的测试都将在 edge-runtime 中运行
      ['**/*.edge.test.ts', 'edge-runtime'],
      // ...
    ],
  },
});

poolMatchGlobs

类型: [string, 'threads' | 'forks' | 'vmThreads' | 'vmForks' | 'typescript'][]
默认: []

已弃用

此 API 在 Vitest 3 中已弃用。请改用 projects 来定义不同的配置：

export default defineConfig({
  test: {
    poolMatchGlobs: [ 
      ['./*.threads.test.ts', 'threads'], 
    ], 
    projects: [ 
      { 
        test: { 
          extends: true, 
          pool: 'threads', 
        }, 
      }, 
    ], 
  },
})

根据通配符模式自动分配测试运行的池。Vitest 将使用第一个匹配项。

例如：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolMatchGlobs: [
      // "worker-specific" 目录中的所有测试都将在 worker 中运行，就像你为它们启用了 `--pool=threads` 一样
      ['**/tests/worker-specific/**', 'threads'],
      // 在实际浏览器中运行 "browser" 目录中的所有测试
      ['**/tests/browser/**', 'browser'],
      // 如果你没有指定其他 glob 模式，所有其他测试将根据 "browser.enabled" 和 "threads" 选项运行
      // ...
    ],
  },
});

update*

类型: boolean
默认: false
CLI: -u, --update, --update=false

更新快照文件。这会更新所有变更的快照并删除过期的快照。

watch*

类型: boolean
默认: !process.env.CI && process.stdin.isTTY
CLI: -w, --watch, --watch=false

启用监听模式。

在交互式环境中，此模式是默认设置，除非明确指定 --run。

在 CI 中，或从非交互式 shell 运行时，“监听”模式不是默认设置，但可以使用此标志明确启用。

watchTriggerPatterns 3.2.0+ *

类型: WatcherTriggerPattern[]

Vitest 根据模块图重新运行测试，模块图由静态和动态 import 语句填充。但是，如果你从文件系统读取或从代理获取，则 Vitest 无法检测到这些依赖项。

为了正确重新运行这些测试，你可以定义一个正则表达式模式和一个返回要运行的测试文件列表的函数。

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    watchTriggerPatterns: [
      {
        pattern: /^src\/(mailers|templates)\/(.*)\.(ts|html|txt)$/,
        testToRun: (id, match) => {
          // 相对于根值
          return `./api/tests/mailers/${match[2]}.test.ts`;
        },
      },
    ],
  },
});

WARNING

返回的文件路径应该是绝对路径或相对于根目录的路径。请注意，这是一个全局选项，不能在项目配置中使用。

root

类型: string
CLI: -r <path>, --root=<path>

项目根目录。

dir

类型: string
CLI: --dir=<path>
默认: 与 root 相同

扫描测试文件的基本目录。如果你的根目录覆盖整个项目，你可以指定此选项以加快测试发现速度。

reporters*

类型: Reporter | Reporter[]
默认: 'default'
CLI: --reporter=<name>, --reporter=<name1> --reporter=<name2>

用于输出的自定义报告器。报告器可以是 Reporter 实例、用于选择内置报告器的字符串，或自定义实现的路径（例如 './path/to/reporter.ts'、'@scope/reporter'）。

outputFile*

类型: string | Record<string, string>
CLI: --outputFile=<path>, --outputFile.json=./path

当同时指定 --reporter=json、--reporter=html 或 --reporter=junit 选项时，将测试结果写入到文件中。通过提供一个对象而不是字符串，你可以在使用多个报告器时定义单独的输出。

pool*

类型: 'threads' | 'forks' | 'vmThreads' | 'vmForks'
默认: 'forks'
CLI: --pool=threads

用于运行测试的池。

threads*

使用 tinypool（Piscina 的轻量级分支）启用多线程。使用线程时，你无法使用 process.chdir() 等与进程相关的 API。一些用原生语言编写的库，例如 Prisma、bcrypt 和 canvas，在多线程中运行时可能会出现问题并导致段错误。在这些情况下，建议使用 forks 池。

forks*

与 threads 池类似，但通过 tinypool 使用 child_process 而不是 worker_threads。测试与主进程之间的通信速度不如 threads 池快。process.chdir() 等与进程相关的 API 在 forks 池中可用。

vmThreads*

在 threads 池中使用 VM 上下文（在沙盒环境中）运行测试。

这使得测试运行更快，但 VM 模块在运行 ESM 代码时不稳定。你的测试会内存泄漏——为了解决这个问题，请考虑手动编辑 poolOptions.vmThreads.memoryLimit 值。

WARNING

在沙盒中运行代码有一些优点（更快的测试），但也有一些缺点。

原生模块（如 fs、path 等）中的全局变量与测试环境中存在的全局变量不同。因此，这些原生模块抛出的任何错误都将引用与你的代码中使用的错误构造函数不同的错误构造函数：

try {
  fs.writeFileSync('/doesnt exist');
} catch (err) {
  console.log(err instanceof Error); // false
}

导入 ES 模块会无限期地缓存它们。如果你有大量上下文（测试文件），这会导致内存泄漏。Node.js 中没有用于清除该缓存的 API。
在沙盒环境中访问全局变量会花费更长时间需要更长时间。

请注意使用此选项时可能出现的问题。Vitest 团队无法解决这些由底层机制引起的问题。

vmForks*

与 vmThreads 池类似，但通过 tinypool 使用 child_process 而不是 worker_threads。测试与主进程之间的通信速度不如 vmThreads 池快。process.chdir() 等与进程相关的 API 在 vmForks 池中可用。请注意，此池具有 vmThreads 中列出的相同陷阱。

poolOptions*

类型: Record<'threads' | 'forks' | 'vmThreads' | 'vmForks', {}>
默认: {}

poolOptions.threads

threads 池的选项。

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      threads: {
        // 线程相关选项在此处
      },
    },
  },
});

poolOptions.threads.maxThreads*

类型: number | string
默认: 可用 CPU 数量

最大线程数或线程百分比。你也可以使用 VITEST_MAX_THREADS 环境变量。

poolOptions.threads.minThreads*

类型: number | string
默认: 可用 CPU 数量

最小线程数或线程百分比。你也可以使用 VITEST_MIN_THREADS 环境变量。

poolOptions.threads.singleThread

类型: boolean
默认: false

在单个工作线程中运行所有使用相同环境的测试。这将禁用内置模块隔离（源代码或内联代码仍将为每个测试重新评估），但可以提高测试性能。

WARNING

尽管此选项将强制测试一个接一个地运行，但此选项与 Jest 的 --runInBand 不同。Vitest 使用 worker 不仅是为了并行运行测试，也是为了提供隔离。通过禁用此选项，你的测试将按顺序运行，但在相同的全局上下文中，因此你必须自己提供隔离。

如果你依赖全局状态（前端框架通常如此）或你的代码依赖于为每个测试单独设置环境，这可能会导致各种问题。但对于不一定依赖全局状态或可以轻松规避全局状态影响的测试来说，这可以大大提高测试速度（最多快 3 倍）。

poolOptions.threads.useAtomics*

类型: boolean
默认: false

使用 Atomics 同步线程。

这在某些情况下可以提高性能，但在较旧的 Node 版本中可能会导致段错误。

poolOptions.threads.isolate

Type: boolean
Default: true

为每个测试文件隔离环境。

poolOptions.threads.execArgv*

类型: string[]
默认: []

向线程中的 Node.js 进程传递额外参数。有关更多信息，请参阅 Command-line API | Node.js。

WARNING

使用时请小心，因为某些选项可能会导致 worker 进程崩溃，例如 --prof、--title。请参阅 https://github.com/nodejs/node/issues/41103。

poolOptions.forks

forks 池的选项。

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      forks: {
        // Forks 相关选项在此处
      },
    },
  },
});

poolOptions.forks.maxForks*

类型: number | string
默认: 可用 CPU 数量

最大 fork 数或 fork 百分比。你也可以使用 VITEST_MAX_FORKS 环境变量。

poolOptions.forks.minForks*

类型: number | string
默认: 可用 CPU 数量

最小 fork 数或 fork 百分比。你也可以使用 VITEST_MIN_FORKS 环境变量。

poolOptions.forks.isolate

类型: boolean
默认: true

为每个测试文件隔离环境。

poolOptions.forks.singleFork

类型: boolean
默认: false

在单个子进程中运行所有使用相同环境的测试。这将禁用内置模块隔离（源代码或内联代码仍将为每个测试重新评估），但可以提高测试性能。

WARNING

尽管此选项将强制测试一个接一个地运行，但此选项与 Jest 的 --runInBand 不同。Vitest 使用子进程不仅是为了并行运行测试，也是为了提供隔离。通过禁用此选项，你的测试将按顺序运行，但在相同的全局上下文中，因此你必须自己提供隔离。

poolOptions.forks.execArgv*

类型: string[]
默认: []

向子进程中的 Node.js 进程传递额外参数。有关更多信息，请参阅 Command-line API | Node.js。

WARNING

使用时请小心，因为某些选项可能会导致 worker 进程崩溃，例如 --prof、--title。请参阅 https://github.com/nodejs/node/issues/41103。

poolOptions.vmThreads

vmThreads 池的选项。

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmThreads: {
        // VM 线程相关选项在此处
      },
    },
  },
});

poolOptions.vmThreads.maxThreads*

类型: number | string
默认: 可用 CPU 数量

最大线程数或线程百分比。你也可以使用 VITEST_MAX_THREADS 环境变量。

poolOptions.vmThreads.minThreads*

类型: number | string
默认: 可用 CPU 数量

最小线程数或线程百分比。你也可以使用 VITEST_MIN_THREADS 环境变量。

poolOptions.vmThreads.memoryLimit*

类型: string | number
默认: 1 / CPU Cores

指定 worker 在被回收之前的内存限制。此值严重依赖于你的环境，因此最好手动指定它而不是依赖默认值。

TIP

此实现基于 Jest 的 workerIdleMemoryLimit。

限制可以通过多种方式指定，无论结果如何，都使用 Math.floor 将其转换为整数值：

<= 1 - 该值被假定为系统总内存的百分比。因此 0.5 将 worker 的内存限制设置为系统总内存的一半。
> 1 - 假定为固定字节值。由于前面的规则，如果你想要 1 字节的值（我不知道为什么），你可以使用 1.1。
带单位
- 50% - 如上所述，总系统内存的百分比。
- 100KB、65MB 等 - 带单位表示固定内存限制。
- K / KB - 千字节 (x1000)
- KiB - Kibibytes (x1024)
- M / MB - 兆字节 - MiB - Mebibytes
- G / GB - 千兆字节 - GiB - Gibibytes

WARNING

由于报告的系统内存不正确，基于百分比的内存限制在 Linux CircleCI worker 上无法正常工作。

poolOptions.vmThreads.useAtomics*

类型: boolean
默认: false

使用 Atomics 同步线程。

这在某些情况下可以提高性能，但在较旧的 Node 版本中可能会导致段错误。

poolOptions.vmThreads.execArgv*

类型: string[]
默认: []

向 VM 上下文中的 Node.js 进程传递额外参数。有关更多信息，请参阅 Command-line API | Node.js。

WARNING

使用时请小心，因为某些选项可能会导致 worker 进程崩溃，例如 --prof、--title。请参阅 https://github.com/nodejs/node/issues/41103。

poolOptions.vmForks*

vmForks 池的选项。

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    poolOptions: {
      vmForks: {
        // VM forks 相关选项在此处
      },
    },
  },
});

poolOptions.vmForks.maxForks*

类型: number | string
默认: 可用 CPU 数量

最大 fork 数或 fork 百分比。你也可以使用 VITEST_MAX_FORKS 环境变量。

poolOptions.vmForks.minForks*

类型: number | string
默认: 可用 CPU 数量

最小 fork 数或 fork 百分比。你也可以使用 VITEST_MIN_FORKS 环境变量。

poolOptions.vmForks.memoryLimit*

类型: string | number
默认: 1 / CPU Cores

指定 worker 在被回收之前的内存限制。此值严重依赖于你的环境，因此最好手动指定它而不是依赖默认值。该值的计算方式在 poolOptions.vmThreads.memoryLimit 中描述。

poolOptions.vmForks.execArgv*

类型: string[]
默认: []

向 VM 上下文中的 Node.js 进程传递额外参数。有关更多信息，请参阅 Command-line API | Node.js。

WARNING

使用时请小心，因为某些选项可能会导致 worker 进程崩溃，例如 --prof、--title。请参阅 https://github.com/nodejs/node/issues/41103。

fileParallelism*

类型: boolean
默认: true
CLI: --no-file-parallelism, --fileParallelism=false

是否所有测试文件都并行运行。将其设置为 false 将会把 maxWorkers 和 minWorkers 选项的值覆盖为 1。

TIP

此选项不影响在同一个文件中运行的测试。如果你想并行运行这些测试，请在 describe 或通过配置使用 concurrent 选项。

maxWorkers*

类型: number | string

运行测试的最大 worker 数量或百分比。poolOptions.{threads,vmThreads}.maxThreads/poolOptions.forks.maxForks 具有更高的优先级。

minWorkers*

类型: number | string

运行测试的最小 worker 数量或百分比。poolOptions.{threads,vmThreads}.minThreads/poolOptions.forks.minForks 具有更高的优先级。

testTimeout

类型: number
默认: Node.js 中为 5_000，如果 browser.enabled 为 true 则为 15_000
CLI: --test-timeout=5000, --testTimeout=5000

测试的默认超时时间（毫秒）。使用 0 完全禁用超时。

hookTimeout

类型: number
默认: Node.js 中为 10_000，如果 browser.enabled 为 true 则为 30_000
CLI: --hook-timeout=10000, --hookTimeout=10000

钩子的默认超时时间（毫秒）。使用 0 完全禁用超时。

teardownTimeout*

类型: number
默认: 10000
CLI: --teardown-timeout=5000, --teardownTimeout=5000

Vitest 关闭时等待其完成关闭操作的默认超时时间（毫秒）。

silent*

类型: boolean | 'passed-only'
默认: false
CLI: --silent, --silent=false

静默测试的控制台输出。

使用 'passed-only' 仅显示失败测试的日志。失败测试的日志在测试完成后打印。

setupFiles

类型: string | string[]

设置文件的路径。它们将在每个测试文件运行之前执行。

INFO

编辑设置文件将自动触发所有测试的重新运行。

你可以在 setup 文件内部使用 process.env.VITEST_POOL_ID（整数型字符串）来区分线程。

TIP

请注意，如果你正在运行 --isolate=false，此设置文件将在相同的全局作用域中多次运行。这意味着你在每次测试之前都访问相同的全局对象，因此请确保你没有重复执行不必要的操作。

例如，你可能依赖一个全局变量：

import { config } from '@some-testing-lib';

if (!globalThis.defined) {
  config.plugins = [myCoolPlugin];
  computeHeavyThing();
  globalThis.defined = true;
}

// 钩子在每个套件之前重置
afterEach(() => {
  cleanup();
});

globalThis.resetBeforeEachTest = true;

provide 2.1.0+

类型: Partial<ProvidedContext>

定义可以在测试中通过 inject 方法访问的值。

vitest.config.jsapi.test.js

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    provide: {
      API_KEY: '123',
    },
  },
});

import { expect, inject, test } from 'vitest';

test('api key is defined', () => {
  expect(inject('API_KEY')).toBe('123');
});

WARNING

属性名必须是字符串，值必须是可序列化的，因为此对象将在不同进程之间传输。

TIP

如果你正在使用 TypeScript，你需要增强 ProvidedContext 类型以实现类型安全访问：

declare module 'vitest' {
  export interface ProvidedContext {
    API_KEY: string;
  }
}

// 将此文件标记为模块，以便类型增强正常工作
export {};

globalSetup

类型: string | string[]

全局设置文件的路径，相对于项目根目录。

全局设置文件可以导出名为 setup 和 teardown 的函数，或者一个返回 teardown 函数的 default 导出（示例）。

INFO

可以有多个 globalSetup 文件。setup 和 teardown 按顺序执行，teardown 则按相反顺序执行。

WARNING

全局设置仅在至少有一个测试正在运行时才运行。这意味着全局设置可能会在监听模式下，当测试文件更改后开始运行（测试文件将等待全局设置完成才能运行）。

请注意，全局设置在不同的全局作用域中运行，因此测试无法访问此处定义的变量。但是，你可以通过 provide 方法将可序列化数据传递给测试：

example.test.jsglobalSetup.ts 3.0.0+ globalSetup.ts 2.0.0+

import { inject } from 'vitest';

inject('wsPort') === 3000;

import type { TestProject } from 'vitest/node';

export default function setup(project: TestProject) {
  project.provide('wsPort', 3000);
}

declare module 'vitest' {
  export interface ProvidedContext {
    wsPort: number;
  }
}

import type { GlobalSetupContext } from 'vitest/node';

export default function setup({ provide }: GlobalSetupContext) {
  provide('wsPort', 3000);
}

declare module 'vitest' {
  export interface ProvidedContext {
    wsPort: number;
  }
}

从 Vitest 3 开始，你可以定义一个自定义回调函数，在 Vitest 重新运行测试时被调用。如果该函数是异步的，运行器将等待它完成，然后才执行测试。请注意，你不能像 { onTestsRerun } 那样解构 project，因为它依赖于上下文。

import type { TestProject } from 'vitest/node';

export default function setup(project: TestProject) {
  project.onTestsRerun(async () => {
    await restartDb();
  });
}

forceRerunTriggers*

类型: string[]
默认: ['**/package.json/**', '**/vitest.config.*/**', '**/vite.config.*/**']

用于匹配将触发整个测试套件重新运行的文件路径的通配符模式。当与 --changed 参数一起使用时，如果 git diff 中检测到触发器，将运行整个测试套件。

如果你正在测试调用 CLI 命令，这很有用，因为 Vite 无法构建模块图：

test('execute a script', async () => {
  // 如果 `dist/index.js` 的内容发生变化，Vitest 无法重新运行此测试
  await execa('node', ['dist/index.js']);
});

TIP

确保文件没有被 server.watch.ignored 排除。

coverage*

你可以使用 v8、istanbul 或自定义覆盖率解决方案来收集覆盖率。

你可以使用点表示法向 CLI 提供覆盖率选项：

npx vitest --coverage.enabled --coverage.provider=istanbul --coverage.all

WARNING

如果你使用点表示法指定覆盖率选项，请不要忘记启用 --coverage.enabled。在这种情况下，不要单独提供 --coverage 选项。

coverage.provider

类型: 'v8' | 'istanbul' | 'custom'
默认: 'v8'
CLI: --coverage.provider=<provider>

使用 provider 来选择用于覆盖率收集的工具。

coverage.enabled

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.enabled, --coverage.enabled=false

启用覆盖率收集功能。可以使用 --coverage CLI 选项覆盖。

coverage.include

类型: string[]
默认: ['**']
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.include=<path>, --coverage.include=<path1> --coverage.include=<path2>

作为通配符模式，用于指定应包含在覆盖率中的文件列表。

coverage.extension

类型: string | string[]
默认: ['.js', '.cjs', '.mjs', '.ts', '.mts', '.tsx', '.jsx', '.vue', '.svelte', '.marko', '.astro']
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.extension=<extension>, --coverage.extension=<extension1> --coverage.extension=<extension2>

coverage.exclude

类型: string[]
默认:

[
  'coverage/**',
  'dist/**',
  '**/node_modules/**',
  '**/[.]**',
  'packages/*/test?(s)/**',
  '**/*.d.ts',
  '**/virtual:*',
  '**/__x00__*',
  '**/\x00*',
  'cypress/**',
  'test?(s)/**',
  'test?(-*).?(c|m)[jt]s?(x)',
  '**/*{.,-}{test,spec,bench,benchmark}?(-d).?(c|m)[jt]s?(x)',
  '**/__tests__/**',
  '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*',
  '**/vitest.{workspace,projects}.[jt]s?(on)',
  '**/.{eslint,mocha,prettier}rc.{?(c|m)js,yml}',
];

可用提供者: 'v8' | 'istanbul'
CLI: --coverage.exclude=<path>, --coverage.exclude=<path1> --coverage.exclude=<path2>

作为通配符模式，用于指定应从覆盖率中排除的文件列表。

此选项会覆盖所有默认设置。在添加新的忽略模式时，请扩展默认选项：

import { coverageConfigDefaults, defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    coverage: {
      exclude: ['**/custom-pattern/**', ...coverageConfigDefaults.exclude],
    },
  },
});

注意

Vitest 会自动将测试文件的 include 模式添加到 coverage.exclude 中。无法显示测试文件自身的覆盖率。

coverage.all

类型: boolean
默认: true
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.all, --coverage.all=false

是否将所有文件（包括未测试的文件）包含在报告中。

coverage.clean

类型: boolean
默认: true
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.clean, --coverage.clean=false

在运行测试之前清除覆盖率结果。

coverage.cleanOnRerun

类型: boolean
默认: true
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.cleanOnRerun, --coverage.cleanOnRerun=false

在监听模式下重新运行时清除覆盖率报告。设置为 false 以保留上次运行的覆盖率结果。

coverage.reportsDirectory

类型: string
默认: './coverage'
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.reportsDirectory=<path>

WARNING

如果 coverage.clean 启用（默认值），Vitest 将在运行测试之前删除此目录。

用于写入覆盖率报告的目录。

要在 HTML 报告器的输出中预览覆盖率报告，此选项必须设置为 HTML 报告目录的子目录（例如 ./html/coverage）。

coverage.reporter

类型: string | string[] | [string, {}][]
默认: ['text', 'html', 'clover', 'json']
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.reporter=<reporter>, --coverage.reporter=<reporter1> --coverage.reporter=<reporter2>

要使用的覆盖率报告器。有关所有报告器的详细列表，请参阅 istanbul 文档。有关报告器特定选项的详细信息，请参阅 @types/istanbul-reporter。

报告器有三种不同类型：

单个报告器：{ reporter: 'html' }
多个无选项报告器：{ reporter: ['html', 'json'] }

带报告器选项的单个或多个报告器：

{
  reporter: [
    ['lcov', { projectRoot: './src' }],
    ['json', { file: 'coverage.json' }],
    ['text'],
  ];
}

你还可以指定自定义覆盖率报告器。有关更多信息，请参阅指南 - 自定义覆盖率报告器。

{
  reporter: [
    // 使用 NPM 包名指定报告器
    '@vitest/custom-coverage-reporter',
    ['@vitest/custom-coverage-reporter', { someOption: true }],

    // 使用本地路径指定报告器
    '/absolute/path/to/custom-reporter.cjs',
    ['/absolute/path/to/custom-reporter.cjs', { someOption: true }],
  ];
}

你可以在 Vitest UI 中查看覆盖率报告：有关更多详细信息，请查看 Vitest UI 覆盖率。

coverage.reportOnFailure

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.reportOnFailure, --coverage.reportOnFailure=false

即使测试失败也生成覆盖率报告。

coverage.allowExternal

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.allowExternal, --coverage.allowExternal=false

收集项目 root 之外的文件的覆盖率。

coverage.excludeAfterRemap 2.1.0+

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.excludeAfterRemap, --coverage.excludeAfterRemap=false

在覆盖率重新映射到原始源后，再次应用排除规则。当源文件被转译并可能包含非源文件的源映射时，这很有用。

当报告中出现即使与 coverage.exclude 模式匹配的文件时，请使用此选项。

coverage.skipFull

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.skipFull, --coverage.skipFull=false

不显示语句、分支和函数覆盖率达到 100% 的文件。

coverage.thresholds

覆盖率阈值选项。

如果阈值设置为正数，则将其解释为所需的最小覆盖率百分比。例如，将行阈值设置为 90 意味着必须覆盖 90% 的代码行。

如果阈值设置为负数，则将其视为允许的最大未覆盖项数。例如，将行阈值设置为 -10 意味着未覆盖的代码行数不得超过 10 行。

{
  coverage: {
    thresholds: {
      // 需要 90% 的函数覆盖率
      functions: 90,

      // 要求未覆盖的行数不超过 10 行
      lines: -10,
    }
  }
}

coverage.thresholds.lines

类型: number
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.thresholds.lines=<number>

代码行的全局阈值。

coverage.thresholds.functions

类型: number
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.thresholds.functions=<number>

函数的全局阈值。

coverage.thresholds.branches

类型: number
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.thresholds.branches=<number>

分支的全局阈值。

coverage.thresholds.statements

类型: number
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.thresholds.statements=<number>

语句的全局阈值。

coverage.thresholds.perFile

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.thresholds.perFile, --coverage.thresholds.perFile=false

按文件检查阈值。

coverage.thresholds.autoUpdate

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.thresholds.autoUpdate=<boolean>

当当前覆盖率优于配置的阈值时，将所有阈值 lines、functions、branches 和 statements 更新到配置文件中。此选项有助于在覆盖率提高时自动更新阈值。

coverage.thresholds.100

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.thresholds.100, --coverage.thresholds.100=false

将全局阈值设置为 100%。 --coverage.thresholds.lines 100 --coverage.thresholds.functions 100 --coverage.thresholds.branches 100 --coverage.thresholds.statements 100 的快捷方式。

coverage.thresholds[glob-pattern]

类型: { statements?: number functions?: number branches?: number lines?: number }
默认: undefined
可用提供者: 'v8' | 'istanbul'

为匹配通配符模式的文件设置阈值。

注意

Vitest 将所有文件（包括通配符模式匹配的文件）计入全局覆盖率阈值。这与 Jest 的行为不同。

{
  coverage: {
    thresholds: {
      // 所有文件的阈值
      functions: 95,
      branches: 70,

      // 匹配 glob 模式的阈值
      'src/utils/**.ts': {
        statements: 95,
        functions: 90,
        branches: 85,
        lines: 80,
      },

      // 匹配此模式的文件将只设置行阈值。
      // 不继承全局阈值。
      '**/math.ts': {
        lines: 100,
      }
    }
  }
}

coverage.thresholds[glob-pattern].100 2.1.0+

类型: boolean
默认: false
可用提供者: 'v8' | 'istanbul'

将匹配通配符模式的文件的阈值设置为 100%。

{
  coverage: {
    thresholds: {
      // 所有文件的阈值
      functions: 95,
      branches: 70,

      // 匹配 glob 模式的阈值
      'src/utils/**.ts': { 100: true },
      '**/math.ts': { 100: true }
    }
  }
}

coverage.ignoreEmptyLines

类型: boolean
默认: true (v1 中为 false)
可用提供者: 'v8'
CLI: --coverage.ignoreEmptyLines=<boolean>

忽略空行、注释和其他非运行时代码，例如 TypeScript 类型。需要 experimentalAstAwareRemapping: false。

此选项仅在所使用的编译器从转译代码中删除注释和其他非运行时代码时才有效。默认情况下，Vite 使用 ESBuild，它从 .ts、.tsx 和 .jsx 文件中删除注释和 TypeScript 类型。

如果你也想将 ESBuild 应用于其他文件，请在 esbuild 选项中定义它们：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  esbuild: {
    // 使用 ESBuild 转译所有文件，以从代码覆盖率中移除注释。
    // `test.coverage.ignoreEmptyLines` 工作所需：
    include: ['**/*.js', '**/*.jsx', '**/*.mjs', '**/*.ts', '**/*.tsx'],
  },
  test: {
    coverage: {
      provider: 'v8',
      ignoreEmptyLines: true,
    },
  },
});

coverage.experimentalAstAwareRemapping

类型: boolean
默认: false
可用提供者: 'v8'
CLI: --coverage.experimentalAstAwareRemapping=<boolean>

使用实验性 AST 基于分析重新映射覆盖率。提供更准确的结果。

coverage.ignoreClassMethods

类型: string[]
默认: []
可用提供者: 'istanbul'
CLI: --coverage.ignoreClassMethods=<method>

设置为要忽略覆盖率统计的类方法名称数组。有关更多信息，请参阅 istanbul 文档。

coverage.watermarks

类型:

{
  statements?: [number, number],
  functions?: [number, number],
  branches?: [number, number],
  lines?: [number, number]
}

默认:

{
  statements: [50, 80],
  functions: [50, 80],
  branches: [50, 80],
  lines: [50, 80]
}

可用提供者: 'v8' | 'istanbul'
CLI: --coverage.watermarks.statements=50,80, --coverage.watermarks.branches=50,80

语句、行、分支和函数的水印。有关更多信息，请参阅 istanbul 文档。

coverage.processingConcurrency

类型: boolean
默认: Math.min(20, os.availableParallelism?.() ?? os.cpus().length)
可用提供者: 'v8' | 'istanbul'
CLI: --coverage.processingConcurrency=<number>

处理覆盖率结果时使用的并发限制。

coverage.customProviderModule

类型: string
可用提供者: 'custom'
CLI: --coverage.customProviderModule=<path or module name>

指定自定义覆盖率提供程序模块的模块名称或路径。有关更多信息，请参阅指南 - 自定义覆盖率提供程序。

testNamePattern*

类型 string | RegExp
CLI: -t <pattern>, --testNamePattern=<pattern>, --test-name-pattern=<pattern>

运行全名匹配指定模式的测试。如果你将 OnlyRunThis 添加到此属性，则测试名称中不包含“OnlyRunThis”的测试将被跳过。

import { expect, test } from 'vitest';

// 运行
test('OnlyRunThis', () => {
  expect(true).toBe(true);
});

// 跳过
test('doNotRun', () => {
  expect(true).toBe(true);
});

open*

类型: boolean
默认: !process.env.CI
CLI: --open, --open=false

打开 Vitest UI（正在开发中）

api

类型: boolean | number
默认: false
CLI: --api, --api.port, --api.host, --api.strictPort

监听端口并提供 API 服务。设置为 true 时，默认端口为 51204。

browser 实验性

默认: { enabled: false }
CLI: --browser=<name>, --browser.name=chrome --browser.headless

用于运行浏览器测试的配置。请参阅"浏览器配置参考"文章。

WARNING

这是一个实验性功能。破坏性更改可能不遵循 SemVer，请在使用时锁定 Vitest 的版本。

clearMocks

类型: boolean
默认: false

将在每次测试前对所有 spies 调用 .mockClear() 方法。这将清除模拟历史记录，而不影响模拟的实现。

mockReset

类型: boolean
默认: false

将在每次测试前对所有 spies 调用 .mockReset() 方法。这将清除模拟历史记录并将每个模拟实现重置为其原始状态。

restoreMocks

类型: boolean
默认: false

将在每次测试前对所有 spies 调用 .mockRestore() 方法。这将清除模拟历史记录，将每个模拟实现恢复为其原始状态，并恢复被监视对象的原始描述符。

unstubEnvs

类型: boolean
默认: false

将在每次测试前调用 vi.unstubAllEnvs 方法。

unstubGlobals

类型: boolean
默认: false

将在每次测试前调用 vi.unstubAllGlobals 方法。

testTransformMode

类型: { web?, ssr? }

确定测试中导入的所有与通配符模式匹配的模块的转换方法。默认情况下，它依赖于环境。例如，使用 JSDOM 环境的测试将使用 ssr: false 标志处理所有文件，而使用 Node 环境的测试将使用 ssr: true 标志处理所有模块。

testTransformMode.ssr

类型: string[]
默认: []

对指定测试中的所有模块使用 SSR 转换管道。
Vite 插件在处理这些文件时将接收 ssr: true 标志。

testTransformMode.web

类型: string[]
默认: []

首先执行正常的转换管道（针对浏览器），然后执行 SSR 重写以在 Node 中运行代码。
Vite 插件在处理这些文件时将接收 ssr: false 标志。

snapshotFormat*

类型: PrettyFormatOptions

快照测试的格式选项。这些选项会传递给 pretty-format 库。

TIP

请注意，此对象上的 plugins 字段将被忽略。

如果你需要通过 pretty-format 插件扩展快照序列化器，请使用 expect.addSnapshotSerializer API 或 snapshotSerializers 选项。

snapshotSerializers*

类型: string[]
默认: []

快照测试的快照序列化器模块路径列表。如果你想添加自定义快照序列化器，这很有用。有关更多信息，请参阅自定义序列化器。

resolveSnapshotPath*

类型: (testPath: string, snapExtension: string, context: { config: SerializedConfig }) => string
默认: 将快照文件存储在 __snapshots__ 目录中

覆盖默认快照路径。例如，将快照存储在测试文件旁边：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    resolveSnapshotPath: (testPath, snapExtension) => testPath + snapExtension,
  },
});

allowOnly

类型: boolean
默认: !process.env.CI
CLI: --allowOnly, --allowOnly=false

允许运行标记为 only 的测试和套件。

dangerouslyIgnoreUnhandledErrors*

类型: boolean
默认: false
CLI: --dangerouslyIgnoreUnhandledErrors --dangerouslyIgnoreUnhandledErrors=false

忽略发生的任何未处理错误。

passWithNoTests*

类型: boolean
默认: false
CLI: --passWithNoTests, --passWithNoTests=false

如果找不到测试，Vitest 将不会报错。

logHeapUsage

类型: boolean默认: false
CLI: --logHeapUsage, --logHeapUsage=false

在每次测试后显示堆使用情况。这对于调试内存泄漏很有用。

css

类型: boolean | { include?, exclude?, modules? }

配置是否应处理 CSS。当被排除时，CSS 文件将被空字符串替换以绕过后续处理。CSS Modules 将返回一个代理，以避免影响运行时。

css.include

类型: RegExp | RegExp[]
默认: []

用于匹配应返回实际 CSS 并由 Vite 管道处理的文件的 RegExp 模式。

TIP

要处理所有 CSS 文件，请使用 /.+/。

css.exclude

类型: RegExp | RegExp[]
默认: []

用于匹配将返回空 CSS 文件的 RegExp 模式。

css.modules

类型: { classNameStrategy? }
默认: {}

css.modules.classNameStrategy

类型: 'stable' | 'scoped' | 'non-scoped'
默认: 'stable'

如果你决定处理 CSS 文件，你可以配置 CSS 模块中的类名是否应该具有作用域。你可以选择以下选项之一：

stable：类名将生成为 _${name}_${hashedFilename}。这意味着如果 CSS 内容更改，生成的类将保持不变，但如果文件名被修改或文件移动到另一个文件夹，则会更改。此设置在你使用快照功能时很有用。
scoped：类名将照常生成，如果启用了 CSS 处理，则会遵循 css.modules.generateScopedName 方法。默认情况下，文件名将生成为 _${name}_${hash}，其中 hash 包含文件名和文件内容。
non-scoped：类名将不进行哈希处理。

WARNING

默认情况下，Vitest 导出代理，绕过 CSS Modules 处理。如果你依赖类上的 CSS 属性，则必须使用 include 选项启用 CSS 处理。

maxConcurrency

类型: number
默认: 5
CLI: --max-concurrency=10, --maxConcurrency=10

允许同时运行的、标记为 test.concurrent 的测试数量。

超出此限制的测试将排队等待可用插槽出现时运行。

cache*

类型: false
CLI: --no-cache, --cache=false

如果你想禁用缓存功能，请使用此选项。目前 Vitest 会缓存测试结果，以便首先运行耗时较长和失败的测试。

缓存目录由 Vite 的 cacheDir 选项控制：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  cacheDir: 'custom-folder/.vitest',
});

你可以通过使用 process.env.VITEST 将目录限制为仅 Vitest：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  cacheDir: process.env.VITEST ? 'custom-folder/.vitest' : undefined,
});

sequence

类型: { sequencer?, shuffle?, seed?, hooks?, setupFiles?, groupOrder }

关于测试应如何排序的选项。

你可以使用点表示法向 CLI 提供序列选项：

npx vitest --sequence.shuffle --sequence.seed=1000

sequence.sequencer*

类型: TestSequencerConstructor
默认: BaseSequencer

一个自定义类，定义了分片和排序的方法。如果你只需要重新定义 sort 和 shard 方法中的一个，你可以从 vitest/node 扩展 BaseSequencer，但这两个方法都必须存在。

分片发生在排序之前，并且仅在提供了 --shard 选项时才进行。

如果指定了 sequencer.groupOrder，则 sequencer 将为每个组和池调用一次。

groupOrder 3.2.0+

类型: number
默认: 0

使用多个项目时，控制此项目运行测试的顺序。

具有相同组顺序号的项目将一起运行，且组按从低到高的顺序运行。
如果你不设置此选项，所有项目将并行运行。
如果多个项目使用相同的组顺序，它们将同时运行。

此设置仅影响项目运行的顺序，不影响项目内测试的顺序。要控制项目内的测试隔离或测试顺序，请使用 isolate 和 sequence.sequencer 选项。

示例

考虑这个例子：

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    projects: [
      {
        test: {
          name: 'slow',
          sequence: {
            groupOrder: 0,
          },
        },
      },
      {
        test: {
          name: 'fast',
          sequence: {
            groupOrder: 0,
          },
        },
      },
      {
        test: {
          name: 'flaky',
          sequence: {
            groupOrder: 1,
          },
        },
      },
    ],
  },
});

这些项目中的测试将按以下顺序运行：

 0. slow  |
          |> 一起运行
 0. fast  |

 1. flaky |> 在 slow 和 fast 之后单独运行

sequence.shuffle

类型: boolean | { files?, tests? }
默认: false
CLI: --sequence.shuffle, --sequence.shuffle=false

如果你希望文件和测试随机运行，你可以使用此选项或 CLI 参数 --sequence.shuffle 启用此功能。

Vitest 通常使用缓存来排序测试，因此耗时较长的测试会更早开始——这使得测试运行更快。如果文件和测试将随机运行，你将失去这种性能改进，但这可能有助于跟踪意外依赖于先前运行的测试。

sequence.shuffle.files

类型: boolean
默认: false
CLI: --sequence.shuffle.files, --sequence.shuffle.files=false

是否随机化文件。请注意，如果启用此选项，耗时较长的测试将不会更早开始。

sequence.shuffle.tests

类型: boolean
默认: false
CLI: --sequence.shuffle.tests, --sequence.shuffle.tests=false

是否随机化测试。

sequence.concurrent

类型: boolean
默认: false
CLI: --sequence.concurrent, --sequence.concurrent=false

如果你希望测试并行运行，你可以使用此选项或 CLI 参数 --sequence.concurrent 启用此功能。

sequence.seed*

类型: number
默认: Date.now()
CLI: --sequence.seed=1000

设置随机化种子，如果测试以随机顺序运行。

sequence.hooks

类型: 'stack' | 'list' | 'parallel'
默认: 'stack'
CLI: --sequence.hooks=<value>

更改钩子的执行顺序。

stack 将按相反顺序执行“after”钩子，“before”钩子将按其定义顺序执行
list 将按其定义顺序执行所有钩子
parallel 将并行运行单个组中的钩子（父套件中的钩子仍将在当前套件的钩子之前运行）

TIP

此选项不影响 onTestFinished。它总是按相反顺序调用。

sequence.setupFiles

类型: 'list' | 'parallel'
默认: 'parallel'
CLI: --sequence.setupFiles=<value>

更改设置文件的执行顺序。

list 将按其定义顺序执行设置文件
parallel 将并行执行设置文件

typecheck

用于配置类型检查测试环境的选项。

typecheck.enabled

类型: boolean
默认: false
CLI: --typecheck, --typecheck.enabled

在常规测试的同时启用类型检查功能。

typecheck.only

类型: boolean
默认: false
CLI: --typecheck.only

当启用类型检查时，仅运行类型检查测试。使用 CLI 时，此选项将自动启用类型检查功能。

typecheck.checker

类型: 'tsc' | 'vue-tsc' | string
默认: tsc

用于类型检查的工具。Vitest 将根据类型生成具有特定参数的进程，以便于解析。检查器应实现与 tsc 相同的输出格式。

你需要安装一个包才能使用类型检查器：

tsc 需要 typescript 包
vue-tsc 需要 vue-tsc 包

你还可以指定自定义二进制文件或命令名称的路径，该二进制文件或命令名称生成与 tsc --noEmit --pretty false 相同的输出。

typecheck.include

类型: string[]
默认: ['**/*.{test,spec}-d.?(c|m)[jt]s?(x)']

用于匹配应被视为测试文件的通配符模式。

typecheck.exclude

类型: string[]
默认: ['**/node_modules/**', '**/dist/**', '**/cypress/**', '**/.{idea,git,cache,output,temp}/**']

用于匹配不应被视为测试文件的通配符模式。

typecheck.allowJs

类型: boolean
默认: false

检查带有 @ts-check 注释的 JS 文件。如果你在 tsconfig 中启用了它，此设置将不会覆盖它。

typecheck.ignoreSourceErrors

类型: boolean
默认: false

如果 Vitest 在测试文件之外发现错误，则不导致测试失败。这将完全不显示非测试文件中的错误。

默认情况下，如果 Vitest 发现源文件中的错误，它将使测试套件失败。

typecheck.tsconfig

类型: string
默认: 尝试查找最近的 tsconfig.json

自定义 tsconfig 的路径，相对于项目根目录。

typecheck.spawnTimeout

类型: number
默认: 10_000

生成类型检查器所需的最小时间（毫秒）。

slowTestThreshold*

类型: number
默认: 300
CLI: --slow-test-threshold=<number>, --slowTestThreshold=<number>

测试或套件被视为慢速并在结果中报告为慢速的毫秒数。

chaiConfig

类型: { includeStack?, showDiff?, truncateThreshold? }
默认: { includeStack: false, showDiff: true, truncateThreshold: 40 }

等同于 Chai config。

chaiConfig.includeStack

类型: boolean
默认: false

影响断言错误消息中是否包含堆栈跟踪。默认值为 false 会抑制错误消息中的堆栈跟踪。

chaiConfig.showDiff

类型: boolean
默认: true

影响抛出的 AssertionErrors 中是否应包含 showDiff 标志。false 将始终为 false；true 将在断言请求显示差异时为 true。

chaiConfig.truncateThreshold

类型: number
默认: 40

设置断言错误中实际值和预期值的长度阈值。如果超过此阈值，例如对于大型数据结构，该值将替换为 [ Array(3) ] 或 { Object (prop1, prop2) } 等内容。如果想完全禁用截断，请将其设置为 0。

此配置选项会影响 test.each 标题和断言错误消息中值的截断。

bail

类型: number
默认: 0
CLI: --bail=<value>

当给定数量的测试失败时，停止测试执行。

默认情况下，Vitest 将运行所有测试用例，即使其中一些失败。这对于 CI 构建可能不是期望的行为，因为你只对 100% 成功的构建感兴趣，并且希望在测试失败时尽快停止测试执行。bail 选项可用于通过在发生失败时阻止其运行更多测试来加快 CI 运行。

retry

类型: number
默认: 0
CLI: --retry=<value>

如果测试失败，则重试指定次数。

onConsoleLog*

类型: (log: string, type: 'stdout' | 'stderr') => boolean | void

测试中 console.log 的自定义处理程序。如果你返回 false，Vitest 将不会把日志打印到控制台。

这对于过滤掉第三方库的日志很有用。

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    onConsoleLog(log: string, type: 'stdout' | 'stderr'): boolean | void {
      return !(log === 'message from third party library' && type === 'stdout');
    },
  },
});

onStackTrace*

类型: (error: Error, frame: ParsedStack) => boolean | void

在处理错误时，对每个堆栈跟踪的每个帧应用过滤函数。第一个参数 error 是一个对象，其属性与标准 Error 相同，但它不是 Error 的实际实例。

这对于过滤掉第三方库的堆栈跟踪帧很有用。

import type { ParsedStack } from 'vitest';
import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    onStackTrace(error: Error, { file }: ParsedStack): boolean | void {
      // 如果我们遇到 ReferenceError，则显示整个堆栈。
      if (error.name === 'ReferenceError') {
        return;
      }

      // 拒绝所有来自第三方库的帧。
      if (file.includes('node_modules')) {
        return false;
      }
    },
  },
});

diff

类型: string
CLI: --diff=<path>

DiffOptions 对象或导出 DiffOptions 的模块路径。如果你想自定义差异显示，这很有用。

例如，作为配置对象：

import { defineConfig } from 'vitest/config';
import c from 'picocolors';

export default defineConfig({
  test: {
    diff: {
      aIndicator: c.bold('--'),
      bIndicator: c.bold('++'),
      omitAnnotationLines: true,
    },
  },
});

或者作为模块：

vitest.config.jsvitest.diff.ts

import { defineConfig } from 'vitest/config';

export default defineConfig({
  test: {
    diff: './vitest.diff.ts',
  },
});

import type { DiffOptions } from 'vitest';
import c from 'picocolors';

export default {
  aIndicator: c.bold('--'),
  bIndicator: c.bold('++'),
  omitAnnotationLines: true,
} satisfies DiffOptions;

diff.expand

类型: boolean
默认: true
CLI: --diff.expand=false

展开所有公共行。

diff.truncateThreshold

类型: number
默认: 0
CLI: --diff.truncateThreshold=<path>

要显示的差异结果的最大长度。超过此阈值的差异将被截断。默认值 0 不会生效。

diff.truncateAnnotation

类型: string
默认: '... Diff result is truncated'
CLI: --diff.truncateAnnotation=<annotation>

如果差异结果被截断，则在差异结果末尾输出的注释。

diff.truncateAnnotationColor

类型: DiffOptionsColor = (arg: string) => string
默认: noColor = (string: string): string => string

截断注释的颜色，默认输出为无颜色。

diff.printBasicPrototype

类型: boolean
默认: false

在差异输出中打印基本原型 Object 和 Array。

diff.maxDepth

类型: number
默认: 20 (或比较不同类型时为 8)

限制打印嵌套对象时的递归深度。

fakeTimers

类型: FakeTimerInstallOpts

Vitest 在使用 vi.useFakeTimers() 时将传递给 @sinon/fake-timers 的选项。

fakeTimers.now

类型: number | Date
默认: Date.now()

使用指定的 Unix 纪元安装假计时器。

fakeTimers.toFake

类型: ('setTimeout' | 'clearTimeout' | 'setImmediate' | 'clearImmediate' | 'setInterval' | 'clearInterval' | 'Date' | 'nextTick' | 'hrtime' | 'requestAnimationFrame' | 'cancelAnimationFrame' | 'requestIdleCallback' | 'cancelIdleCallback' | 'performance' | 'queueMicrotask')[]
默认: 全局可用的所有内容，除了 nextTick 和 queueMicrotask

要模拟的全局方法和 API 名称数组。

要仅模拟 setTimeout() 和 nextTick()，请将此属性指定为 ['setTimeout', 'nextTick']。

当使用 --pool=forks 在 node:child_process 中运行 Vitest 时，不支持模拟 nextTick。NodeJS 在 node:child_process 内部使用 process.nextTick，并在模拟时导致挂起。当使用 --pool=threads 运行 Vitest 时，支持模拟 nextTick。

fakeTimers.loopLimit

类型: number
默认: 10_000

调用 vi.runAllTimers() 时将运行的最大计时器数量。

fakeTimers.shouldAdvanceTime

类型: boolean
默认: false

告诉 @sinonjs/fake-timers 根据实际系统时间偏移自动增加模拟时间（例如，模拟时间将根据实际系统时间每 20 毫秒增加 20 毫秒）。

fakeTimers.advanceTimeDelta

类型: number
默认: 20

仅在使用 shouldAdvanceTime: true 时相关。模拟时间每 20 毫秒增加 advanceTimeDelta 毫秒，实际系统时间每 20 毫秒变化。

fakeTimers.shouldClearNativeTimers

类型: boolean
默认: true

告诉假计时器通过委托给各自的处理程序来清除“原生”（即非假）计时器。禁用时，如果计时器在启动假计时器会话之前存在，可能会导致潜在的意外行为。

workspace*

已弃用

此选项已弃用，并将在下一个主要版本中移除。请改用 projects。

类型: string | TestProjectConfiguration[]
CLI: --workspace=./file.js
默认: 靠近配置文件或根目录的 vitest.{workspace,projects}.{js,ts,json} 文件

相对于 root 的工作区配置文件的路径。

从 Vitest 3 开始，你也可以在根配置中定义工作区数组。如果工作区在配置中手动定义，Vitest 将忽略根目录中的 vitest.workspace 文件。

projects*

类型: TestProjectConfiguration[]
默认: []

项目数组。

isolate

类型: boolean
默认: true
CLI: --no-isolate, --isolate=false

在隔离环境中运行测试。此选项对 vmThreads 和 vmForks 池没有影响。

如果代码不依赖副作用（对于 node 环境的项目通常如此），禁用此选项可能会提高性能。

TIP

你可以通过使用 poolOptions 属性禁用特定池的隔离。

includeTaskLocation

类型: boolean
默认: false

当 Vitest API 在报告器中接收任务时，是否应包含 location 属性。如果测试很多，这可能会导致轻微的性能下降。

location 属性具有 column 和 line 值，它们对应于原始文件中 test 或 describe 的位置。

如果你没有明确禁用此选项，并且你正在下列场景中运行 Vitest，此选项将自动启用：

TIP

如果你不使用依赖此功能的自定义代码，此选项无效。

snapshotEnvironment

类型: string

自定义快照环境实现的路径。如果你在不支持 Node.js API 的环境中运行测试，这很有用。此选项对浏览器运行器没有任何影响。

此对象应具有 SnapshotEnvironment 的形状，并用于解析和读/写快照文件：

export interface SnapshotEnvironment {
  getVersion: () => string;
  getHeader: () => string;
  resolvePath: (filepath: string) => Promise<string>;
  resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
  saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
  readSnapshotFile: (filepath: string) => Promise<string | null>;
  removeSnapshotFile: (filepath: string) => Promise<void>;
}

如果你只需要覆盖 API 的一部分，你可以从 vitest/snapshot 入口点扩展默认的 VitestSnapshotEnvironment。

WARNING

这是一个低级选项，仅应在无法访问默认 Node.js API 的高级场景下使用。

如果你只需要配置快照功能，请使用 snapshotFormat 或 resolveSnapshotPath 选项。

env

类型: Partial<NodeJS.ProcessEnv>

测试期间在 process.env 和 import.meta.env 上可用的环境变量。这些变量在主进程中不可用（例如，在 globalSetup 中）。

expect

类型: ExpectOptions

expect.requireAssertions

类型: boolean
默认: false

与在每个测试开始时调用 expect.hasAssertions() 相同。这确保没有测试会意外通过。

TIP

这仅适用于 Vitest 的 expect。如果你使用 assert 或 .should 断言，它们将不计入，并且测试将因缺少 expect 断言而失败。

你可以通过调用 vi.setConfig({ expect: { requireAssertions: false } }) 来更改此值。该配置将应用于每个后续的 expect 调用，直到手动调用 vi.resetConfig。

expect.poll

expect.poll 的全局配置选项。这些选项与你可以传递给 expect.poll(condition, options) 的选项相同。

expect.poll.interval

类型: number
默认: 50

轮询间隔（毫秒）。

expect.poll.timeout

类型: number
默认: 1000

轮询超时（毫秒）。

printConsoleTrace

类型: boolean
默认: false

调用任何 console 方法时始终打印控制台跟踪。这对于调试很有用。

attachmentsDir 3.2.0+

类型: string
默认: '.vitest-attachments'

用于存储由 context.annotate 创建的附件的目录路径，相对于项目根目录。

配置 Vitest ​

include ​

exclude ​

includeSource ​

name ​

server ​

server.sourcemap ​

server.debug ​

server.debug.dumpModules ​

server.debug.loadDumppedModules ​

server.deps ​

server.deps.external ​

server.deps.inline ​

server.deps.fallbackCJS ​

server.deps.cacheDir ​

deps ​

deps.optimizer ​

deps.optimizer.{mode}.enabled ​

deps.web ​

deps.web.transformAssets ​

deps.web.transformCss ​

deps.web.transformGlobPattern ​

deps.interopDefault ​

deps.moduleDirectories ​

runner ​

benchmark ​

benchmark.include ​

benchmark.exclude ​

benchmark.includeSource ​

benchmark.reporters ​

benchmark.outputFile ​

benchmark.outputJson ​

benchmark.compare ​

alias ​

globals ​

environment ​

environmentOptions ​

environmentMatchGlobs ​

poolMatchGlobs ​

update* ​

watch* ​

watchTriggerPatterns 3.2.0+ * ​

root ​

dir ​

reporters* ​

outputFile* ​

pool* ​

threads* ​

forks* ​

vmThreads* ​

vmForks* ​

poolOptions* ​

poolOptions.threads ​

poolOptions.threads.maxThreads* ​

poolOptions.threads.minThreads* ​

poolOptions.threads.singleThread ​

poolOptions.threads.useAtomics* ​

poolOptions.threads.isolate ​

poolOptions.threads.execArgv* ​

poolOptions.forks ​

poolOptions.forks.maxForks* ​

poolOptions.forks.minForks* ​

poolOptions.forks.isolate ​

poolOptions.forks.singleFork ​

poolOptions.forks.execArgv* ​

poolOptions.vmThreads ​

poolOptions.vmThreads.maxThreads* ​

poolOptions.vmThreads.minThreads* ​

poolOptions.vmThreads.memoryLimit* ​

poolOptions.vmThreads.useAtomics* ​

poolOptions.vmThreads.execArgv* ​

poolOptions.vmForks* ​

poolOptions.vmForks.maxForks* ​

poolOptions.vmForks.minForks* ​

poolOptions.vmForks.memoryLimit* ​

poolOptions.vmForks.execArgv* ​

fileParallelism* ​

maxWorkers* ​

minWorkers* ​

testTimeout ​

配置 Vitest

include

exclude

includeSource

name

server

server.sourcemap

server.debug

server.debug.dumpModules

server.debug.loadDumppedModules

server.deps

server.deps.external

server.deps.inline

server.deps.fallbackCJS

server.deps.cacheDir

deps

deps.optimizer

deps.optimizer.{mode}.enabled

deps.web

deps.web.transformAssets

deps.web.transformCss

deps.web.transformGlobPattern

deps.interopDefault

deps.moduleDirectories

runner

benchmark

benchmark.include

benchmark.exclude

benchmark.includeSource

benchmark.reporters

benchmark.outputFile

benchmark.outputJson

benchmark.compare

alias

globals

environment

environmentOptions

environmentMatchGlobs

poolMatchGlobs

update*

watch*

watchTriggerPatterns 3.2.0+ *

root

dir

reporters*

outputFile*

pool*

threads*

forks*

vmThreads*

vmForks*

poolOptions*

poolOptions.threads

poolOptions.threads.maxThreads*

poolOptions.threads.minThreads*

poolOptions.threads.singleThread

poolOptions.threads.useAtomics*

poolOptions.threads.isolate

poolOptions.threads.execArgv*

poolOptions.forks

poolOptions.forks.maxForks*

poolOptions.forks.minForks*

poolOptions.forks.isolate

poolOptions.forks.singleFork

poolOptions.forks.execArgv*

poolOptions.vmThreads

poolOptions.vmThreads.maxThreads*

poolOptions.vmThreads.minThreads*

poolOptions.vmThreads.memoryLimit*

poolOptions.vmThreads.useAtomics*

poolOptions.vmThreads.execArgv*

poolOptions.vmForks*

poolOptions.vmForks.maxForks*

poolOptions.vmForks.minForks*

poolOptions.vmForks.memoryLimit*

poolOptions.vmForks.execArgv*

fileParallelism*

maxWorkers*

minWorkers*

testTimeout