阅读(4.7k) 书签赞(0) 我要纠错

Jest 配置

2021-09-23 20:21 更新

Jest 的配置可以在package.json你项目的文件中定义，也可以通过jest.config.js文件或--config <path/to/file.js|cjs|mjs|json>选项来定义。如果你想用你的package.json来存储 Jest 的配置，"jest"密钥应该用在顶层，这样 Jest 就会知道如何找到你的设置：

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

或者通过 JavaScript：

// jest.config.js
//Sync object
module.exports = {
  verbose: true,
};
//Or async function
module.exports = async () => {
  return {
    verbose: true,
  };
};

请记住最后拿到的配置必须是可被 JSON 序列化的。

使用--config配置选项时，JSON 文件绝不能有"jest"键值︰

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

选项

这些选项可让你控制 Jest 在package.json文件中的行为。Jest 的理念是默认运行良好，但有时你只需要更多的配置能力。

默认值

你可以了解 Jest 的默认选项，以便在必要时扩展它们：

// jest.config.js
const {defaults} = require('jest-config');
module.exports = {
  // ...
  moduleFileExtensions: [...defaults.moduleFileExtensions, 'ts', 'tsx'],
  // ...
};

参考

automock [boolean]

默认值︰false

这个选项告诉 Jest 测试中所有导入的模块都应该自动模拟。测试中使用的所有模块都将具有替换实现，从而保持 API 表面。

示例：

// 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();
});

注意：当你进行手动模拟时，节点模块会自动模拟（例如：）__mocks__/lodash.js。更多信息在这里。

注意：fs默认情况下不会模拟核心模块，例如。它们可以被显式地模拟，例如jest.mock('fs').

bail[number | boolean]

默认值： 0

默认情况下，Jest 运行所有测试并在完成后将所有错误生成到控制台中。可以在此处使用保释配置选项让 Jest 在n失败后停止运行测试。将保释设置true为与将保释设置为相同1。

cacheDirectory [string]

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

Jest用来储存依赖信息缓存的目录。

Jest 尝试去扫描你的依赖树一次（前期）并且把依赖树缓存起来，其目的就是抹去某些在运行测试时需要进行的文件系统排序。这一配置选项让你可以自定义Jest将缓存数据储存在磁盘的那个位置。

clearMocks [boolean]

默认值︰false

在每次测试之前自动清除模拟调用和实例。相当于jest.clearAllMocks()每次测试前调用。这不会删除可能已提供的任何模拟实现。

collectCoverage [boolean]

默认值︰false

指出是否收集测试时的覆盖率信息。因为这些使用coverage collection语句对所有执行的文件进行了改造，所以可能会显著降低测试的速度。

collectCoverageFrom [array]

默认值：undefined

一组 glob 模式，指示应为其收集覆盖率信息的一组文件。如果文件与指定的 glob 模式匹配，即使此文件不存在测试并且测试套件中从不需要它，也会为其收集覆盖率信息。

示例：

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

