一、Jest基本概念

npm安装：

1. npm install jest -D（安装到本地）
2. npm install jest -g（安装到全局）

运行：

npx jest（安装到本地的前提下）
jest（安装到全局的前提下）
修改”script” 中的”test” 为”jest”后使用npm run test或npm t

零配置：

但测试用例文件名格式为**test.js（默认配置下）

基本方法：

• 分组（Test Group）：descripe(描述语,function)

• 测试用例（Test Case）：test(描述语,function)

• 断言（Assert）：expect(运行需测试的方法并返回实际结果).toBe(预期结果)

Pencil.query =(name, url)=> { //方法，返回捕获
    // ?hello=test&wonghan=handsome
    var reg = new RegExp('(?:\?|&)' + name + '=(.*?)(?:&|$)')
    var ret = reg.exec(url) || []
    return ret[1]
}

test('query',()=>{ // testCase
    // 断言
    expect(Pencil.query('hello', '?hello=test')).toBe('test')
    expect(Pencil.query('hello', '?hello2=test')).toBe(undefined)
    //可以写多个ecpect()
})

test('query2',()=>{
    expect(Pencil.query('hello/test', '?hello/test=test')).toBe('test')
})

    //可以写多个test()
describe('test query',()=>{
test('query3',()=>{ // testCase
    // assert
    expect(Pencil.query('hello', '?hello=test')).toBe('test')
    expect(Pencil.query('hello', '?hello2=test')).toBe(undefined)
    })
})

二、Jest 配置

虽然说Jest是零配置，但也是可以配置

（一）配置位置

1. package.json

在package.json添加配置项”jest” : { 配置项 }

2. jest.config.js

新建jest.config.js并添加配置项module.exports = { 配置项 }

3. 命令行（独有的option）

见：命令行配置

（二）配置项

1. testMatch

设置识别哪些文件是测试文件（glob形式），与testRegex互斥，不能同时写

testMatch: ['**/__tests__/**/*.js?(x)','**/?(*.)(spec|test).js?(x)']

2. testRegex

设置识别哪些文件是测试文件（正则形式），与testMatch互斥，不能同时写

testRegex: '(/__tests__).*|(\\.|/)(test|spec))\\.jsx?$'

3. testRnviroment

测试环境，默认值是：jsdom，可修改为node

testEnvironment: 'jsdom'

4. rootDir

默认值：当前目录，一般是package.json所在的目录。

rootDir: ' '

5. moduleFileExtensions

测试文件的类型

moduleFileExtensions: ['js','json','jsx','node']

一般配置：

module.exports = {undefined
  testMatch: ['<rootDir>/test/**/*.js'],
  testEnvironment: 'jsdom',
  rootDir: '',
  moduleFileExtensions: ['js','json','jsx','node']
}

三、Jest Matchers

Matchers俗称断言库，例如上面的expect().toBe()便是其中之一，其他常见用法如下：

1.相等断言

**toBe(value)**：比较数字、string
**toEqual(value)**：比较Object、array
toBeNull()
toBeUndefined()

2.包含断言

**toHaveProperty(keyPath, value)**：是否有对应的属性
**toContain(item)**：是否包含对应的值，括号里写上array、string
**toMatch(regexpOrString)**：括号里写上正则

3.逻辑断言

toBeTruthy()
toBeFalsy()

在JavaScript中，有六个falsy值：false，0，’’，null， undefined，和NaN。其他一切都是Truthy。

**toBeGreaterThan(number)**：大于
**toBeLessThan(number)**：小于

4.not

取反，用法见下面例子

test('matchers',()=>{
    const a = {
        hello: 'jest',
        hi :{
            name: 'jest'
    }
}

const b = {
    hello: 'jest',
    hi: {
        name: 'jest'
    }
}

// 以下结果均为true
expect(a).toEqual(b)
expect([1,2,3]).toEqual([1,2,3])
expect(null).toBeNull()
expect([1,2,3]).toContain(1)
expect(b).toHaveProperty('hi')
expect('123').toContain('2')
expect('123').toMatch(/^\d+$/)
expect('123').not.toContain('4')
})

• 使用npx jest测试执行，结果为passed

从软件开发的角度来说项目技术的复杂度会带来开发，测试，交付流程等的复杂度的成倍提升，而我们知道测试是整个软件交付流程中非常重要的一个环节，在重前端的形势下，前端的测试的构建也显示尤为重要。

运行测试时，Jest会自动模拟依赖。Jest自动为每个依赖的模块生成Mock，并默认提供这些Mock，这样就可以很容易地隔离模块的依赖。集成了断言库，不需要再引入第三方的断言库，并且非常完美的支持React组件化测试

新建文件夹然后通过npm 命令安装：

npm install --save-dev jest

让我们来测试一个简单两个数字相加的function吧，新建 Sum.js

function sum(a, b){undefined
  return a + b;
}
module.exports = sum;

然后新一个Sum.test.js的文件来测试我们的sum function：

const sum = require('./Sum.js')

test('test 1 plus 2 result', () => {undefined
 expect(sum(1 , 2)).toBe(3);
})

test('test 2 plus 2 should equal 4', () => {undefined
 expect(sum(2 , 2)).toBe(4);
})

需要在package.json中加入下面配置：

