跳至主要内容
版本：29.7

全局变量

在您的测试文件中，Jest 将这些方法和对象中的每一个都放入全局环境中。您无需进行任何要求或导入即可使用它们。但是，如果您更喜欢显式导入，您可以执行 import {describe, expect, test} from '@jest/globals'。

信息

本页面的 TypeScript 示例只有在您显式导入 Jest API 时才能按文档工作

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

有关如何使用 TypeScript 设置 Jest 的详细信息，请参阅 入门 指南。

方法​

参考​

afterAll(fn, timeout)​

在该文件中的所有测试都完成后运行一个函数。如果该函数返回一个 promise 或是一个生成器，Jest 会等待该 promise 解决后再继续。

可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待多长时间。默认超时时间为 5 秒。

这在您想要清理跨测试共享的一些全局设置状态时很有用。

例如

const globalDatabase = makeGlobalDatabase();

function cleanUpDatabase(db) {
  db.cleanUp();
}

afterAll(() => {
  cleanUpDatabase(globalDatabase);
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

这里 afterAll 确保在所有测试运行后调用 cleanUpDatabase。

如果 afterAll 在 describe 块中，它将在 describe 块结束时运行。

如果您想在所有测试之后而不是在所有测试之后运行一些清理，请改用 afterEach。

afterEach(fn, timeout)​

在该文件中的每个测试完成后运行一个函数。如果该函数返回一个 promise 或是一个生成器，Jest 会等待该 promise 解决后再继续。

可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待多长时间。默认超时时间为 5 秒。

这在您想要清理每个测试创建的一些临时状态时很有用。

例如

const globalDatabase = makeGlobalDatabase();

function cleanUpDatabase(db) {
  db.cleanUp();
}

afterEach(() => {
  cleanUpDatabase(globalDatabase);
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

这里 afterEach 确保在每个测试运行后调用 cleanUpDatabase。

如果 afterEach 在 describe 块中，它只会在该 describe 块中的测试之后运行。

如果您想只运行一次清理，在所有测试运行后，请改用 afterAll。

beforeAll(fn, timeout)​

在该文件中的任何测试运行之前运行一个函数。如果该函数返回一个 promise 或是一个生成器，Jest 会等待该 promise 解决后再运行测试。

可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待多长时间。默认超时时间为 5 秒。

这在您想要设置一些将被许多测试使用的全局状态时很有用。

例如

const globalDatabase = makeGlobalDatabase();

beforeAll(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

// Since we only set up the database once in this example, it's important
// that our tests don't modify it.
test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

这里 beforeAll 确保在测试运行之前设置数据库。如果设置是同步的，您可以在没有 beforeAll 的情况下执行此操作。关键是 Jest 会等待 promise 解决，因此您也可以进行异步设置。

如果 beforeAll 在 describe 块中，它将在 describe 块开始时运行。

如果您想在每个测试之前而不是在任何测试运行之前运行某些内容，请改用 beforeEach。

beforeEach(fn, timeout)​

在该文件中的每个测试运行之前运行一个函数。如果该函数返回一个 promise 或是一个生成器，Jest 会等待该 promise 解决后再运行测试。

可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待多长时间。默认超时时间为 5 秒。

这在您想要重置一些将被许多测试使用的全局状态时很有用。

例如

const globalDatabase = makeGlobalDatabase();

beforeEach(() => {
  // Clears the database and adds some testing data.
  // Jest will wait for this promise to resolve before running tests.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

test('can insert a thing', () => {
  return globalDatabase.insert('thing', makeThing(), response => {
    expect(response.success).toBeTruthy();
  });
});

这里 beforeEach 确保为每个测试重置数据库。

如果 beforeEach 在 describe 块中，它将为 describe 块中的每个测试运行。

如果您只需要运行一次设置代码，在任何测试运行之前，请改用 beforeAll。

describe(name, fn)​

describe(name, fn) 创建一个块，将几个相关的测试分组在一起。例如，如果您有一个 myBeverage 对象，它应该美味但不能酸，您可以使用以下方法对其进行测试

const myBeverage = {
  delicious: true,
  sour: false,
};

describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

这不是必需的 - 您可以直接在顶层编写 test 块。但是，如果您希望将测试组织成组，这会很方便。

如果您有测试的层次结构，您也可以嵌套 describe 块

const binaryStringToNumber = binString => {
  if (!/^[01]+$/.test(binString)) {
    throw new CustomError('Not a binary number.');
  }

  return parseInt(binString, 2);
};

describe('binaryStringToNumber', () => {
  describe('given an invalid binary string', () => {
    test('composed of non-numbers throws CustomError', () => {
      expect(() => binaryStringToNumber('abc')).toThrow(CustomError);
    });

    test('with extra whitespace throws CustomError', () => {
      expect(() => binaryStringToNumber('  100')).toThrow(CustomError);
    });
  });

  describe('given a valid binary string', () => {
    test('returns the correct number', () => {
      expect(binaryStringToNumber('100')).toBe(4);
    });
  });
});

describe.each(table)(name, fn, timeout)​

如果您一直使用不同的数据重复相同的测试套件，请使用 describe.each。describe.each 允许您编写一次测试套件并传入数据。

describe.each 可用于两种 API

1. describe.each(table)(name, fn, timeout)​

  • table: Array，包含传递给每行 fn 的参数的数组。如果您传入一个 1D 的基本类型数组，它会在内部映射到一个表格，即 [1, 2, 3] -> [[1], [2], [3]]。

  • name: String，测试套件的标题。

    • 通过使用 printf 格式化 按位置注入参数来生成唯一的测试标题
      • %p - pretty-format.
      • %s- 字符串。
      • %d- 数字。
      • %i - 整数。
      • %f - 浮点值。
      • %j - JSON。
      • %o - 对象。
      • %# - 测试用例的索引。
      • %% - 单个百分号 ('%')。这不会消耗参数。
    • 或者通过使用 $variable 注入测试用例对象的属性来生成唯一的测试标题
      • 要注入嵌套对象的值，您可以提供一个 keyPath，即 $variable.path.to.value
      • 您可以使用 $# 来注入测试用例的索引
      • 您不能将 $variable 与 printf 格式化一起使用，除了 %%

  • fn: Function，要运行的测试套件，这是将接收每行参数作为函数参数的函数。

  • 可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待每行多长时间。默认超时时间为 5 秒。

示例

describe.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});
describe.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

2. describe.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal
    • 第一行变量名称列标题，用 | 分隔
    • 一个或多个后续数据行，作为使用 ${value} 语法的模板文字表达式提供。
  • name: String，测试套件的标题，使用 $variable 从标记的模板表达式中将测试数据注入套件标题，并使用 $# 表示行的索引。
    • 要注入嵌套对象的值，您可以提供一个 keyPath，即 $variable.path.to.value
  • fn: Function，要运行的测试套件，这是将接收测试数据对象的函数。
  • 可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待每行多长时间。默认超时时间为 5 秒。

示例

describe.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('$a + $b', ({a, b, expected}) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });

  test(`returned value not be greater than ${expected}`, () => {
    expect(a + b).not.toBeGreaterThan(expected);
  });

  test(`returned value not be less than ${expected}`, () => {
    expect(a + b).not.toBeLessThan(expected);
  });
});

describe.only(name, fn)​

也称为：fdescribe(name, fn)

如果您只想运行一个 describe 块，可以使用 describe.only

describe.only('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

describe('my other beverage', () => {
  // ... will be skipped
});

describe.only.each(table)(name, fn)​

也称为：fdescribe.each(table)(name, fn) 和 fdescribe.each`table`(name, fn)

如果您只想运行数据驱动测试的特定测试套件，请使用 describe.only.each。

describe.only.each 可用于两种 API

describe.only.each(table)(name, fn)​

describe.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected);
  });
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.only.each`table`(name, fn)​