这将收集项目中所有文件的覆盖信息rootDir，除了匹配**/node_modules/**或的文件**/vendor/**。

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

帮助：如果你看到覆盖输出，例如……

=============================== 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.

很可能你的 glob 模式与任何文件都不匹配。请参阅micromatch文档以确保你的 glob 兼容。

coverageDirectory [string]

默认值：undefined

Jest输出覆盖信息文件的目录。

coveragePathIgnorePatterns [array]

默认值︰["node_modules"]

在执行测试之前与所有文件路径匹配的正则表达式模式字符串数组。如果文件路径与任何模式匹配，则将跳过覆盖信息。

这些模式字符串与完整路径匹配。使用<rootDir>字符串标记包含项目根目录的路径，以防止它意外忽略不同环境中可能具有不同根目录的所有文件。例子：["<rootDir>/build/", "<rootDir>/node_modules/"]。

coverageProvider [string]

指示应使用哪个提供程序来检测代码以进行覆盖。允许的值为babel（默认）或v8。

请注意，使用v8被认为是实验性的。这使用了 V8 的内置代码覆盖率，而不是基于 Babel 的覆盖率。它没有经过很好的测试，而且在 Node.js 的最后几个版本中也得到了改进。使用最新版本的 node（在撰写本文时为 v14）会产生更好的结果。

coverageReporters [array]

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

Jest 在撰写报道报告时使用的记者姓名列表。可以使用任何伊斯坦布尔记者。

注意：设置此选项会覆盖默认值。添加"text"或"text-summary"查看控制台输出中的覆盖范围摘要。

注意：你可以使用元组形式将其他选项传递给 istanbul 报告器。例如：

["json", ["lcov", {"projectRoot": "../../"}]]

有关选项对象形状的其他信息，请参考类型定义中的CoverageReporterWithOptions类型。

coverageThreshold [object]

默认值：undefined

这将用于配置覆盖结果的最低阈值强制执行。阈值可以指定为global、glob以及目录或文件路径。没有如果达到阈值，Jest 执行测试时将失败。指定为正数的阈值被视为所需的最小百分比。指定为负数的阈值表示允许的未覆盖实体的最大数量。

例如，如果分支、行和函数覆盖率低于 80%，或者有超过 10 个未覆盖的语句，则使用以下配置 jest 将失败：

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

如果全局或路径与全局一起指定，则匹配路径的覆盖率数据将从总体覆盖率中减去，并且将独立应用阈值。通配符模式设置的阈值将应用到所匹配的所有文件上并单独计算。如果找不到路径指定的文件，则返回错误。

例如，基于下面的配置：

{
  ...
  "jest": {
    "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
      }
    }
  }
}

Jest 在以下情况下将失败：

该./src/components目录的分支或语句覆盖率低于 40%。
匹配./src/reducers/**/*.jsglob的文件之一的语句覆盖率低于 90%。
文件 ./src/api/very-important-module.js 的任意一种覆盖率低于 100%
所有剩下的文件的任意一种覆盖率总计低于 50% (根据 global)

dependencyExtractor [string]

默认值：undefined

此选项允许使用自定义依赖项提取器。它必须是一个节点模块，它导出一个带有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等），其中包含在代码中找到的依赖项。

该模块还可以包含一个getCacheKey函数来生成一个缓存键，以确定逻辑是否已经改变，任何依赖于它的缓存工件都应该被丢弃。

displayName [string，object]

默认值：undefined

允许在测试运行时在测试旁边打印标签。这在可能有许多 jest 配置文件的多项目存储库中变得更加有用。这直观地告诉了测试属于哪个项目。以下是示例有效值。

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

或

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

作为次要的选择，与该属性的对象name和color可以传递。这允许自定义配置 displayName 的背景颜色。displayName当其值为字符串时默认为白色。Jest 使用粉笔提供颜色。因此，jest 也支持 chalk 支持的所有颜色的有效选项。

errorOnDeprecated [boolean]

默认值︰false

使调用已弃用的 API 抛出有用的错误消息。有助于简化升级过程。

extraGlobals [array]

默认值：undefined

测试文件在vm内运行，这会减慢对全局上下文属性（例如Math）的调用。使用此选项，你可以指定要在 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
    }
  }
}

注意，如果你在这指定了一个全局引用值（例如，对象或者数组），之后在测试运行中有些代码改变了这个被引用的值，这个改动对于其他测试不会生效。此外，globals对象必须是json可序列化的，因此不能用于指定全局函数。为此，你应该使用setupfile。

globalSetup [string]

默认值：undefined

此选项允许使用自定义全局设置模块，该模块导出在所有测试套件之前触发一次的异步函数。该函数获取 Jest 的globalConfig对象作为参数。

注意：只有当你从该项目运行至少一个测试时，才会触发在项目中配置的全局设置模块（使用多项目运行器）。

注意：通过定义的任何全局变量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 的globalConfig对象作为参数。

注意：在项目中配置的全局拆卸模块（使用多项目运行器）只有在你从该项目运行至少一个测试时才会被触发。

注意：关于node_modulesas for 的转换的相同注意事项globalSetup适用于globalTeardown。

maxConcurrency [number]

默认： 5

使用test.concurrent. 一旦插槽被释放，任何超过此限制的测试都将排队并执行。

moduleDirectories [array]

默认值︰["node_modules"]

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

moduleFileExtensions [array]

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

你的模块使用的文件扩展名数组。如果你需要没有指定文件扩展名的模块，这些是 Jest 将按从左到右的顺序查找的扩展名。

