Interface ResolvedConfig

Construct a type with the properties of T except for those in type K.

interface ResolvedConfig {
    alias: AliasOptions;
    allowOnly: boolean;
    api: ApiConfig & { token: string };
    attachmentsDir: string;
    bail?: number;
    base?: string;
    benchmark?: Required<
        Omit<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">,
    > & Pick<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">;
    browser: ResolvedBrowserOptions;
    cache: false | { dir: string };
    chaiConfig: ChaiConfig;
    changed: string | boolean;
    clearCache: boolean;
    clearMocks: boolean;
    clearScreen: boolean;
    cliExclude?: string[];
    color?: LabelColor;
    compare: string;
    config?: string;
    coverage: ResolvedCoverageOptions;
    css:
        | boolean
        | {
            exclude?: RegExp
            | RegExp[];
            include?: RegExp | RegExp[];
            modules?: { classNameStrategy?: CSSModuleScopeStrategy };
        };
    dangerouslyIgnoreUnhandledErrors: boolean;
    defines: Record<string, any>;
    deps: DepsOptions;
    diff?: string | SerializedDiffOptions;
    dir: string;
    disableConsoleIntercept: boolean;
    dom: boolean;
    dumpDir?: string;
    env: Partial<ProcessEnv>;
    environment: VitestEnvironment;
    environmentOptions: EnvironmentOptions;
    exclude: string[];
    execArgv: string[];
    expandSnapshotDiff: boolean;
    expect: {
        poll?: { interval?: number; timeout?: number };
        requireAssertions?: boolean;
    };
    experimental: {
        fsModuleCache?: boolean;
        fsModuleCachePath?: string;
        openTelemetry?: { enabled: boolean; sdkPath?: string };
        printImportBreakdown?: boolean;
    };
    fakeTimers: FakeTimerInstallOpts;
    filters?: string[];
    forceRerunTriggers: string[];
    globals: boolean;
    globalSetup: string
    | string[];
    hideSkippedTests: boolean;
    hookTimeout: number;
    include: string[];
    includeSource: string[];
    includeTaskLocation: boolean;
    inspect: string | boolean;
    inspectBrk: string | boolean;
    inspector: {
        enabled?: boolean;
        host?: string;
        port?: number;
        waitForDebugger?: boolean;
    };
    isolate: boolean;
    logHeapUsage: boolean;
    maxConcurrency: number;
    maxWorkers: number;
    mergeReports: string;
    mockReset: boolean;
    mode: VitestRunMode;
    name: string;
    onConsoleLog: (
        log: string,
        type: "stdout" | "stderr",
        entity: TestModule | TestCase | TestSuite | undefined,
    ) => boolean | void;
    onStackTrace: (error: TestError, frame: ParsedStack) => boolean | void;
    onUnhandledError: OnUnhandledErrorCallback;
    open: boolean;
    outputFile:
        | string
        | Partial<
            Record<
                | "default"
                | "blob"
                | "verbose"
                | "dot"
                | "json"
                | "tap"
                | "tap-flat"
                | "junit"
                | "tree"
                | "hanging-process"
                | "github-actions",
                string,
            >,
        > & Record<string, string>;
    outputJson: string;
    passWithNoTests: boolean;
    pool: Pool;
    poolRunner?: PoolRunnerInitializer;
    printConsoleTrace: boolean;
    project: string[];
    projects: TestProjectConfiguration[];
    provide: Partial<ProvidedContext>;
    related?: string[];
    reporters: (
        | Reporter
        | ["default", Partial<DefaultReporterOptions>]
        | ["blob", Partial<BlobOptions>]
        | ["verbose", Partial<DefaultReporterOptions>]
        | ["dot", Partial<BaseOptions>]
        | ["json", Partial<JsonOptions>]
        | ["tap", object]
        | ["tap-flat", object]
        | ["junit", Partial<JUnitOptions>]
        | ["tree", Partial<BaseOptions>]
        | ["hanging-process", object]
        | ["github-actions", Partial<GithubActionsReporterOptions>]
        | ["html", Partial<HTMLOptions>]
        | [string & {}, Record<string, unknown>]
    )[];
    restoreMocks: boolean;
    retry: number;
    root: string;
    runner?: string;
    sequence: {
        concurrent?: boolean;
        groupOrder: number;
        hooks: SequenceHooks;
        seed: number;
        sequencer: TestSequencerConstructor;
        setupFiles: SequenceSetupFiles;
        shuffle?: boolean;
    };
    server: {
        debug?: { dump?: string
        | true; load?: boolean };
        deps?: ServerDepsOptions;
    };
    setupFiles: string[];
    shard?: { count: number; index: number };
    silent: boolean | "passed-only";
    slowTestThreshold: number;
    snapshotEnvironment?: string;
    snapshotFormat: Omit<PrettyFormatOptions, "plugins" | "compareKeys"> & {
        compareKeys?: null;
    };
    snapshotOptions: SnapshotStateOptions;
    snapshotSerializers: string[];
    standalone: boolean;
    teardownTimeout: number;
    testNamePattern?: RegExp;
    testTimeout: number;
    typecheck: Omit<TypecheckConfig, "enabled"> & { enabled: boolean };
    ui: boolean;
    uiBase: string;
    unstubEnvs: boolean;
    unstubGlobals: boolean;
    update: boolean;
    vmMemoryLimit?: string | number;
    watch: boolean;
    watchTriggerPatterns: WatcherTriggerPattern[];
}