describe.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  test('passes', () => {
    expect(a + b).toBe(expected);
  });
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.skip(name, fn)​

也称为：xdescribe(name, fn)

如果您不想运行特定 describe 块的测试，可以使用 describe.skip

describe('my beverage', () => {
  test('is delicious', () => {
    expect(myBeverage.delicious).toBeTruthy();
  });

  test('is not sour', () => {
    expect(myBeverage.sour).toBeFalsy();
  });
});

describe.skip('my other beverage', () => {
  // ... will be skipped
});

使用 describe.skip 通常是临时注释掉一组测试的更简洁的替代方法。请注意，describe 块仍将运行。如果您有一些也应该跳过的设置，请在 beforeAll 或 beforeEach 块中执行。

describe.skip.each(table)(name, fn)​

也称为：xdescribe.each(table)(name, fn) 和 xdescribe.each`table`(name, fn)

如果您想停止运行一组数据驱动测试，请使用 describe.skip.each。

describe.skip.each 可用于两种 API

describe.skip.each(table)(name, fn)​

describe.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  test(`returns ${expected}`, () => {
    expect(a + b).toBe(expected); // will not be run
  });
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.skip.each`table`(name, fn)​

describe.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  test('will not be run', () => {
    expect(a + b).toBe(expected); // will not be run
  });
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test(name, fn, timeout)​