我们建议将项目中最常用的扩展放在左侧，因此如果你使用的是 TypeScript，你可能需要考虑将“ts”和/或“tsx”移动到数组的开头。

moduleNameMapper [object>]

默认值︰null

从正则表达式到模块名称或模块名称数组的映射，允许使用单个模块提取资源，例如图像或样式。

映射到别名的模块在默认情况下是 unmock 的，无论是否启用 automocking。

如果要使用文件路径<rootDir>，请使用字符串标记来引用rootDir值。

此外，你可以使用编号的反向引用替换捕获的正则表达式组。

示例：

{
  "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"
    ]
  }
}

定义映射的顺序很重要。图案被一一检查，直到适合为止。应首先列出最具体的规则。对于模块名称数组也是如此。

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

modulePathIgnorePatterns [array]

默认值：[]

在模块加载器将这些路径视为“可见”之前，与所有模块路径匹配的正则表达式模式字符串数组。如果给定模块的路径与任何模式匹配，则它将无法require()在测试环境中使用。

这些模式字符串与完整路径匹配。使用<rootDir>字符串标记包含项目根目录的路径，以防止它意外忽略不同环境中可能具有不同根目录的所有文件。例子：["<rootDir>/build/"]。

modulePaths [array]

默认值：[]

设置NODE_PATHenv 变量的替代 APImodulePaths是解析模块时要搜索的其他位置的绝对路径数组。使用<rootDir>字符串标记包含项目根目录的路径。例子：["<rootDir>/app/"]。

notify [boolean]

默认值︰false

激活测试结果通知。

注意： Jest 使用node-notifier来显示桌面通知。在 Windows 上，它会在第一次使用时创建一个新的开始菜单条目，并且不显示通知。通知将在后续运行中正确显示

notifyMode [string]

默认： failure-change

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

模式

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

preset [string]

默认值：undefined

用作 Jest 配置基础的预设。预设应指向根目录为jest-preset.json或jest-preset.js文件的 npm 模块。

例如，此预设foo-bar/jest-preset.js将配置如下：

{
  "preset": "foo-bar"
}

预设也可能与文件系统路径有关。

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

prettierPath [string]

默认： 'prettier'

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

projects [array]

默认值：undefined

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

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

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

该项目的功能也可以用于运行多种配置或多亚军。为此，你可以传递一组配置对象。例如，要在同一个 Jest 调用中同时运行测试和 ESLint（通过jest-runner-eslint）：

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

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

reporters [array]

默认值：undefined

使用此配置选项将自定义报告器添加到 Jest。自定义报告器是一个实现onRunStart、onTestStart、onTestResult、onRunComplete方法的类，这些方法将在发生任何这些事件时调用。

如果指定了自定义报告器，默认的 Jest 报告器将被覆盖。要保留默认报告器，default可以作为模块名称传递。

这将覆盖默认记者：

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

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

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

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

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

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

示例记者：

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

有关方法和参数类型的完整列表，请参阅Reporter接口封装/笑话-记者/ src目录/ types.ts

resetMocks [boolean]

默认值︰false

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

resetModules [boolean]

默认值︰false

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

resolver [string]

默认值：undefined

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

{
  "basedir": string,
  "defaultResolver": "function(request, options)",
  "extensions": [string],
  "moduleDirectory": [string],
  "paths": [string],
  "packageFilter": "function(pkg, pkgdir)",
  "rootDir": [string]
}

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

注意：作为选项传递的 defaultResolver 是 Jest 默认解析器，这在你编写自定义解析器时可能很有用。它采用与你的自定义参数相同的参数，例如(request, options).

例如，如果要尊重 Browserify 的"browser"field，可以使用以下配置：

{
  ...
  "jest": {
    "resolver": "browser-resolve"
  }
}

通过组合defaultResolver，packageFilter我们可以实现一个package.json“预处理器”，它允许我们改变默认解析器解析模块的方式。例如，假设我们想要使用该字段（"module"如果它存在），否则回退到"main"：

{
  ...
  "jest": {
    "resolver": "my-module-resolve"
  }
}