Hierarchy (View Summary)

Omit<
    Required<UserConfig>,

        | "project"
        | "config"
        | "filters"
        | "browser"
        | "coverage"
        | "testNamePattern"
        | "related"
        | "api"
        | "reporters"
        | "resolveSnapshotPath"
        | "benchmark"
        | "shard"
        | "cache"
        | "sequence"
        | "typecheck"
        | "runner"
        | "pool"
        | "cliExclude"
        | "diff"
        | "setupFiles"
        | "snapshotEnvironment"
        | "bail"
        | "name"
        | "vmMemoryLimit"
        | "fileParallelism",
>
- ResolvedConfig

Index

Properties

alias allowOnly api attachmentsDir bail? base? benchmark? browser cache chaiConfig changed clearCache clearMocks clearScreen cliExclude? color? compare config? coverage css dangerouslyIgnoreUnhandledErrors defines deps diff? dir disableConsoleIntercept dom dumpDir? env environment environmentOptions exclude execArgv expandSnapshotDiff expect experimental fakeTimers filters? forceRerunTriggers globals globalSetup hideSkippedTests hookTimeout include includeSource includeTaskLocation inspect inspectBrk inspector isolate logHeapUsage maxConcurrency maxWorkers mergeReports mockReset mode name onConsoleLog onStackTrace onUnhandledError open outputFile outputJson passWithNoTests pool poolRunner? printConsoleTrace project projects provide related? reporters restoreMocks retry root runner? sequence server setupFiles shard? silent slowTestThreshold snapshotEnvironment? snapshotFormat snapshotOptions snapshotSerializers standalone teardownTimeout testNamePattern? testTimeout typecheck ui uiBase unstubEnvs unstubGlobals update vmMemoryLimit? watch watchTriggerPatterns

Properties

alias

alias: AliasOptions

Specifies an Object, or an Array of Object, which defines aliases used to replace values in import or require statements. Will be merged with the default aliases inside resolve.alias.

allowOnly

allowOnly: boolean

Allow tests and suites that are marked as only

Default

!process.env.CI

api

api: ApiConfig & { token: string }

attachmentsDir

attachmentsDir: string

Directory path for storing attachments created by context.annotate

Default

'.vitest-attachments'

`Optional`bail

bail?: number

`Optional`base

base?: string

`Optional`benchmark

benchmark?: Required<
Omit<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">,
> & Pick<BenchmarkUserOptions, "outputFile" | "compare" | "outputJson">

browser

browser: ResolvedBrowserOptions

cache

cache: false | { dir: string }

Type Declaration

false
{ dir: string }
- dir: string
  Deprecated

chaiConfig

chaiConfig: ChaiConfig

Modify default Chai config. Vitest uses Chai for expect and assert matches. https://github.com/chaijs/chai/blob/4.x.x/lib/chai/config.js

changed

changed: string | boolean

Runs tests that are affected by the changes in the repository, or between specified branch or commit hash Requires initialized git repository

Default

false

`Experimental`clearCache

clearCache: boolean

Delete all Vitest caches, including experimental.fsModuleCache.

clearMocks

clearMocks: boolean

Will call .mockClear() on all spies before each test

Default

false

clearScreen

clearScreen: boolean

Override vite config's clearScreen from cli

`Optional`cliExclude

cliExclude?: string[]

`Optional`color

color?: LabelColor

compare

compare: string

benchmark.compare option exposed at the top level for cli

