The Jest philosophy is to work great by default, but sometimes you just need more configuration power.

It is recommended to define the configuration in a dedicated JavaScript, TypeScript or JSON file. The file will be discovered automatically, if it is namedjest.config.js|ts|mjs|cjs|cts|json. You can use--config flag to pass an explicit path to the file.

The configuration file should simply export an object:

/**@type{import('jest').Config} */
const config={
verbose:true,
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  verbose:true,
};

exportdefault config;

Or a function returning an object:

/**@returns{Promise<import('jest').Config>} */
module.exports=async()=>{
return{
verbose:true,
};
};

importtype{Config}from'jest';

exportdefaultasync():Promise<Config>=>{
return{
    verbose:true,
};
};

/**@jest-config-loader ts-node */
// or
/**@jest-config-loader esbuild-register */

importtype{Config}from'jest';

const config: Config={
  verbose:true,
};

exportdefault config;

/**@jest-config-loader ts-node */
/**@jest-config-loader-options{"transpileOnly": true} */

importtype{Config}from'jest';

const config: Config={
  verbose:true,
};

exportdefault config;

The configuration also can be stored in a JSON file as a plain object:

{
"bail":1,
"verbose":true
}

Alternatively Jest's configuration can be defined through the"jest" key in thepackage.json of your project:

{
"name":"my-project",
"jest":{
"verbose":true
}
}

Also Jest's configuration json file can be referenced through the"jest" key in thepackage.json of your project:

{
"name":"my-project",
"jest":"./path/to/config.json"
}

Options​

const{defaults}=require('jest-config');

/**@type{import('jest').Config} */
const config={
moduleDirectories:[...defaults.moduleDirectories,'bower_components'],
};

module.exports= config;

importtype{Config}from'jest';
import{defaults}from'jest-config';

const config: Config={
  moduleDirectories:[...defaults.moduleDirectories,'bower_components'],
};

exportdefault config;

Reference​

automock [boolean]​

Default:false

This option tells Jest that all imported modules in your tests should be mocked automatically. All modules used in your tests will have a replacement implementation, keeping the API surface.

Example:

exportdefault{
authorize:()=>'token',
isAuthorized:secret=> secret==='wizard',
};

importutilsfrom'../utils';

test('if utils mocked automatically',()=>{
// Public methods of `utils` are now mock functions
expect(utils.authorize.mock).toBeTruthy();
expect(utils.isAuthorized.mock).toBeTruthy();

// You can provide them with your own implementation
// or pass the expected return value
  utils.authorize.mockReturnValue('mocked_token');
  utils.isAuthorized.mockReturnValue(true);

expect(utils.authorize()).toBe('mocked_token');
expect(utils.isAuthorized('not_wizard')).toBeTruthy();
});

bail [number | boolean]​

Default:0

By default, Jest runs all tests and produces all errors into the console upon completion. The bail config option can be used here to have Jest stop running tests aftern failures. Setting bail totrue is the same as setting bail to1.

cacheDirectory [string]​

Default:"/tmp/<path>"

The directory where Jest should store its cached dependency information.

Jest attempts to scan your dependency tree once (up-front) and cache it in order to ease some of the filesystem churn that needs to happen while running tests. This config option lets you customize where Jest stores that cache data on disk.

clearMocks [boolean]​

Default:false

Automatically clear mock calls, instances, contexts and results before every test. Equivalent to callingjest.clearAllMocks() before each test. This does not remove any mock implementation that may have been provided.

collectCoverage [boolean]​

Default:false

Indicates whether the coverage information should be collected while executing the test. Because this retrofits all executed files with coverage collection statements, it may significantly slow down your tests.

Jest ships with two coverage providers:babel (default) andv8. See thecoverageProvider option for more details.

collectCoverageFrom [array]​

Default:undefined

An array ofglob patterns indicating a set of files for which coverage information should be collected. If a file matches the specified glob pattern, coverage information will be collected for it even if no tests exist for this file and it's never required in the test suite.