{undefined
 "scripts": {undefined
  "test": "jest"
 }
}

Jest支持Babel，我们将很轻松的使用ES6的高级语法

Jest支持webpack，非常方便的使用它来管理我们的项目

Jest支持TypeScript

// be and equal
　　expect(4 * 2).toBe(8);                      // ===
　　expect({bar: 'bar'}).toEqual({bar: 'baz'}); // deep equal
　　expect(1).not.toBe(2);

　　// boolean
　　expect(1 === 2).toBeFalsy();
　　expect(false).not.toBeTruthy();

　　// comapre
　　expect(8).toBeGreaterThan(7);
　　expect(7).toBeGreaterThanOrEqual(7);
　　expect(6).toBeLessThan(7);
　　expect(6).toBeLessThanOrEqual(6);

　　// Promise
　　expect(Promise.resolve('problem')).resolves.toBe('problem');
　　expect(Promise.reject('assign')).rejects.toBe('assign');

　　// contain
　　expect(['apple', 'banana']).toContain('banana');
　　expect([{name: 'Homer'}]).toContainEqual({name: 'Homer'});
　　
　　// match
　　expect('NBA').toMatch(/^NB/);
　　expect({name: 'Homer', age: 45}).toMatchObject({name: 'Homer'});

API列表

`automock`

[boolean] 默认值︰false

这个选项告诉Jest所有的导入模块都自动mock下。

示例：

// utils.js
export default {
  authorize: () => {
    return 'token';
  },
  isAuthorized: secret => secret === 'wizard',
};

//__tests__/automocking.test.js
import utils from '../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();
});

注意：node modules当源以下mocks时会自动执行mock。核心模块，例如fs，是不会默认mock的，需要手动设置目录下：jest.mock('fs')

`bail`[number| boolean]

默认： 0

Jest默认将所有测试产生的信息都通过控制台显示，保释选项可以让你配置开玩笑在每次失败后将停止运行测试，设置与设置1一样是真实的。

`browser` [boolean]

默认值︰false

当解析模块的时候，是否跟package.json在中的Browserify的浏览器中。"browser"

`cacheDirectory` [string]

默认值︰ "/tmp/<path>"

Jest用来存储使用依赖信息缓存的目录。
Jest尝试去扫描你的依赖树一次（搁置）并且依赖树缓存起来，其Object是在运行测试时需要进行文件的示例。这个配置让你可以自定义将缓存数据储存在磁盘的那个位置。

`clearMocks` [boolean]

默认值︰false

在每个测试前自动调用的实例和实例调用。在每个测试之前jest.clearAllMocks，但不会删除已经有的实例调用。

`collectCoverage` [boolean]

默认值︰false

复查所有文件，可能会让你的测试执行速度明显减半。

`collectCoverageFrom` [array]

默认值：undefined

参数是glob 模式的列表，有哪些集合的文件是需要收集的。如果文件匹配了，那么被收集作为覆盖的基数，这个文件没有测试的用例。

示例：

{
  "collectCoverageFrom": [
    "**/*.{js,jsx}",
    "!**/node_modules/**",
    "!**/vendor/**"
  ]
}

上面的例子中搜索在rootDir下面所有的以js出的文件或jsx为后缀的目录，同时派node_modules
和vendor下的文件。

注意：该选项要求被设置collectCoverage成真实，或者通过--coverage参数来调用 Jest。

`coverageDirectory` [string]

默认值：undefined

`coveragePathIgnorePatterns` [array]

默认值︰["node_modules"]

比如提出覆盖的文件列表，模式string默认匹配全路径，可以添加<rootDir>token来放置某个系统环境里面把你的覆盖文件遗漏了["<rootDir>/build/", "<rootDir>/node_modules/"]。

`coverageProvider` [string]

使用哪个供应商来指导到底代码的覆盖测试，允许的参数有babel（默认） —— 用于v8。
注意：v8还比较像，比较的配置可能会有一些瑕疵。

`coverageReporters` [array]

默认： ["json", "lcov", "text", "clover"]

包含了reporters名字的列表，而Jest会用他们来覆盖报告。至于reporters有哪些，请参考：伊斯坦booleanreporters。

`coverageThreshold` [Object]

默认值：undefined

如果没有达到目标值，正确global的值是作为一个覆盖结构的最小目标值来设置的。最小的值，如果给了一个负数就表示最大的支持的允许值。

举个例子，下面的配置我们的分支数和覆盖率小 8%，和 10% 的举起未覆盖率声明

{
  ...
  "jest": {
    "coverageThreshold": {
      "global": {
        "branches": 80,
        "functions": 80,
        "lines": 80,
        "statements": -10
      }
    }
  }
}

`dependencyExtractor` [string]

默认值：undefined

这个选项允许特定依赖提取器的使用，必须满足是一个节点模块，同时导出的Object中包含extract函数。

例如：

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

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');
  },
};

extract函数应该返回一个代码里面的依赖项，并且返回的结果是可以遍历的。(例如Array, Set, etc.) 。

模块空间包含一个getCacheKey函数来生成一个缓存的key，用于决定逻辑是否变更。

`displayName` [string，Object]

默认值：undefined

允许在测试的时候打印显示标签。这在有多个repo和多个jest配置文件的时候很好用。