`Optional`config

config?: string

coverage

coverage: ResolvedCoverageOptions

css

css:
    | boolean
    | {
        exclude?: RegExp
        | RegExp[];
        include?: RegExp | RegExp[];
        modules?: { classNameStrategy?: CSSModuleScopeStrategy };
    }

Indicates if CSS files should be processed.

When excluded, the CSS files will be replaced with empty strings to bypass the subsequent processing.

Default

{ include: [], modules: { classNameStrategy: false } }

dangerouslyIgnoreUnhandledErrors

dangerouslyIgnoreUnhandledErrors: boolean

Ignore any unhandled errors that occur

Default

false

defines

defines: Record<string, any>

deps

deps: DepsOptions

Handling for dependencies inlining or externalizing

`Optional`diff

diff?: string | SerializedDiffOptions

dir

dir: string

Base directory to scan for the test files

Default

config.root

disableConsoleIntercept

disableConsoleIntercept: boolean

By default, Vitest automatically intercepts console logging during tests for extra formatting of test file, test title, etc... This is also required for console log preview on Vitest UI. However, disabling such interception might help when you want to debug a code with normal synchronous terminal console logging.

This option has no effect on browser pool since Vitest preserves original logging on browser devtools.

Default

false

dom

dom: boolean

Use happy-dom

`Optional`dumpDir

dumpDir?: string

env

env: Partial<ProcessEnv>

Custom environment variables assigned to process.env before running tests.

environment

environment: VitestEnvironment

Running environment

Supports 'node', 'jsdom', 'happy-dom', 'edge-runtime'

If used unsupported string, will try to load the package vitest-environment-${env}

Default

'node'

environmentOptions

environmentOptions: EnvironmentOptions

Environment options.

exclude

exclude: string[]

Exclude globs for test files

Default

['**/node_modules/**', '**/.git/**']

execArgv

execArgv: string[]

Pass additional arguments to node process when spawning the worker.

See Command-line API | Node.js for more information.

Set to process.execArgv to pass all arguments of the current process.

Be careful when using, it as some options may crash worker, e.g. --prof, --title. See https://github.com/nodejs/node/issues/41103

Default

[] // no execution arguments are passed

expandSnapshotDiff

expandSnapshotDiff: boolean

Show full diff when snapshot fails instead of a patch.

expect

expect: {
poll?: { interval?: number; timeout?: number };
requireAssertions?: boolean;
}

Configuration options for expect() matches.

Type Declaration

Optionalpoll?: { interval?: number; timeout?: number }
Default options for expect.poll()
- Optionalinterval?: number
  Polling interval in milliseconds
  Default
```
50
```
- Optionaltimeout?: number
  Timeout in milliseconds
  Default
```
1000
```
OptionalrequireAssertions?: boolean
Throw an error if tests don't have any expect() assertions.

`Experimental`experimental

experimental: {
    fsModuleCache?: boolean;
    fsModuleCachePath?: string;
    openTelemetry?: { enabled: boolean; sdkPath?: string };
    printImportBreakdown?: boolean;
}

Experimental features

Type Declaration

OptionalfsModuleCache?: boolean
Enable caching of modules on the file system between reruns.
OptionalfsModuleCachePath?: string
Path relative to the root of the project where the fs module cache will be stored.
Default
```
node_modules/.experimental-vitest-cache
```
OptionalopenTelemetry?: { enabled: boolean; sdkPath?: string }
https://vitest.dev/guide/open-telemetry
OptionalprintImportBreakdown?: boolean
Show imports (top 10) that take a long time.

Enabling this will also show a breakdown by default in UI, but you can always press a button to toggle it.

fakeTimers

fakeTimers: FakeTimerInstallOpts

Options for @sinon/fake-timers

`Optional`filters

filters?: string[]

forceRerunTriggers

forceRerunTriggers: string[]

Glob pattern of file paths that will trigger the whole suite rerun

Useful if you are testing calling CLI commands

Default

['**/package.json/**', '**/{vitest,vite}.config.*/**']

globals

globals: boolean

Default

false

globalSetup

globalSetup: string | string[]

Path to global setup files

hideSkippedTests

hideSkippedTests: boolean

Hide logs for skipped tests

Default

false

hookTimeout

hookTimeout: number

Default timeout of a hook in milliseconds

Default

include

include: string[]

A list of glob patterns that match your test files.

Default

['**/*.{test,spec}.?(c|m)[jt]s?(x)']