// my-module-resolve package
module.exports = (request, options) => {
  // Call the defaultResolver, so we leverage its cache, error handling, etc.
  return options.defaultResolver(request, {
    ...options,
    // Use packageFilter to process parsed `package.json` before the resolution (see https://www.npmjs.com/package/resolve#resolveid-opts-cb)
    packageFilter: pkg => {
      return {
        ...pkg,
        // Alter the value of `main` before resolving the package
        main: pkg.module || pkg.main,
      };
    },
  });
};

restoreMocks [boolean]

默认值︰false

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

rootDir [string]

默认：包含你的玩笑目录的根目录配置文件或将package.json 或将pwd如果没有package.json被发现

Jest 应该扫描其中的测试和模块的根目录。如果你将 Jest 配置放在你的内部package.json并希望根目录成为你的存储库的根目录，则此配置参数的值将默认为package.json.

通常，你需要将其设置为'src'或'lib'，对应于代码在存储库中的存储位置。

请注意，'<rootDir>'在任何其他基于路径的配置设置中用作字符串标记将引用回此值。因此，例如，如果你希望setupFiles配置条目指向env-setup.js项目根目录下的文件，则可以将其值设置为["<rootDir>/env-setup.js"].

roots [array]

默认值︰["<rootDir>"]

Jest 应该用来搜索文件的目录路径列表。

有时你只希望 Jest 在单个子目录中进行搜索（例如，你的存储库中有一个src/目录），但阻止它访问存储库的其余部分。

注意：虽然rootDir主要用作在其他配置选项中重复使用的令牌，但被rootsJest 内部用于定位测试文件和源文件。这也适用于从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在环境中安装测试框架之前执行，此脚本文件为你提供了在环境中安装测试框架后立即运行某些代码的机会。

如果你路径相对于项目的根目录，请包含<rootDir>在路径字符串中，例如"<rootDir>/a-configs-folder".

例如，Jestjasmine通过对 jasmine API 进行猴子修补，为该工作提供了几个插件。如果你想添加更多的 jasmine 插件（或者如果你想要一些自定义的、项目范围的匹配器），你可以在这些模块中这样做。

注意：setupTestFrameworkScriptFile不赞成使用setupFilesAfterEnv.

setupFilesAfterEnvjest.config.js 中的示例数组：

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

示例jest.setup.js文件

jest.setTimeout(10000); // in milliseconds

slowTestThreshold [number]

默认： 5

测试被视为缓慢并在结果中报告的秒数。

snapshotResolver [string]

默认值：undefined

可以解析 test<->snapshot 路径的模块的路径。这个配置选项让你自定义 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 = {
  serialize(val, config, indentation, depth, refs, printer) {
    return 'Pretty foo: ' + printer(val.foo);
  },
  test(val) {
    return val && val.hasOwnProperty('foo');
  },
};

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

要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 配置中添加其路径。

可以在此处找到有关序列化程序 API 的更多信息。

testEnvironment [string]

默认值︰"jsdom"

将用于测试的测试环境。Jest 中的默认环境是通过jsdom的类似浏览器的环境。如果你正在构建节点服务，则可以使用该node选项来代替使用类似节点的环境。

通过@jest-environment在文件顶部添加一个docblock，你可以指定另一个用于该文件中所有测试的环境：

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

你可以创建自己的模块，用于设置测试环境。模块必须使用setup,teardown和runScript方法导出类。你还可以通过将变量分配给this.global对象来将变量从该模块传递到你的测试套件- 这将使它们在你的测试套件中作为全局变量可用。

该类可以选择公开一个异步handleTestEvent方法来绑定到由触发的事件jest-circus。通常情况下，jest-circus测试运行将暂停，直到一个承诺从返回handleTestEvent得到满足，除了未来事件：start_describe_definition，finish_describe_definition，add_hook，add_test或error（关于上行最新列表，你可以看看SyncEvent类型的类型定义）。这是由向后兼容性原因和process.on('unhandledRejection', callback)签名引起的，但对于大多数用例来说，这通常不是问题。

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

注意：TestEnvironment 是沙盒化的。每个测试套件将在他们自己的测试环境中触发设置/拆卸。

示例：

// 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);
  }
  async 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，.ts和.tsx里面的文件__tests__夹，以及带有后缀的任何文件.test或.spec（如Component.test.js或Component.spec.js）。它还会找到名为test.js或的文件spec.js。

有关你可以指定的模式的详细信息，请参阅micromatch包。