也称为：it(name, fn, timeout)

测试文件中只需要包含一个test方法来运行测试。例如，假设有一个函数inchesOfRain()应该返回零。整个测试可以是

test('did not rain', () => {
  expect(inchesOfRain()).toBe(0);
});

第一个参数是测试名称；第二个参数是一个包含要测试的期望的函数。第三个参数（可选）是timeout（以毫秒为单位），用于指定在中止之前等待多长时间。默认超时时间为 5 秒。

如果从test返回一个**Promise**，Jest 将等待 Promise 解决，然后再让测试完成。例如，假设fetchBeverageList()返回一个 Promise，该 Promise 应该解析为一个包含lemon的列表。你可以用以下方法测试它

test('has lemon in it', () => {
  return fetchBeverageList().then(list => {
    expect(list).toContain('lemon');
  });
});

即使对test的调用会立即返回，但测试要等到 Promise 解决才会完成。有关更多详细信息，请参阅测试异步代码页面。

提示

如果你**为测试函数提供一个参数**，Jest 也会等待，这个参数通常称为done。当你想测试回调时，这可能很方便。

test.concurrent(name, fn, timeout)​

别名：it.concurrent(name, fn, timeout)

注意

test.concurrent被认为是实验性的 - 请参阅这里了解有关缺失功能和其他问题的详细信息。

如果你想让测试并发运行，请使用test.concurrent。

第一个参数是测试名称；第二个参数是一个包含要测试的期望的异步函数。第三个参数（可选）是timeout（以毫秒为单位），用于指定在中止之前等待多长时间。默认超时时间为 5 秒。

test.concurrent('addition of 2 numbers', async () => {
  expect(5 + 3).toBe(8);
});

test.concurrent('subtraction 2 numbers', async () => {
  expect(5 - 3).toBe(2);
});
提示

使用maxConcurrency配置选项来防止 Jest 同时执行超过指定数量的测试。

test.concurrent.each(table)(name, fn, timeout)​

别名：it.concurrent.each(table)(name, fn, timeout)

如果你一直重复使用相同的数据进行相同的测试，请使用test.concurrent.each。test.each允许你只编写一次测试并传入数据，所有测试都是异步运行的。

test.concurrent.each有两种 API 可用