module.exports = {
  displayName: 'CLIENT',
};

或者

module.exports = {
  displayName: {
    name: 'CLIENT',
    color: 'blue',
  },
};

`errorOnDeprecated` [boolean]

默认值︰false

例外的 API 抛出提示性的错误信息。

`extraGlobals` [array]

默认值：undefined

测试文件在vmMath中运行，这会减慢对全局上下文属性（例如）的调用。使用此选项，您可以指定要在 vm 内定义的额外属性，以便更快地查找。
例如，如果您的测试Math经常调用，您可以通过设置extraGlobals.

{
  ...
  "jest": {
    "extraGlobals": ["Math"]
  }
}

`forceCoverageMatch` [array]

默认： ['']

收集代码覆盖率通常会忽略测试文件。使用此选项，您可以覆盖此行为并在代码覆盖中包含其他被忽略的文件。
例如，如果您在以.t.js如下扩展名命名的源文件中有测试：

// sum.t.js

export function sum(a, b) {
  return a + b;
}

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

你可以通过设置forceCoverageMatch从这些文件中收集覆盖率。

{
  ...
  "jest": {
    "forceCoverageMatch": ["**/*.t.js"]
  }
}

`globals` [Object]

默认值：{}

各种类似的变量，在所有测试环境下都可以访问。

下面，创建代码变量的环境有一个所有true的测试变量__DEV__：

{
  ...
  "jest": {
    "globals": {
      "__DEV__": true
    }
  }
}

注意，如果你在这指定了一个类似的值（例如，Object或物品），在之后的测试中，这个代码不会改变被引用的值，这对于其他测试来说是有效的。此外，globalsObject必须是json-serializable，因此不能用于指定全局函数。要实现这种功能，应该使用setupFiles。

`globalSetup` [string]

默认值：undefined

此选项允许使用自定义全局设置模块，该模块导出在所有测试套件之前触发一次的异步函数。此函数获取 Jest 的globalConfigObject作为参数。
注意：项目中配置的全局设置模块（使用多项目运行器）仅当您从该项目运行至少一个测试时才会触发。
注意：通过定义的任何全局变量globalSetup只能在globalTeardown. 您无法检索在测试套件中定义的全局变量。
注意：当代码转换应用于链接的设置文件时，Jest不会转换node_modules. 这是由于需要加载实际的转换器（例如babel或typescript）来执行转换。

示例：

// setup.js
module.exports = async () => {
  // ...
  // Set reference to mongod in order to close the server during teardown.
  global.__MONGOD__ = mongod;
};

// teardown.js
module.exports = async function() {
  await global.__MONGOD__.stop();
};

`globalTeardown` [string]

默认值：undefined

此选项允许使用自定义全局拆卸模块，该模块导出在所有测试套件之后触发一次的异步函数。此函数获取 Jest 的globalConfigObject作为参数。
注意：在项目中配置的全局拆卸模块（使用多项目运行器）仅在您从该项目运行至少一个测试时才会触发。
注意：关于node_modulesas for转换的相同警告globalSetup适用于globalTeardown.

`maxConcurrency` [number]

默认： 5

限制使用时允许同时运行的测试数量的数字test.concurrent。一旦插槽被释放，任何超过此限制的测试都将排队并执行。

`moduleDirectories` [array]

默认值︰["node_modules"]

要从所需模块的位置向上递归搜索的目录名称array。设置此选项将覆盖默认值，如果您仍希望搜索node_modules包，请将其与任何其他选项一起包含：["node_modules", "bower_components"]

`moduleFileExtensions` [array]

默认： ["js", "json", "jsx", "ts", "tsx", "node"]

您的模块使用的一系列文件扩展名。如果您需要模块而不指定文件扩展名，这些是 Jest 将按照从左到右的顺序查找的扩展名。
我们建议将项目中最常用的扩展放在左侧，因此如果您使用 TypeScript，您可能需要考虑将“ts”和/或“tsx”移动到array的开头。

`moduleNameMapper` [Object<string，string>]

默认值︰null

从正则表达式到moduleName 的映射，允许存根资源，例如带有单个模块的图像或样式。
默认情况下，映射到别名的模块不会被模拟，无论是否启用自动模拟。
如果要使用文件路径，请使用<rootDir>string标记来引用值。rootDir
此外，您可以使用编号的反向引用替换捕获的正则表达式组。

示例：

{
  "moduleNameMapper": {
    "^image![a-zA-Z0-9$_-]+$": "GlobalImageStub",
    "^[./a-zA-Z0-9$_-]+\\.png$": "<rootDir>/RelativeImageStub.js",
    "module_name_(.*)": "<rootDir>/substituted_module_$1.js"
  }
}

定义映射的顺序很重要。图案被一一检查，直到适合。最具体的规则应首先列出。

注意：如果您提供没有边界的moduleName ^$，可能会导致难以发现错误。例如relay，将替换relay名称中包含子string的所有模块：relay，react-relay并且graphql-relay都将指向您的存根。

`modulePathIgnorePatterns` [array]

默认值：[]