See

https://vitest.dev/config/include

includeSource

includeSource: string[]

Include globs for in-source test files

Default

[]

includeTaskLocation

includeTaskLocation: boolean

Include "location" property inside the test definition

Default

false

inspect

inspect: string | boolean

Debug tests by opening node:inspector in worker / child process. Provides similar experience as --inspect Node CLI argument.

Requires fileParallelism: false.

inspectBrk

inspectBrk: string | boolean

Debug tests by opening node:inspector in worker / child process and wait for debugger to connect. Provides similar experience as --inspect-brk Node CLI argument.

Requires fileParallelism: false.

inspector

inspector: {
    enabled?: boolean;
    host?: string;
    port?: number;
    waitForDebugger?: boolean;
}

Inspector options. If --inspect or --inspect-brk is enabled, these options will be passed to the inspector.

Type Declaration

Optionalenabled?: boolean
Enable inspector
Optionalhost?: string
Host to run inspector on
Optionalport?: number
Port to run inspector on
OptionalwaitForDebugger?: boolean
Wait for debugger to connect before running tests

isolate

isolate: boolean

Run tests in an isolated environment. This option has no effect on vmThreads pool.

Disabling this option improves performance if your code doesn't rely on side effects.

Default

true

logHeapUsage

logHeapUsage: boolean

Show heap usage after each test. Useful for debugging memory leaks.

maxConcurrency

maxConcurrency: number

A number of tests that are allowed to run at the same time marked with test.concurrent.

Default

maxWorkers

maxWorkers: number

Maximum number or percentage of workers to run tests in.

mergeReports

mergeReports: string

Directory of blob reports to merge

Default

'.vitest-reports'

mockReset

mockReset: boolean

Will call .mockReset() on all spies before each test

Default

false

mode

mode: VitestRunMode

Overrides Vite mode

Default

'test'

name

name: string

onConsoleLog

Custom handler for console.log in tests.

Return false to ignore the log.

onStackTrace

onStackTrace: (error: TestError, frame: ParsedStack) => boolean | void

Enable stack trace filtering. If absent, all stack trace frames will be shown.

Return false to omit the frame.

onUnhandledError

onUnhandledError: OnUnhandledErrorCallback

A callback that can return false to ignore an unhandled error

open

open: boolean

Open UI automatically.

Default

!process.env.CI

outputFile