/**@type{import('jest').Config} */
const config={
collectCoverageFrom:[
'**/*.{js,jsx}',
'!**/node_modules/**',
'!**/vendor/**',
],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  collectCoverageFrom:[
'**/*.{js,jsx}',
'!**/node_modules/**',
'!**/vendor/**',
],
};

exportdefault config;

This will collect coverage information for all the files inside the project'srootDir, except the ones that match**/node_modules/** or**/vendor/**.

=============================== Coverage summary ===============================
Statements   : Unknown% ( 0/0 )
Branches     : Unknown% ( 0/0 )
Functions    : Unknown% ( 0/0 )
Lines        : Unknown% ( 0/0 )
================================================================================
Jest: Coverage data for global was not found.

coverageDirectory [string]​

Default:undefined

The directory where Jest should output its coverage files.

coveragePathIgnorePatterns [array<string>]​

Default:["/node_modules/"]

An array of regexp pattern strings that are matched against all file paths before executing the test. If the file path matches any of the patterns, coverage information will be skipped.

These pattern strings match against the full path. Use the<rootDir> string token to include the path to your project's root directory to prevent it from accidentally ignoring all of your files in different environments that may have different root directories. Example:["<rootDir>/build/", "<rootDir>/node_modules/"].

coverageProvider [string]​

Indicates which provider should be used to instrument code for coverage. Allowed values arebabel (default) orv8.

coverageReporters [array<string | [string, options]>]​

Default:["clover", "json", "lcov", "text"]

A list of reporter names that Jest uses when writing coverage reports. Anyistanbul reporter can be used.

Additional options can be passed using the tuple form. For example, you may hide coverage report lines for all fully-covered files:

/**@type{import('jest').Config} */
const config={
coverageReporters:['clover','json','lcov',['text',{skipFull:true}]],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  coverageReporters:['clover','json','lcov',['text',{skipFull:true}]],
};

exportdefault config;

For more information about the options object shape refer toCoverageReporterWithOptions type in thetype definitions.

coverageThreshold [object]​

Default:undefined

This will be used to configure minimum threshold enforcement for coverage results. Thresholds can be specified asglobal, as aglob, and as a directory or file path. If thresholds aren't met, jest will fail. Thresholds specified as a positive number are taken to be the minimum percentage required. Thresholds specified as a negative number represent the maximum number of uncovered entities allowed.

For example, with the following configuration jest will fail if there is less than 80% branch, line, and function coverage, or if there are more than 10 uncovered statements:

/**@type{import('jest').Config} */
const config={
coverageThreshold:{
global:{
branches:80,
functions:80,
lines:80,
statements:-10,
},
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  coverageThreshold:{
    global:{
      branches:80,
      functions:80,
      lines:80,
      statements:-10,
},
},
};

exportdefault config;

If globs or paths are specified alongsideglobal, coverage data for matching paths will be subtracted from overall coverage and thresholds will be applied independently. Thresholds for globs are applied to all files matching the glob. If the file specified by path is not found, an error is returned.

For example, with the following configuration:

/**@type{import('jest').Config} */
const config={
coverageThreshold:{
global:{
branches:50,
functions:50,
lines:50,
statements:50,
},
'./src/components/':{
branches:40,
statements:40,
},
'./src/reducers/**/*.js':{
statements:90,
},
'./src/api/very-important-module.js':{
branches:100,
functions:100,
lines:100,
statements:100,
},
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  coverageThreshold:{
    global:{
      branches:50,
      functions:50,
      lines:50,
      statements:50,
},
'./src/components/':{
      branches:40,
      statements:40,
},
'./src/reducers/**/*.js':{
      statements:90,
},
'./src/api/very-important-module.js':{
      branches:100,
      functions:100,
      lines:100,
      statements:100,
},
},
};

exportdefault config;

Jest will fail if:

• The./src/components directory has less than 40% branch or statement coverage.
• One of the files matching the./src/reducers/**/*.js glob has less than 90% statement coverage.
• The./src/api/very-important-module.js file has less than 100% coverage.
• Every remaining file combined has less than 50% coverage (global).

dependencyExtractor [string]​

Default:undefined

This option allows the use of a custom dependency extractor. It must be a node module that exports an object with anextract function. E.g.:

const crypto=require('crypto');
const fs=require('fs');

module.exports={
extract(code, filePath, defaultExtract){
const deps=defaultExtract(code, filePath);
// Scan the file and add dependencies in `deps` (which is a `Set`)
return deps;
},
getCacheKey(){
return crypto
.createHash('md5')
.update(fs.readFileSync(__filename))
.digest('hex');
},
};

Theextract function should return an iterable (Array,Set, etc.) with the dependencies found in the code.

That module can also contain agetCacheKey function to generate a cache key to determine if the logic has changed and any cached artifacts relying on it should be discarded.

displayName [string, object]​

default:undefined

Allows for a label to be printed alongside a test while it is running. This becomes more useful in multi-project repositories where there can be many jest configuration files. This visually tells which project a test belongs to.

/**@type{import('jest').Config} */
const config={
displayName:'CLIENT',
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  displayName:'CLIENT',
};

exportdefault config;

Alternatively, an object with the propertiesname andcolor can be passed. This allows for a custom configuration of the background color of the displayName.displayName defaults to white when its value is a string. Jest useschalk to provide the color. As such, all of the valid options for colors supported bychalk are also supported by Jest.

/**@type{import('jest').Config} */
const config={
displayName:{
name:'CLIENT',
color:'blue',
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  displayName:{
    name:'CLIENT',
    color:'blue',
},
};

exportdefault config;

errorOnDeprecated [boolean]​

Default:false

Make calling deprecated APIs throw helpful error messages. Useful for easing the upgrade process.

extensionsToTreatAsEsm [array<string>]​

Default:[]

Jest will run.mjs and.js files with nearestpackage.json'stype field set tomodule as ECMAScript Modules. If you have any other files that should run with native ESM, you need to specify their file extension here.

/**@type{import('jest').Config} */
const config={
extensionsToTreatAsEsm:['.ts'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  extensionsToTreatAsEsm:['.ts'],
};

exportdefault config;

fakeTimers [object]​

Default:{}

The fake timers may be useful when a piece of code sets a long timeout that we don't want to wait for in a test. For additional details seeFake Timers guide andAPI documentation.

This option provides the default configuration of fake timers for all tests. Callingjest.useFakeTimers() in a test file will use these options or will override them if a configuration object is passed. For example, you can tell Jest to keep the original implementation ofprocess.nextTick() and adjust the limit of recursive timers that will be run:

/**@type{import('jest').Config} */
const config={
fakeTimers:{
doNotFake:['nextTick'],
timerLimit:1000,
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  fakeTimers:{
    doNotFake:['nextTick'],
    timerLimit:1000,
},
};

exportdefault config;

// install fake timers for this file using the options from Jest configuration
jest.useFakeTimers();

test('increase the limit of recursive timers for this and following tests',()=>{
  jest.useFakeTimers({timerLimit:5000});
// ...
});

/**@type{import('jest').Config} */
const config={
fakeTimers:{
enableGlobally:true,
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  fakeTimers:{
    enableGlobally:true,
},
};

exportdefault config;

Configuration options:

typeFakeableAPI=
|'Date'
|'hrtime'
|'nextTick'
|'performance'
|'queueMicrotask'
|'requestAnimationFrame'
|'cancelAnimationFrame'
|'requestIdleCallback'
|'cancelIdleCallback'
|'setImmediate'
|'clearImmediate'
|'setInterval'
|'clearInterval'
|'setTimeout'
|'clearTimeout';

typeModernFakeTimersConfig={
/**
   * If set to `true` all timers will be advanced automatically by 20 milliseconds
   * every 20 milliseconds. A custom time delta may be provided by passing a number.
   * The default is `false`.
   */
  advanceTimers?:boolean|number;
/**
   * List of names of APIs that should not be faked. The default is `[]`, meaning
   * all APIs are faked.
   */
  doNotFake?:Array<FakeableAPI>;
/** Whether fake timers should be enabled for all test files. The default is `false`. */
  enableGlobally?:boolean;
/**
   * Use the old fake timers implementation instead of one backed by `@sinonjs/fake-timers`.
   * The default is `false`.
   */
  legacyFakeTimers?:boolean;
/** Sets current system time to be used by fake timers, in milliseconds. The default is `Date.now()`. */
  now?:number;
/** Maximum number of recursive timers that will be run. The default is `100_000` timers. */
  timerLimit?:number;
};

/**@type{import('jest').Config} */
const config={
fakeTimers:{
enableGlobally:true,
legacyFakeTimers:true,
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  fakeTimers:{
    enableGlobally:true,
    legacyFakeTimers:true,
},
};

exportdefault config;

forceCoverageMatch [array<string>]​

Default:['']

Test files are normally ignored from collecting code coverage. With this option, you can overwrite this behavior and include otherwise ignored files in code coverage.

For example, if you have tests in source files named with.t.js extension as following:

exportfunctionsum(a, b){
return a+ b;
}

if(process.env.NODE_ENV==='test'){
test('sum',()=>{
expect(sum(1,2)).toBe(3);
});
}

You can collect coverage from those files with settingforceCoverageMatch.

/**@type{import('jest').Config} */
const config={
forceCoverageMatch:['**/*.t.js'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  forceCoverageMatch:['**/*.t.js'],
};

exportdefault config;

globals [object]​

Default:{}

A set of global variables that need to be available in all test environments.

For example, the following would create a global__DEV__ variable set totrue in all test environments:

/**@type{import('jest').Config} */
const config={
globals:{
__DEV__:true,
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  globals:{
    __DEV__:true,
},
};

exportdefault config;

globalSetup [string]​

Default:undefined

This option allows the use of a custom global setup module, which must export a function (it can be sync or async). The function will be triggered once before all test suites and it will receive two arguments: Jest'sglobalConfig andprojectConfig.

module.exports=asyncfunction(globalConfig, projectConfig){
console.log(globalConfig.testPathPatterns);
console.log(projectConfig.cache);

// Set reference to mongod in order to close the server during teardown.
  globalThis.__MONGOD__= mongod;
};

module.exports=asyncfunction(globalConfig, projectConfig){
console.log(globalConfig.testPathPatterns);
console.log(projectConfig.cache);

await globalThis.__MONGOD__.stop();
};

globalTeardown [string]​

Default:undefined

This option allows the use of a custom global teardown module which must export a function (it can be sync or async). The function will be triggered once after all test suites and it will receive two arguments: Jest'sglobalConfig andprojectConfig.

haste [object]​

Default:undefined

This will be used to configure the behavior ofjest-haste-map, Jest's internal file crawler/cache system. The following options are supported:

typeHasteConfig={
/** Whether to hash files using SHA-1. */
  computeSha1?:boolean;
/** The platform to use as the default, e.g. 'ios'. */
  defaultPlatform?:string|null;
/** Force use of Node's `fs` APIs rather than shelling out to `find` */
  forceNodeFilesystemAPI?:boolean;
/**
   * Whether to follow symlinks when crawling for files.
   *   This options cannot be used in projects which use watchman.
   *   Projects with `watchman` set to true will error if this option is set to true.
   */
  enableSymlinks?:boolean;
/** Path to a custom implementation of Haste. */
  hasteImplModulePath?:string;
/** All platforms to target, e.g ['ios', 'android']. */
  platforms?:Array<string>;
/** Whether to throw an error on module collision. */
  throwOnModuleCollision?:boolean;
/** Custom HasteMap module */
  hasteMapModulePath?:string;
/** Whether to retain all files, allowing e.g. search for tests in `node_modules`. */
  retainAllFiles?:boolean;
};

injectGlobals [boolean]​

Default:true

Insert Jest's globals (expect,test,describe,beforeEach etc.) into the global environment. If you set this tofalse, you should import from@jest/globals, e.g.

import{expect, jest, test}from'@jest/globals';

jest.useFakeTimers();

test('some test',()=>{
expect(Date.now()).toBe(0);
});

maxConcurrency [number]​

Default:5

A number limiting the number of tests that are allowed to run at the same time when usingtest.concurrent. Any test above this limit will be queued and executed once a slot is released.

maxWorkers [number | string]​

Specifies the maximum number of workers the worker-pool will spawn for running tests. In single run mode, this defaults to the number of the cores available on your machine minus one for the main thread. In watch mode, this defaults to half of the available cores on your machine to ensure Jest is unobtrusive and does not grind your machine to a halt. It may be useful to adjust this in resource limited environments like CIs but the defaults should be adequate for most use-cases.

For environments with variable CPUs available, you can use percentage based configuration:

/**@type{import('jest').Config} */
const config={
maxWorkers:'50%',
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  maxWorkers:'50%',
};

exportdefault config;

moduleDirectories [array<string>]​

Default:["node_modules"]

An array of directory names to be searched recursively up from the requiring module's location. Setting this option willoverride the default, if you wish to still searchnode_modules for packages include it along with any other options:

/**@type{import('jest').Config} */
const config={
moduleDirectories:['node_modules','bower_components'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  moduleDirectories:['node_modules','bower_components'],
};

exportdefault config;

moduleFileExtensions [array<string>]​

Default:["js", "mjs", "cjs", "jsx", "ts", "mts", "cts", "tsx", "json", "node"]

An array of file extensions your modules use. If you require modules without specifying a file extension, these are the extensions Jest will look for, in left-to-right order.

We recommend placing the extensions most commonly used in your project on the left, so if you are using TypeScript, you may want to consider moving "ts" and/or "tsx" to the beginning of the array.

moduleNameMapper [object<string, string | array<string>>]​

Default:null

A map from regular expressions to module names or to arrays of module names that allow to stub out resources, like images or styles with a single module.

Modules that are mapped to an alias are unmocked by default, regardless of whether automocking is enabled or not.

Use<rootDir> string token to refer torootDir value if you want to use file paths.

Additionally, you can substitute captured regex groups using numbered backreferences.

/**@type{import('jest').Config} */
const config={
moduleNameMapper:{
'^image![a-zA-Z0-9$_-]+$':'GlobalImageStub',
'^[./a-zA-Z0-9$_-]+\\.png$':'<rootDir>/RelativeImageStub.js',
'module_name_(.*)':'<rootDir>/substituted_module_$1.js',
'assets/(.*)':[
'<rootDir>/images/$1',
'<rootDir>/photos/$1',
'<rootDir>/recipes/$1',
],
},
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  moduleNameMapper:{
'^image![a-zA-Z0-9$_-]+$':'GlobalImageStub',
'^[./a-zA-Z0-9$_-]+\\.png$':'<rootDir>/RelativeImageStub.js',
'module_name_(.*)':'<rootDir>/substituted_module_$1.js',
'assets/(.*)':[
'<rootDir>/images/$1',
'<rootDir>/photos/$1',
'<rootDir>/recipes/$1',
],
},
};

exportdefault config;

The order in which the mappings are defined matters. Patterns are checked one by one until one fits. The most specific rule should be listed first. This is true for arrays of module names as well.

modulePathIgnorePatterns [array<string>]​

Default:[]

An array of regexp pattern strings that are matched against all module paths before those paths are to be considered 'visible' to the module loader. If a given module's path matches any of the patterns, it will not berequire()-able in the test environment.

These pattern strings match against the full path. Use the<rootDir> string token to include the path to your project's root directory to prevent it from accidentally ignoring all of your files in different environments that may have different root directories.

/**@type{import('jest').Config} */
const config={
modulePathIgnorePatterns:['<rootDir>/build/'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  modulePathIgnorePatterns:['<rootDir>/build/'],
};

exportdefault config;

modulePaths [array<string>]​

Default:[]

An alternative API to setting theNODE_PATH env variable,modulePaths is an array of absolute paths to additional locations to search when resolving modules. Use the<rootDir> string token to include the path to your project's root directory.

/**@type{import('jest').Config} */
const config={
modulePaths:['<rootDir>/app/'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  modulePaths:['<rootDir>/app/'],
};

exportdefault config;

notify [boolean]​

Default:false

Activates native OS notifications for test results. To display the notifications Jest needsnode-notifier package, which must be installed additionally:

npminstall --save-dev node-notifier

yarnadd--dev node-notifier

pnpmadd --save-dev node-notifier

notifyMode [string]​

Default:failure-change

Specifies notification mode. Requiresnotify: true.

Modes​

• always: always send a notification.
• failure: send a notification when tests fail.
• success: send a notification when tests pass.
• change: send a notification when the status changed.
• success-change: send a notification when tests pass or once when it fails.
• failure-change: send a notification when tests fail or once when it passes.

openHandlesTimeout [number]​

Default:1000

Print a warning indicating that there are probable open handles if Jest does not exit cleanly this number of milliseconds after it completes. Use0 to disable the warning.

preset [string]​

Default:undefined

A preset that is used as a base for Jest's configuration. A preset should point to an npm module that has ajest-preset.json,jest-preset.js,jest-preset.cjs orjest-preset.mjs file at the root.

For example, this presetfoo-bar/jest-preset.js will be configured as follows:

/**@type{import('jest').Config} */
const config={
preset:'foo-bar',
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  preset:'foo-bar',
};

exportdefault config;

Presets may also be relative to filesystem paths:

/**@type{import('jest').Config} */
const config={
preset:'./node_modules/foo-bar/jest-preset.js',
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  preset:'./node_modules/foo-bar/jest-preset.js',
};

exportdefault config;

prettierPath [string]​

Default:'prettier'

Sets the path to theprettier node module used to update inline snapshots.

projects [array<string | ProjectConfig>]​

Default:undefined

When theprojects configuration is provided with an array of paths or glob patterns, Jest will run tests in all of the specified projects at the same time. This is great for monorepos or when working on multiple projects at the same time.

/**@type{import('jest').Config} */
const config={
projects:['<rootDir>','<rootDir>/examples/*'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  projects:['<rootDir>','<rootDir>/examples/*'],
};

exportdefault config;

This example configuration will run Jest in the root directory as well as in every folder in the examples directory. You can have an unlimited amount of projects running in the same Jest instance.

The projects feature can also be used to run multiple configurations or multiplerunners. For this purpose, you can pass an array of configuration objects. For example, to run both tests and ESLint (viajest-runner-eslint) in the same invocation of Jest:

/**@type{import('jest').Config} */
const config={
projects:[
{
displayName:'test',
},
{
displayName:'lint',
runner:'jest-runner-eslint',
testMatch:['<rootDir>/**/*.js'],
},
],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  projects:[
{
      displayName:'test',
},
{
      displayName:'lint',
      runner:'jest-runner-eslint',
      testMatch:['<rootDir>/**/*.js'],
},
],
};

exportdefault config;

randomize [boolean]​

Default:false

The equivalent of the--randomize flag to randomize the order of the tests in a file.

reporters [array<moduleName | [moduleName, options]>]​

Default:undefined

Use this configuration option to add reporters to Jest. It must be a list of reporter names, additional options can be passed to a reporter using the tuple form:

/**@type{import('jest').Config} */
const config={
reporters:[
'default',
['<rootDir>/custom-reporter.js',{banana:'yes',pineapple:'no'}],
],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  reporters:[
'default',
['<rootDir>/custom-reporter.js',{banana:'yes', pineapple:'no'}],
],
};

exportdefault config;

Default Reporter​

If custom reporters are specified, the default Jest reporter will be overridden. If you wish to keep it,'default' must be passed as a reporters name:

/**@type{import('jest').Config} */
const config={
reporters:[
'default',
['jest-junit',{outputDirectory:'reports',outputName:'report.xml'}],
],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  reporters:[
'default',
['jest-junit',{outputDirectory:'reports', outputName:'report.xml'}],
],
};

exportdefault config;

GitHub Actions Reporter​

If included in the list, the built-in GitHub Actions Reporter will annotate changed files with test failure messages and (if used with'silent: false') print logs with github group features for easy navigation. Note that'default' should not be used in this case as'github-actions' will handle that already, so remember to also include'summary'. If you wish to use it only for annotations simply leave only the reporter without options as the default value of'silent' is'true':

/**@type{import('jest').Config} */
const config={
reporters:[['github-actions',{silent:false}],'summary'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  reporters:[['github-actions',{silent:false}],'summary'],
};

exportdefault config;

Summary Reporter​

Summary reporter prints out summary of all tests. It is a part of default reporter, hence it will be enabled if'default' is included in the list. For instance, you might want to use it as stand-alone reporter instead of the default one, or together withSilent Reporter:

/**@type{import('jest').Config} */
const config={
reporters:['jest-silent-reporter','summary'],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  reporters:['jest-silent-reporter','summary'],
};

exportdefault config;

Thesummary reporter accepts options. Since it is included in thedefault reporter you may also pass the options there.

/**@type{import('jest').Config} */
const config={
reporters:[['default',{summaryThreshold:10}]],
};

module.exports= config;

importtype{Config}from'jest';

const config: Config={
  reporters:[['default',{summaryThreshold:10}]],
};

exportdefault config;

ThesummaryThreshold option behaves in the following way, if the total number of test suites surpasses this threshold, a detailed summary of all failed tests will be printed after executing all the tests. It defaults to20.

Custom Reporters​

Custom reporter module must export a class that takesglobalConfig,reporterOptions andreporterContext as constructor arguments:

classCustomReporter{
constructor(globalConfig, reporterOptions, reporterContext){
this._globalConfig= globalConfig;
this._options= reporterOptions;
this._context= reporterContext;
}

onRunComplete(testContexts, results){
console.log('Custom reporter output:');
console.log('global config:',this._globalConfig);
console.log('options for this reporter from Jest config:',this._options);
console.log('reporter context passed from test scheduler:',this._context);
}

// Optionally, reporters can force Jest to exit with non zero code by returning
// an `Error` from `getLastError()` method.
getLastError(){
if(this._shouldFail){
returnnewError('Custom error reported!');
}
}
}

module.exports=CustomReporter;

resetMocks [boolean]​

Default:false

Automatically reset mock state before every test. Equivalent to callingjest.resetAllMocks() before each test. This will lead to any mocks having their fake implementations removed but does not restore their initial implementation.

resetModules [boolean]​

Default:false

By default, each test file gets its own independent module registry. EnablingresetModules goes a step further and resets the module registry before running each individual test. This is useful to isolate modules for every test so that the local module state doesn't conflict between tests. This can be done programmatically usingjest.resetModules().

resolver [string]​

Default:undefined

This option allows the use of a custom resolver. This resolver must be a module that exportseither:

1. a function expecting a string as the first argument for the path to resolve and an options object as the second argument. The function should either return a path to the module that should be resolved or throw an error if the module can't be found.or
2. an object containingasync and/orsync properties. Thesync property should be a function with the shape explained above, and theasync property should also be a function that accepts the same arguments, but returns a promise which resolves with the path to the module or rejects with an error.

The options object provided to resolvers has the shape:

typeResolverOptions={
/** Directory to begin resolving from. */
  basedir:string;
/** List of export conditions. */
  conditions?:Array<string>;
/** Instance of default resolver. */
defaultResolver:(path:string, options: ResolverOptions)=>string;
/** List of file extensions to search in order. */
  extensions?:Array<string>;
/** List of directory names to be looked up for modules recursively. */
  moduleDirectory?:Array<string>;
/** List of `require.paths` to use if nothing is found in `node_modules`. */
  paths?:Array<string>;
/** Current root directory. */
  rootDir?:string;
};