在将这些路径视为对模块加载器“可见”之前，与所有模块路径匹配的正则表达式模式string array。如果给定模块的路径与任何模式匹配，它将无法require()在测试环境中使用。
这些模式string与完整路径匹配。使用<rootDir>string标记来包含项目根目录的路径，以防止它意外忽略可能具有不同根目录的不同环境中的所有文件。示例：["<rootDir>/build/"]。

`modulePaths` [array]

默认值：[]

设置NODE_PATHenv 变量的另一种 APImodulePaths是解析模块时要搜索的其他位置的绝对路径array。使用<rootDir>string标记包含项目根目录的路径。示例：["<rootDir>/app/"]。

`notify` [boolean]

默认值︰false

激活测试结果通知。

`notifyMode` [string]

默认： failure-change

指定通知模式。需要notify: true.

Modes

always: 总是发送通知。
failure：当测试失败时发送通知。
success：测试通过时发送通知。
change: 当状态改变时发送通知。
success-change：当测试通过或失败时发送通知。
failure-change：当测试失败或通过时发送通知。

`preset` [string]

默认值：undefined

用作 Jest 配置基础的预设。预设应该指向在根目录下具有jest-preset.jsonor文件的 npm 模块。jest-preset.js
例如，此预设foo-bar/jest-preset.js将配置如下：

{
  "preset": "foo-bar"
}

预设也可以是相对文件系统路径。

{
  "preset": "./node_modules/foo-bar/jest-preset.js"
}

`prettierPath` [string]

默认： 'prettier'

prettier设置用于更新内联快照的节点模块的路径。

`projects`[array<string | ProjectConfig>]

默认值：undefined

当projects配置提供了一组路径或 glob 模式时，Jest 将同时在所有指定项目中运行测试。这对于 monorepos 或同时处理多个项目非常有用。

{
  "projects": ["<rootDir>", "<rootDir>/examples/*"]
}

此示例配置将在根目录以及示例目录中的每个文件夹中运行 Jest。您可以在同一个 Jest 实例中运行无限数量的项目。

项目功能也可用于运行多个配置或多个运行器。为此，您可以传递一组配置Object。例如，在 Jest 的同一次调用中同时运行测试和 ESLint（通过jest-runner-eslint ）：

{
  "projects": [
    {
      "displayName": "test"
    },
    {
      "displayName": "lint",
      "runner": "jest-runner-eslint",
      "testMatch": ["<rootDir>/**/*.js"]
    }
  ]
}

注意：使用多项目运行器时，建议displayName为每个项目添加一个。这将在displayName其测试旁边显示项Object。

`reporters`[array<moduleName | [moduleName ，options]>]

默认值：undefined

使用此配置选项将自定义报告器添加到 Jest。自定义报告器是一个实现onRunStart, onTestStart, onTestResult,onRunComplete方法的类，当任何这些事件发生时将调用这些方法。
如果指定了自定义报告器，则默认的 Jest 报告器将被覆盖。要保留默认报告器，default可以作为moduleName 传递。

这将覆盖默认reporters：

{
  "reporters": ["<rootDir>/my-custom-reporter.js"]
}

除了 Jest 提供的默认报告器之外，这将使用自定义报告器：

{
  "reporters": ["default", "<rootDir>/my-custom-reporter.js"]
}

此外，可以通过将optionsObject作为第二个参数传递来配置自定义报告器：

{
  "reporters": [
    "default",
    ["<rootDir>/my-custom-reporter.js", {"banana": "yes", "pineapple": "no"}]
  ]
}

自定义报告器模块必须定义一个将 aGlobalConfig和报告器选项作为构造函数参数的类：

示例reporters：

// my-custom-reporter.js
class MyCustomReporter {
  constructor(globalConfig, options) {
    this._globalConfig = globalConfig;
    this._options = options;
  }

  onRunComplete(contexts, results) {
    console.log('Custom reporter output:');
    console.log('GlobalConfig: ', this._globalConfig);
    console.log('Options: ', this._options);
  }
}

module.exports = MyCustomReporter;
// or export default MyCustomReporter;

getLastError()自定义报告器还可以通过从方法返回错误来强制 Jest 以非 0 代码退出

class MyCustomReporter {
  // ...
  getLastError() {
    if (this._shouldFail) {
      return new Error('my-custom-reporter.js reported an error');
    }
  }
}

有关方法和参数类型的完整列表，请参见packages/jest-reporters/src/types.tsReporter中的接口

`resetMocks` [boolean]

默认值︰false

每次测试前自动重置模拟状态。相当于jest.resetAllMocks()每次测试前调用。这将导致任何模拟删除其虚假实现但不会恢复其初始实现。

`resetModules` [boolean]

默认值︰false

默认情况下，每个测试文件都有自己独立的模块注册表。启用resetModules更进一步，并在运行每个单独的测试之前重置模块注册表。这对于隔离每个测试的模块很有用，这样本地模块状态就不会在测试之间发生冲突。这可以使用jest.resetModules().

`resolver` [string]

默认值：undefined

此选项允许使用自定义解析器。这个解析器必须是一个节点模块，它导出一个函数，该函数需要一个string作为解析路径的第一个参数，以及一个具有以下结构的Object作为第二个参数：

{
  "basedir": string,
  "browser": bool,
  "defaultResolver": "function(request, options)",
  "extensions": [string],
  "moduleDirectory": [string],
  "paths": [string],
  "rootDir": [string]
}