1. test.concurrent.each(table)(name, fn, timeout)​

  • table: Array，包含传递给每个测试fn的每个行的参数。如果你传入一个原始值的 1D 数组，它将在内部映射到一个表格，即[1, 2, 3] -> [[1], [2], [3]]
  • name: String，测试块的标题。
    • 通过使用 printf 格式化 按位置注入参数来生成唯一的测试标题
      • %p - pretty-format.
      • %s- 字符串。
      • %d- 数字。
      • %i - 整数。
      • %f - 浮点值。
      • %j - JSON。
      • %o - 对象。
      • %# - 测试用例的索引。
      • %% - 单个百分号 ('%')。这不会消耗参数。
  • fn: Function，要运行的测试，这是将接收每行参数作为函数参数的函数，**这必须是一个异步函数**。
  • 可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待每行多长时间。默认超时时间为 5 秒。

示例

test.concurrent.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

2. test.concurrent.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal
    • 第一行变量名称列标题，用 | 分隔
    • 一个或多个后续数据行，作为使用 ${value} 语法的模板文字表达式提供。
  • name: String，测试的标题，使用$variable从标记的模板表达式中将测试数据注入测试标题。
    • 要注入嵌套对象的值，您可以提供一个 keyPath，即 $variable.path.to.value
  • fn: Function，要运行的测试，这是将接收测试数据对象的函数，**这必须是一个异步函数**。
  • 可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待每行多长时间。默认超时时间为 5 秒。

示例

test.concurrent.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.concurrent.only.each(table)(name, fn)​

别名：it.concurrent.only.each(table)(name, fn)

如果你只想并发运行特定测试的不同测试数据，请使用test.concurrent.only.each。

test.concurrent.only.each有两种 API 可用

test.concurrent.only.each(table)(name, fn)​

test.concurrent.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)​

test.concurrent.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.concurrent.skip.each(table)(name, fn)​

别名：it.concurrent.skip.each(table)(name, fn)

如果你想停止运行一组异步数据驱动测试，请使用test.concurrent.skip.each。

test.concurrent.skip.each有两种 API 可用

test.concurrent.skip.each(table)(name, fn)​

test.concurrent.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.concurrent.skip.each`table`(name, fn)​

test.concurrent.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.each(table)(name, fn, timeout)​

别名：it.each(table)(name, fn) 和 it.each`table`(name, fn)

如果你一直重复使用相同的数据进行相同的测试，请使用test.each。test.each允许你只编写一次测试并传入数据。

test.each有两种 API 可用

1. test.each(table)(name, fn, timeout)​

  • table: Array，包含传递给每个测试fn的每个行的参数。如果你传入一个原始值的 1D 数组，它将在内部映射到一个表格，即[1, 2, 3] -> [[1], [2], [3]]
  • name: String，测试块的标题。
    • 通过使用 printf 格式化 按位置注入参数来生成唯一的测试标题
      • %p - pretty-format.
      • %s- 字符串。
      • %d- 数字。
      • %i - 整数。
      • %f - 浮点值。
      • %j - JSON。
      • %o - 对象。
      • %# - 测试用例的索引。
      • %% - 单个百分号 ('%')。这不会消耗参数。
    • 或者通过使用 $variable 注入测试用例对象的属性来生成唯一的测试标题
      • 要注入嵌套对象的值，您可以提供一个 keyPath，即 $variable.path.to.value
      • 您可以使用 $# 来注入测试用例的索引
      • 您不能将 $variable 与 printf 格式化一起使用，除了 %%
  • fn: Function，要运行的测试，这是将接收每行参数作为函数参数的函数。
  • 可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待每行多长时间。默认超时时间为 5 秒。

示例

test.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});
test.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

2. test.each`table`(name, fn, timeout)​

  • table: Tagged Template Literal
    • 第一行变量名称列标题，用 | 分隔
    • 一个或多个后续数据行，作为使用 ${value} 语法的模板文字表达式提供。
  • name: String，测试的标题，使用$variable从标记的模板表达式中将测试数据注入测试标题。
    • 要注入嵌套对象的值，您可以提供一个 keyPath，即 $variable.path.to.value
  • fn: Function，要运行的测试，这是将接收测试数据对象的函数。
  • 可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待每行多长时间。默认超时时间为 5 秒。