另见testRegex[字符串 | 大批]，但请注意，你不能同时指定这两个选项。

testPathIgnorePatterns [array]

默认值︰["node_modules"]

在执行测试之前与所有测试路径匹配的正则表达式模式字符串数组。如果测试路径匹配任何模式，它将被跳过。

这些模式字符串与完整路径匹配。使用<rootDir>字符串标记包含项目根目录的路径，以防止它意外忽略不同环境中可能具有不同根目录的所有文件。例子：["<rootDir>/build/", "<rootDir>/node_modules/"]。

testRegex[string | array]

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

Jest 用来检测测试文件的一个或多个模式。默认情况下，它会查找.js，.jsx，.ts和.tsx里面的文件__tests__夹，以及带有后缀的任何文件.test或.spec（如Component.test.js或Component.spec.js）。它还会找到名为test.js或的文件spec.js。另见testMatch[数组]，但请注意，你不能同时指定这两个选项。

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

├── __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

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

{
  "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(
  globalConfig: GlobalConfig,
  config: ProjectConfig,
  environment: Environment,
  runtime: Runtime,
  testPath: string,
): Promise<TestResult>;

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

testSequencer [string]

默认： @jest/test-sequencer

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

示例：

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

// testSequencer.js
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;

在你的 Jest 配置文件中使用它，如下所示：

{
  "testSequencer": "path/to/testSequencer.js"
}

testTimeout [number]

默认： 5000

默认测试超时时间单位为毫秒。

testURL [string]

默认： http://localhost

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

timers [string]

默认值︰real

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

如果值为modern，@sinonjs/fake-timers将用作实现而不是 Jest 自己的遗留实现。这将是 Jest 27 中默认的假实现。

transform [object]

默认： {"^.+\\.[jt]sx?$": "babel-jest"}

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

此类编译器的示例包括：

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

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

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

注意：当添加额外的代码转换器时，这将覆盖默认配置并且babel-jest不再自动加载。如果要使用它来编译 JavaScript 或 Typescript，则必须通过添加{"^.+\\.[jt]sx?$": "babel-jest"}到 transform 属性来显式定义它。查看babel-jest 插件

transformIgnorePatterns [array]

默认： ["/node_modules/", "\\.pnp\\.[^\\\/]+$"]

转换前与所有源文件路径匹配的正则表达式模式字符串数组。如果测试路径与任何模式匹配，则不会对其进行转换。

这些模式字符串与完整路径匹配。使用<rootDir>字符串标记包含项目根目录的路径，以防止它意外忽略不同环境中可能具有不同根目录的所有文件。

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

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

unmockedModulePathPatterns [array]

默认值：[]

在模块加载器将自动为它们返回模拟之前，与所有模块匹配的正则表达式模式字符串数组。如果模块的路径与此列表中的任何模式匹配，则模块加载器不会自动模拟它。

这对于一些几乎始终用作实现细节的常用“实用程序”模块很有用（例如下划线/低破折号等）。通常最好的做法是让这个列表尽可能小，并且在单独的测试中总是使用显式jest.mock()/jest.unmock()调用。对于测试的其他读者来说，明确的每个测试设置更容易推断测试将运行的环境。

通过jest.mock()在测试文件的顶部显式调用，可以在单个测试中覆盖此设置。

verbose [boolean]

默认值︰false

指示是否应在运行期间报告每个单独的测试。执行后，所有错误也仍将显示在底部。请注意，如果只有一个测试文件正在运行，它将默认为true.

watchPathIgnorePatterns [array]

默认值：[]

在监视模式下重新运行测试之前，与所有源文件路径匹配的 RegExp 模式数组。如果文件路径与任何模式匹配，则在更新时不会触发重新运行测试。

这些模式与完整路径匹配。使用<rootDir>字符串标记包含项目根目录的路径，以防止它意外忽略不同环境中可能具有不同根目录的所有文件。例子：["<rootDir>/node_modules/"]。

即使此处未指定任何内容，观察者也会忽略对任何隐藏文件和目录的更改，即以点 ( .)开头的文件和文件夹。

watchPlugins [array]

默认值：[]

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

手表插件的例子包括：

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

// [string]

无默认

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

示例：

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

以上内容是否对您有帮助：

← Jest 对象API

Jest CLI选项 →

写笔记

我要补充