该函数应该返回应该解析的模块的路径，或者如果找不到模块则抛出错误。

注意：作为选项传递的 defaultResolver 是Jest默认解析器，在您编写自定义解析器时可能很有用。它采用与您的自定义参数相同的参数，例如（请求、选项）。

`restoreMocks` [boolean]

默认值︰false

每次测试前自动恢复模拟状态。相当于jest.restoreAllMocks()每次测试前调用。这将导致任何模拟删除其虚假实现并恢复其初始实现。

`rootDir` [string]

默认值：包含您的 Jest配置文件的目录的根目录，或者package.json 如果pwd没有package.json找到

Jest 应该扫描其中的测试和模块的根目录。如果您将 Jest 配置放在您的内部package.json并希望根目录成为您的 repo 的根目录，则此配置参数的值将默认为package.json.
通常，您需要将其设置为'src'或'lib'，对应于存储库中代码的存储位置。
请注意，'<rootDir>'在任何其他基于路径的配置设置中用作string标记将引用此值。因此，例如，如果您希望setupFiles配置条目指向env-setup.js项目根目录下的文件，则可以将其值设置为["<rootDir>/env-setup.js"].

`roots` [array]

默认值︰["<rootDir>"]

Jest 应该用来在其中搜索文件的目录的路径列表。
有时您只希望 Jest 在单个子目录中搜索（例如src/在您的仓库中有一个目录的情况），但阻止它访问其余的仓库。
注意：虽然rootDir主要用作在其他配置选项中重复使用的令牌，roots但 Jest 的内部使用它来定位测试文件和源文件。node_modules这也适用于从(__mocks__将需要生活在其中之一) 中搜索模块的手动模拟时roots。
注意：默认情况下，roots只有一个条目<rootDir>，但在某些情况下，您可能希望在一个项目中有多个根，例如roots: ["<rootDir>/src/", "<rootDir>/tests/"].

`runner` [string]

默认： "jest-runner"

此选项允许您使用自定义运行程序而不是 Jest 的默认测试运行程序。跑步者的例子包括：

注意：runner属性值可以省略jest-runner-包名的前缀。

要编写测试运行器，请导出一个在构造函数中接受的类globalConfig，并具有一个runTests带有签名的方法：

async runTests(
  tests: Array<Test>,
  watcher: TestWatcher,
  onStart: OnTestStart,
  onResult: OnTestSuccess,
  onFailure: OnTestFailure,
  options: TestRunnerOptions,
): Promise<void>

如果您需要将测试运行程序限制为仅以串行方式运行而不是并行执行，则您的类应将属性isSerial设置为true.

`setupFiles` [array]

默认值：[]

运行一些代码以配置或设置测试环境的模块的路径列表。每个 setupFile 将在每个测试文件中运行一次。由于每个测试都在其自己的环境中运行，因此这些脚本将在执行测试代码本身之前立即在测试环境中执行。
还值得注意的是，setupFiles将在之前 setupFilesAfterEnv执行。

`setupFilesAfterEnv` [array]

默认值：[]

运行一些代码以在每次测试之前配置或设置测试框架的模块的路径列表。由于setupFiles在环境中安装测试框架之前执行，因此该脚本文件为您提供了在环境中安装测试框架后立即运行一些代码的机会。
如果您希望路径相对于项Object根目录，请包含<rootDir>在路径的string中，例如"<rootDir>/a-configs-folder".
jasmine例如，Jest通过猴子修补 jasmine API提供了几个插件来完成这项工作。如果你想添加更多的 jasmine 插件（或者如果你想要一些自定义的、项目范围的匹配器），你可以在这些模块中这样做。
注意：setupTestFrameworkScriptFile不赞成使用setupFilesAfterEnv.

setupFilesAfterEnvjest.config.js 中的示例array：

module.exports = {
  setupFilesAfterEnv: ['./jest.setup.js'],
};

示例jest.setup.js文件

jest.setTimeout(10000); // in milliseconds

`snapshotResolver` [string]

默认值：undefined

可以解析测试<->快照路径的模块的路径。此配置选项允许您自定义 Jest 在磁盘上存储快照文件的位置。
示例快照解析器模块：

module.exports = {
  // resolves from test to snapshot path
  resolveSnapshotPath: (testPath, snapshotExtension) =>
    testPath.replace('__tests__', '__snapshots__') + snapshotExtension,

  // resolves from snapshot to test path
  resolveTestPath: (snapshotFilePath, snapshotExtension) =>
    snapshotFilePath
      .replace('__snapshots__', '__tests__')
      .slice(0, -snapshotExtension.length),

  // Example test path, used for preflight consistency check of the implementation above
  testPathForConsistencyCheck: 'some/__tests__/example.test.js',
};

`snapshotSerializers` [array]

默认值：[]

Jest 应用于快照测试的快照序列化程序模块的路径列表。
Jest 具有内置 JavaScript 类型、HTML 元素 (Jest 20.0.0+)、ImmutableJS (Jest 20.0.0+) 和 React 元素的默认序列化程序。有关更多信息，请参阅快照测试教程。

示例序列化模块：

// my-serializer-module
module.exports = {
  print(val, serialize, indent) {
    return 'Pretty foo: ' + serialize(val.foo);
  },

  test(val) {
    return val && val.hasOwnProperty('foo');
  },
};