示例

test.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.failing(name, fn, timeout)​

别名：it.failing(name, fn, timeout)

注意

这仅适用于默认的jest-circus运行器。

当编写测试并期望测试失败时，请使用test.failing。这些测试的行为与正常测试相反。如果failing测试抛出任何错误，则它将通过。如果它没有抛出错误，它将失败。

提示

你可以使用这种类型的测试，例如，当以 BDD 方式编写代码时。在这种情况下，测试在通过之前不会显示为失败。然后，你可以简单地删除failing修饰符以使其通过。

这也可以是为项目贡献失败测试的一种好方法，即使你不知道如何修复错误。

示例

test.failing('it is not equal', () => {
  expect(5).toBe(6); // this test will pass
});

test.failing('it is equal', () => {
  expect(10).toBe(10); // this test will fail
});

test.failing.each(name, fn, timeout)​

别名：it.failing.each(table)(name, fn) 和 it.failing.each`table`(name, fn)

注意

这仅适用于默认的jest-circus运行器。

你还可以通过在failing之后添加each来一次运行多个测试。

示例

test.failing.each([
  {a: 1, b: 1, expected: 2},
  {a: 1, b: 2, expected: 3},
  {a: 2, b: 1, expected: 3},
])('.add($a, $b)', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test.only.failing(name, fn, timeout)​

别名：it.only.failing(name, fn, timeout)，fit.failing(name, fn, timeout)

注意

这仅适用于默认的jest-circus运行器。

如果你只想运行特定的失败测试，请使用test.only.failing。

test.skip.failing(name, fn, timeout)​

别名：it.skip.failing(name, fn, timeout)，xit.failing(name, fn, timeout)，xtest.failing(name, fn, timeout)

注意

这仅适用于默认的jest-circus运行器。

如果你想跳过运行特定的失败测试，请使用test.skip.failing。

test.only(name, fn, timeout)​

别名：it.only(name, fn, timeout)，和 fit(name, fn, timeout)

当你调试一个大型测试文件时，你通常只想运行一部分测试。你可以使用.only来指定要运行的测试文件中的哪些测试。

可选地，您可以提供一个 timeout（以毫秒为单位）来指定在中止之前等待多长时间。默认超时时间为 5 秒。

例如，假设你有以下测试

test.only('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

由于使用test.only运行，因此该测试文件中只有“it is raining”测试会运行。

通常情况下，你不会将使用test.only检查的代码签入源代码控制 - 你会将其用于调试，并在修复了损坏的测试后将其删除。

test.only.each(table)(name, fn)​

别名：it.only.each(table)(name, fn)，fit.each(table)(name, fn)，it.only.each`table`(name, fn) 和 fit.each`table`(name, fn)

如果你只想运行特定测试的不同测试数据，请使用test.only.each。

test.only.each有两种 API 可用

test.only.each(table)(name, fn)​

test.only.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.only.each`table`(name, fn)​

test.only.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

test('will not be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.skip(name, fn)​

别名：it.skip(name, fn)，xit(name, fn)，和 xtest(name, fn)

当你维护一个大型代码库时，你可能会发现某些测试由于某种原因暂时无法运行。如果你想跳过运行此测试，但又不想删除此代码，可以使用test.skip来指定要跳过的某些测试。

例如，假设你有以下测试

test('it is raining', () => {
  expect(inchesOfRain()).toBeGreaterThan(0);
});

test.skip('it is not snowing', () => {
  expect(inchesOfSnow()).toBe(0);
});

由于另一个测试使用test.skip运行，因此只有“it is raining”测试会运行。

你可以注释掉测试，但使用test.skip通常更好，因为它会保留缩进和语法高亮。

test.skip.each(table)(name, fn)​

别名：it.skip.each(table)(name, fn)，xit.each(table)(name, fn)，xtest.each(table)(name, fn)，it.skip.each`table`(name, fn)，xit.each`table`(name, fn) 和 xtest.each`table`(name, fn)

如果你想停止运行一组数据驱动测试，请使用test.skip.each。

test.skip.each有两种 API 可用

test.skip.each(table)(name, fn)​

test.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (a, b, expected) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.skip.each`table`(name, fn)​

test.skip.each`
  a    | b    | expected
  ${1} | ${1} | ${2}
  ${1} | ${2} | ${3}
  ${2} | ${1} | ${3}
`('returns $expected when $a is added to $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be run
});

test('will be run', () => {
  expect(1 / 0).toBe(Infinity);
});

test.todo(name)​

也称为别名：it.todo(name)

当你计划编写测试时，使用 test.todo。这些测试将在最终的摘要输出中突出显示，以便你了解还有多少测试需要编写。

const add = (a, b) => a + b;

test.todo('add should be associative');
提示

如果你传递一个测试回调函数给 test.todo，它将抛出错误。如果你已经实现了测试，但不想运行它，请使用 test.skip。

TypeScript 使用​

信息

本页面的 TypeScript 示例只有在您显式导入 Jest API 时才能按文档工作

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

有关如何使用 TypeScript 设置 Jest 的详细信息，请参阅 入门 指南。

.each​

.each 修饰符提供了几种不同的方法来定义测试用例表。一些 API 在传递给 describe 或 test 回调函数的参数类型推断方面存在一些注意事项。让我们看看它们中的每一个。

注意

为了简单起见，示例中选择了 test.each，但在所有可以使用 .each 修饰符的地方，类型推断都是相同的：describe.each、test.concurrent.only.each、test.skip.each 等。

对象数组​

对象数组 API 最冗长，但它使类型推断成为一项轻松的任务。table 可以内联

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

test.each([
  {name: 'a', path: 'path/to/a', count: 1, write: true},
  {name: 'b', path: 'path/to/b', count: 3},
])('inline table', ({name, path, count, write}) => {
  // arguments are typed as expected, e.g. `write: boolean | undefined`
});

或者作为变量单独声明

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

const table = [
  {a: 1, b: 2, expected: 'three', extra: true},
  {a: 3, b: 4, expected: 'seven', extra: false},
  {a: 5, b: 6, expected: 'eleven'},
];

test.each(table)('table as a variable', ({a, b, expected, extra}) => {
  // again everything is typed as expected, e.g. `extra: boolean | undefined`
});

数组数组​

数组数组样式将与内联表格一起顺利工作

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

test.each([
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
])('inline table example', (a, b, expected, extra) => {
  // arguments are typed as expected, e.g. `extra: boolean | undefined`
});

但是，如果表格被声明为单独的变量，则必须将其类型化为元组数组以进行正确的类型推断（只有当一行中的所有元素都是相同类型时，才不需要这样做）。

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

const table: Array<[number, number, string, boolean?]> = [
  [1, 2, 'three', true],
  [3, 4, 'seven', false],
  [5, 6, 'eleven'],
];

test.each(table)('table as a variable example', (a, b, expected, extra) => {
  // without the annotation types are incorrect, e.g. `a: number | string | boolean`
});

模板字面量​

如果所有值都是相同类型，则模板字面量 API 将正确地对参数进行类型化

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

test.each`
  a    | b    | expected
  ${1} | ${2} | ${3}
  ${3} | ${4} | ${7}
  ${5} | ${6} | ${11}
`('template literal example', ({a, b, expected}) => {
  // all arguments are of type `number`
});

否则，它将需要一个泛型类型参数

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

test.each<{a: number; b: number; expected: string; extra?: boolean}>`
  a    | b    | expected    | extra
  ${1} | ${2} | ${'three'}  | ${true}
  ${3} | ${4} | ${'seven'}  | ${false}
  ${5} | ${6} | ${'eleven'}
`('template literal example', ({a, b, expected, extra}) => {
  // without the generic argument in this case types would default to `unknown`
});
编辑此页面
上次更新于 由 Simen Bekkhus 更新