Write test results to a file when the --reporter=jsonor--reporter=junit` option is also specified. Also definable individually per reporter by using an object instead.

outputJson

outputJson: string

benchmark.outputJson option exposed at the top level for cli

passWithNoTests

passWithNoTests: boolean

Pass with no tests

pool

pool: Pool

`Optional`poolRunner

poolRunner?: PoolRunnerInitializer

printConsoleTrace

printConsoleTrace: boolean

Always print console stack traces.

Default

false

project

project: string[]

projects

projects: TestProjectConfiguration[]

Options for projects

provide

provide: Partial<ProvidedContext>

Define variables that will be returned from inject in the test environment.

Example

// vitest.config.ts
export default defineConfig({
  test: {
    provide: {
      someKey: 'someValue'
    }
  }
})

// test file
import { inject } from 'vitest'
const value = inject('someKey') // 'someValue'

`Optional`related

related?: string[]

reporters

reporters: (
    | Reporter
    | ["default", Partial<DefaultReporterOptions>]
    | ["blob", Partial<BlobOptions>]
    | ["verbose", Partial<DefaultReporterOptions>]
    | ["dot", Partial<BaseOptions>]
    | ["json", Partial<JsonOptions>]
    | ["tap", object]
    | ["tap-flat", object]
    | ["junit", Partial<JUnitOptions>]
    | ["tree", Partial<BaseOptions>]
    | ["hanging-process", object]
    | ["github-actions", Partial<GithubActionsReporterOptions>]
    | ["html", Partial<HTMLOptions>]
    | [string & {}, Record<string, unknown>]
)[]

restoreMocks

restoreMocks: boolean

Will call .mockRestore() on all spies before each test

Default

false

retry

retry: number

Retry the test specific number of times if it fails.

Default

root

root: string

Project root

Default

process.cwd()

`Optional`runner

runner?: string

sequence

sequence: {
    concurrent?: boolean;
    groupOrder: number;
    hooks: SequenceHooks;
    seed: number;
    sequencer: TestSequencerConstructor;
    setupFiles: SequenceSetupFiles;
    shuffle?: boolean;
}

server

server: {
debug?: { dump?: string | true; load?: boolean };
deps?: ServerDepsOptions;
}

setupFiles

setupFiles: string[]

`Optional`shard

shard?: { count: number; index: number }

silent

silent: boolean | "passed-only"

Silent mode

Use 'passed-only' to see logs from failing tests only.

Default

false

slowTestThreshold

slowTestThreshold: number

The number of milliseconds after which a test is considered slow and reported as such in the results.

Default

`Optional`snapshotEnvironment

snapshotEnvironment?: string

snapshotFormat

snapshotFormat: Omit<PrettyFormatOptions, "plugins" | "compareKeys"> & {
compareKeys?: null;
}

Format options for snapshot testing.

snapshotOptions

snapshotOptions: SnapshotStateOptions

snapshotSerializers

snapshotSerializers: string[]

Paths to snapshot serializer modules.

standalone

standalone: boolean

Do not run tests when Vitest starts.

Vitest will only run tests if it's called programmatically or the test file changes.

If CLI file filters are passed, standalone mode is ignored.

teardownTimeout

teardownTimeout: number

Default timeout to wait for close when Vitest shuts down, in milliseconds

Default

`Optional`testNamePattern

testNamePattern?: RegExp

testTimeout

testTimeout: number

Default timeout of a test in milliseconds

Default

typecheck

typecheck: Omit<TypecheckConfig, "enabled"> & { enabled: boolean }

ui

ui: boolean

Enable Vitest UI

Default

false

uiBase

uiBase: string

Base url for the UI

Default

'/__vitest__/'

unstubEnvs

unstubEnvs: boolean

Will restore all env stubs to their original values before each test

Default

false

unstubGlobals

unstubGlobals: boolean

Will restore all global stubs to their original values before each test

Default

false

update

update: boolean

Update snapshot

Default

false

`Optional`vmMemoryLimit

vmMemoryLimit?: string | number

watch

watch: boolean

Watch mode

Default

!process.env.CI

watchTriggerPatterns

watchTriggerPatterns: WatcherTriggerPattern[]

Pattern configuration to rerun only the tests that are affected by the changes of specific files in the repository.

Interface ResolvedConfig

Hierarchy (View Summary)

Index

Properties

Properties

alias

allowOnly

Default

api

attachmentsDir

Default

Optionalbail

Optionalbase

Optionalbenchmark

browser

cache

Type Declaration

dir: string

Deprecated

chaiConfig

changed

Default

ExperimentalclearCache

clearMocks

Default

clearScreen

OptionalcliExclude

Optionalcolor

compare

Optionalconfig

coverage

css

Default

dangerouslyIgnoreUnhandledErrors

Default

defines

deps

Optionaldiff

dir

Default

disableConsoleIntercept

Default

dom

OptionaldumpDir

env

environment

Default

environmentOptions

exclude

Default

execArgv

Default

expandSnapshotDiff

expect

Type Declaration

Optionalpoll?: { interval?: number; timeout?: number }

Optionalinterval?: number

Default

Optionaltimeout?: number

Default

OptionalrequireAssertions?: boolean

Experimentalexperimental

Type Declaration

OptionalfsModuleCache?: boolean

OptionalfsModuleCachePath?: string

Default

OptionalopenTelemetry?: { enabled: boolean; sdkPath?: string }

OptionalprintImportBreakdown?: boolean

fakeTimers

Optionalfilters

forceRerunTriggers

Default

globals

Default

globalSetup

hideSkippedTests

Default

hookTimeout

Default

include

`Optional`bail

`Optional`base

`Optional`benchmark

`Experimental`clearCache

`Optional`cliExclude

`Optional`color

`Optional`config

`Optional`diff

`Optional`dumpDir

`Optional`poll?: { interval?: number; timeout?: number }

`Optional`interval?: number

`Optional`timeout?: number

`Optional`requireAssertions?: boolean

`Experimental`experimental

`Optional`fsModuleCache?: boolean

`Optional`fsModuleCachePath?: string

`Optional`openTelemetry?: { enabled: boolean; sdkPath?: string }

`Optional`printImportBreakdown?: boolean

`Optional`filters

`Optional`enabled?: boolean

`Optional`host?: string

`Optional`port?: number

`Optional`waitForDebugger?: boolean

`Optional`poolRunner

`Optional`related

`Optional`runner

`Optional`shard

`Optional`snapshotEnvironment

`Optional`testNamePattern