serialize 是一个使用现有插件序列化值的函数。

要my-serializer-module用作序列化程序，配置如下：

{
  ...
  "jest": {
    "snapshotSerializers": ["my-serializer-module"]
  }
}

最后测试如下：

test(() => {
  const bar = {
    foo: {
      x: 1,
      y: 2,
    },
  };

  expect(bar).toMatchSnapshot();
});

渲染快照：

Pretty foo: Object {
  "x": 1,
  "y": 2,
}

要使依赖项显式而不是隐式，您可以调用expect.addSnapshotSerializer为单个测试文件添加模块，而不是snapshotSerializers在 Jest 配置中添加其路径。

`testEnvironment` [string]

默认值︰"jsdom"

将用于测试的测试环境。Jest 中的默认环境是通过jsdom实现的类似浏览器的环境。如果您正在构建节点服务，则可以使用该node选项来使用类似节点的环境。
通过在文件顶部添加一个@jest-environmentdocblock，您可以指定另一个环境用于该文件中的所有测试：

/**
 * @jest-environment jsdom
 */

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

您可以创建自己的模块，用于设置测试环境。模块必须导出一个带有setup,teardown和runScript方法的类。您还可以通过将变量分配给this.globalObject来将此模块中的变量传递给您的测试套件——这将使它们在您的测试套件中作为全局变量可用。

该类可以选择公开一个handleTestEvent方法来绑定到由jest-circus.

测试文件中的任何 docblock pragma 都将传递给环境构造函数，并可用于每个测试的配置。如果 pragma 没有值，它将出现在Object中，其值设置为空string。如果 pragma 不存在，则它不会出现在Object中。

注意：TestEnvironment 是沙盒的。每个测试套件都将在他们自己的 TestEnvironment 中触发 setup/teardown。

示例：

// my-custom-environment
const NodeEnvironment = require('jest-environment-node');

class CustomEnvironment extends NodeEnvironment {
  constructor(config, context) {
    super(config, context);
    this.testPath = context.testPath;
    this.docblockPragmas = context.docblockPragmas;
  }

  async setup() {
    await super.setup();
    await someSetupTasks(this.testPath);
    this.global.someGlobalObject = createGlobalObject();

    // Will trigger if docblock contains @my-custom-pragma my-pragma-value
    if (this.docblockPragmas['my-custom-pragma'] === 'my-pragma-value') {
      // ...
    }
  }

  async teardown() {
    this.global.someGlobalObject = destroyGlobalObject();
    await someTeardownTasks();
    await super.teardown();
  }

  runScript(script) {
    return super.runScript(script);
  }

  handleTestEvent(event, state) {
    if (event.name === 'test_start') {
      // ...
    }
  }
}

module.exports = CustomEnvironment;

// my-test-suite
let someGlobalObject;

beforeAll(() => {
  someGlobalObject = global.someGlobalObject;
});

`testEnvironmentOptions` [Object]

默认值：{}

将传递给testEnvironment. 相关选项取决于环境。例如，您可以覆盖提供给jsdom的选项，例如{userAgent: "Agent/007"}.

`testMatch` [array]

（默认[ "**/__tests__/**/*.[jt]s?(x)", "**/?(*.)+(spec|test).[jt]s?(x)" ]：）

Jest 用于检测测试文件的 glob 模式。默认情况下，它会查找文件夹内的、和文件.js，以及.jsx任何带有 or 后缀的文件（例如or ）。它还将查找名为or的文件。.ts``.tsx``__tests__``.test``.spec``Component.test.js``Component.spec.js``test.js``spec.js
有关您可以指定的模式的详细信息，请参阅micromatch包。
另请参阅[testRegexstring | array]，但请注意，您不能同时指定这两个选项。

`testPathIgnorePatterns` [array]

默认值︰["node_modules"]

在执行测试之前与所有测试路径匹配的正则表达式模式string array。如果测试路径匹配任何模式，它将被跳过。
这些模式string与完整路径匹配。使用<rootDir>string标记来包含项目根目录的路径，以防止它意外忽略可能具有不同根目录的不同环境中的所有文件。示例：["<rootDir>/build/", "<rootDir>/node_modules/"]。

`testRegex`[string | array]

默认： (/__tests__/.*|(\\.|/)(test|spec))\\.[jt]sx?$

Jest 用于检测测试文件的模式。默认情况下，它会查找文件夹内的、和文件.js，以及.jsx任何带有 or 后缀的文件（例如or ）。它还将查找名为or的文件。另请参阅[array]，但请注意，您不能同时指定这两个选项。.ts``.tsx``__tests__``.test``.spec``Component.test.js``Component.spec.js``test.js``spec.jstestMatch

以下是默认正则表达式的可视化：

├── __tests__
│   └── component.spec.js # test
│   └── anything # test
├── package.json # not test
├── foo.test.js # test
├── bar.spec.jsx # test
└── component.js # not test

注意：testRegex将尝试使用绝对文件路径检测测试文件，因此具有名称匹配的文件夹会将所有文件作为测试运行

`testResultsProcessor` [string]

默认值：undefined

此选项允许使用自定义结果处理器。该处理器必须是一个节点模块，它导出一个函数，该函数期望具有以下结构的Object作为第一个参数并返回它：

{
  "success": bool,
  "startTime": epoch,
  "numTotalTestSuites": number,
  "numPassedTestSuites": number,
  "numFailedTestSuites": number,
  "numRuntimeErrorTestSuites": number,
  "numTotalTests": number,
  "numPassedTests": number,
  "numFailedTests": number,
  "numPendingTests": number,
  "numTodoTests": number,
  "openHandles": Array<Error>,
  "testResults": [{
    "numFailingTests": number,
    "numPassingTests": number,
    "numPendingTests": number,
    "testResults": [{
      "title": string (message in it block),
      "status": "failed" | "pending" | "passed",
      "ancestorTitles": [string (message in describe blocks)],
      "failureMessages": [string],
      "numPassingAsserts": number,
      "location": {
        "column": number,
        "line": number
      }
    },
    ...
    ],
    "perfStats": {
      "start": epoch,
      "end": epoch
    },
    "testFilePath": absolute path to test file,
    "coverage": {}
  },
  ...
  ]
}

`testRunner` [string]

默认值︰jasmine2

此选项允许使用自定义测试运行器。默认值为 jasmine2。可以通过指定测试运行程序实现的路径来提供自定义测试运行程序。
测试运行器模块必须导出具有以下签名的函数：

function testRunner(
  config: Config,
  environment: Environment,
  runtime: Runtime,
  testPath: string,
): Promise<TestResult>;

可以在我们的默认jasmine2 测试运行程序包中找到此类功能的示例。

`testSequencer` [string]

默认： @jest/test-sequencer

此选项允许您使用自定义音序器而不是 Jest 的默认值。sort可以选择返回一个 Promise。

示例：

按字母顺序对测试路径进行排序。

const Sequencer = require('@jest/test-sequencer').default;

class CustomSequencer extends Sequencer {
  sort(tests) {
    // Test structure information
    // https://github.com/facebook/jest/blob/6b8b1404a1d9254e7d5d90a8934087a9c9899dab/packages/jest-runner/src/types.ts#L17-L21
    const copyTests = Array.from(tests);
    return copyTests.sort((testA, testB) => (testA.path > testB.path ? 1 : -1));
  }
}

module.exports = CustomSequencer;

`testURL` [string]

默认： http://localhost

此选项设置 jsdom 环境的 URL。它反映在诸如location.href.

`timers` [string]

默认值︰real

将此值设置为fake允许对诸如setTimeout. 当一段代码设置了我们不想在测试中等待的长时间超时时，假计时器很有用。

`transform`[Object<string，pathToTransformer | [pathToTransformer, Object]>]

默认值：undefined

从正则表达式到转换器路径的映射。转换器是一个为转换源文件提供同步功能的模块。例如，如果您希望能够在模块或测试中使用 node 尚不支持的新语言功能，您可以插入将未来版本的 JavaScript 编译为当前版本的众多编译器之一。示例：请参阅示例/打字稿示例或webpack 教程。

此类编译器的示例包括：

通天塔
打字稿
异步生成
要构建您自己的，请访问自定义变压器部分

您可以将配置传递给转换器{filePattern: ['path-to-transformer', {options}]}，例如，将 babel-jest 配置为非默认行为，{"\\.js$": ['babel-jest', {rootMode: "upward"}]}

注意：除非文件已更改，否则每个文件只运行一次转换器。--no-cache在开发转换器期间，运行 Jest以经常删除 Jest 的缓存可能很有用。

注意：如果您正在使用babel-jest转换器并想使用额外的代码预处理器，请记住，当“转换”以任何方式被覆盖时，babel-jest不再自动加载。如果你想用它来编译 JavaScript 代码，它必须被显式定义。参见babel-jest 插件

`transformIgnorePatterns` [array]

默认值︰["node_modules"]

在转换之前与所有源文件路径匹配的正则表达式模式string array。如果测试路径匹配任何模式，它将不会被转换。
这些模式string与完整路径匹配。使用<rootDir>string标记来包含项目根目录的路径，以防止它意外忽略可能具有不同根目录的不同环境中的所有文件。

示例：["<rootDir>/bower_components/", "<rootDir>/node_modules/"]。

有时会发生（尤其是在 React Native 或 TypeScript 项目中）第 3 方模块以未转译的形式发布。由于默认不转换里面的所有文件node_modules，所以 Jest 不会理解这些模块中的代码，从而导致语法错误。为了克服这个问题，您可以使用transformIgnorePatterns将此类模块列入白名单。你会在React Native Guide中找到这个用例的一个很好的例子。

`unmockedModulePathPatterns` [array]

默认值：[]

在模块加载器将自动为它们返回一个模拟之前，与所有模块匹配的正则表达式模式string array。如果模块的路径与此列表中的任何模式匹配，则模块加载器不会自动模拟它。
这对于一些常用的“实用程序”模块很有用，这些模块几乎总是几乎一直用作实现细节（如下划线/低破折号等）。通常最好的做法是让这个列表尽可能的小，并且总是在单独的测试中使用显式的jest.mock()/jest.unmock()调用。显式的每个测试设置对于测试的其他读者来说更容易推断测试将在其中运行的环境。
jest.mock()可以通过在测试文件顶部显式调用来覆盖单个测试中的此设置。

`verbose` [boolean]

默认值︰false

指示是否应在运行期间报告每个单独的测试。执行后，所有错误也仍会显示在底部。

`watchPathIgnorePatterns` [array]

默认值：[]

在监视模式下重新运行测试之前，与所有源文件路径匹配的 RegExp 模式array。如果文件路径与任何模式匹配，则在更新时不会触发重新运行测试。
这些模式与完整路径匹配。使用<rootDir>string标记来包含项目根目录的路径，以防止它意外忽略可能具有不同根目录的不同环境中的所有文件。示例：["<rootDir>/node_modules/"]。

`watchPlugins`[array<string | [string，Object]>]

默认值：[]

此选项允许您使用自定义手表插件。在此处阅读有关手表插件的更多信息。

手表插件的示例包括：

注意：watchPlugins属性值中的值可以省略jest-watch-包名的前缀。

`//` [string]

无默认值

此选项允许在package.json. 将注释文本作为此键的值包含在package.json.

示例：

{
  "name": "my-project",
  "jest": {
    "//": "Comment goes here",
    "verbose": true  }
}

jest

一、Jest基本概念

npm安装：

运行：

零配置：

基本方法：

二、Jest 配置

（一）配置位置

1. package.json

2. jest.config.js

3. 命令行（独有的option）

（二）配置项

1. testMatch

2. testRegex

3. testRnviroment

4. rootDir

5. moduleFileExtensions

一般配置：

三、Jest Matchers

1.相等断言

2.包含断言

3.逻辑断言

4.not

API列表

automock

bail[number| boolean]

browser [boolean]

cacheDirectory [string]

clearMocks [boolean]

collectCoverage [boolean]

collectCoverageFrom [array]

coverageDirectory [string]

coveragePathIgnorePatterns [array]

coverageProvider [string]

coverageReporters [array]

coverageThreshold [Object]

dependencyExtractor [string]

displayName [string，Object]

errorOnDeprecated [boolean]

extraGlobals [array]

forceCoverageMatch [array]

globals [Object]

globalSetup [string]

globalTeardown [string]

maxConcurrency [number]

moduleDirectories [array]

moduleFileExtensions [array]

moduleNameMapper [Object<string，string>]

modulePathIgnorePatterns [array]

modulePaths [array]

notify [boolean]

notifyMode [string]

Modes

preset [string]

prettierPath [string]

projects[array<string | ProjectConfig>]

reporters[array<moduleName | [moduleName ，options]>]

resetMocks [boolean]

resetModules [boolean]

resolver [string]

restoreMocks [boolean]

rootDir [string]

roots [array]

runner [string]

setupFiles [array]

setupFilesAfterEnv [array]

snapshotResolver [string]

snapshotSerializers [array]

testEnvironment [string]

testEnvironmentOptions [Object]

testMatch [array]

testPathIgnorePatterns [array]

testRegex[string | array]

testResultsProcessor [string]

testRunner [string]

testSequencer [string]

testURL [string]

timers [string]

transform[Object<string，pathToTransformer | [pathToTransformer, Object]>]

transformIgnorePatterns [array]

unmockedModulePathPatterns [array]

`automock`

`bail`[number| boolean]

`browser` [boolean]

`cacheDirectory` [string]

`clearMocks` [boolean]

`collectCoverage` [boolean]

`collectCoverageFrom` [array]

`coverageDirectory` [string]

`coveragePathIgnorePatterns` [array]

`coverageProvider` [string]

`coverageReporters` [array]

`coverageThreshold` [Object]

`dependencyExtractor` [string]

`displayName` [string，Object]

`errorOnDeprecated` [boolean]

`extraGlobals` [array]

`forceCoverageMatch` [array]

`globals` [Object]

`globalSetup` [string]

`globalTeardown` [string]

`maxConcurrency` [number]

`moduleDirectories` [array]

`moduleFileExtensions` [array]

`moduleNameMapper` [Object<string，string>]

`modulePathIgnorePatterns` [array]

`modulePaths` [array]

`notify` [boolean]

`notifyMode` [string]

`preset` [string]

`prettierPath` [string]

`projects`[array<string | ProjectConfig>]

`reporters`[array<moduleName | [moduleName ，options]>]

`resetMocks` [boolean]

`resetModules` [boolean]

`resolver` [string]

`restoreMocks` [boolean]

`rootDir` [string]

`roots` [array]

`runner` [string]

`setupFiles` [array]

`setupFilesAfterEnv` [array]

`snapshotResolver` [string]

`snapshotSerializers` [array]

`testEnvironment` [string]

`testEnvironmentOptions` [Object]

`testMatch` [array]

`testPathIgnorePatterns` [array]

`testRegex`[string | array]

`testResultsProcessor` [string]

`testRunner` [string]

`testSequencer` [string]

`testURL` [string]

`timers` [string]

`transform`[Object<string，pathToTransformer | [pathToTransformer, Object]>]

`transformIgnorePatterns` [array]

`unmockedModulePathPatterns` [array]

`verbose` [boolean]

`watchPathIgnorePatterns` [array]

`watchPlugins`[array<string | [string，Object]>]

`//` [string]