Jest 全局API

2021-09-18 20:46 更新

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

方法

参考

afterAll(fn, timeout)

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

或者，可以提供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)

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

或者，可以提供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)

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

或者，可以提供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 确保数据库设置运行测试之前。如果安装程序是同步的，那么你可以不必事先进行设置。关键是Jest将等待承诺解决，所以你也可以进行异步设置。

如果beforeAll在describe块内，则它将在 describe 块的开头运行。

如果要在每次测试之前运行某些操作，而不是在任何测试运行之前运行，请改用beforeEach。

beforeEach(fn, timeout)

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

或者，可以提供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')).toThrowError(CustomError);
    });
    test('with extra whitespace throws CustomError', () => {
      expect(() => binaryStringToNumber('  100')).toThrowError(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: Arrayof Arrays 的参数被传递到fn每一行。

○ 注意如果你传入一个一维基元数组，它在内部将被映射到一个表，即[1, 2, 3] -> [[1], [2], [3]]

name：String测试套件的标题。

○ 通过位置注入带有printf格式的参数来生成唯一的测试标题：

■ %p- pertty-format。

■ %s- String。

■ %d- Number。

■ %i - Integer。

■ %f - Float。

■ %j - JSON。

■ %o - Object。

■ %# - 测试用例的索引。

■ %%- 单个百分号 ('%')。这不消耗参数。

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

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.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 ran', () => {
  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 $b', ({a, b, expected}) => {
  test('passes', () => {
    expect(a + b).toBe(expected);
  });
});
test('will not be ran', () => {
  expect(1 / 0).toBe(Infinity);
});

describe.skip(name, fn)

还有别名：xdescribe(name, fn)

如果不想运行特定的描述块，可以使用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.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 ran
  });
});
test('will be ran', () => {
  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 $b', ({a, b, expected}) => {
  test('will not be ran', () => {
    expect(a + b).toBe(expected); // will not be ran
  });
});
test('will be ran', () => {
  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，Jest 将等待承诺解决，然后让测试完成。如果你向通常调用的测试函数提供参数， Jest 也会等待done。当你想测试回调时，这可能会很方便。在此处查看如何测试异步代码。

例如，假设fetchBeverageList()返回一个应该解析为其中包含的列表的承诺lemon。可以使用以下方法进行测试：

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

即使对test的调用将立即返回，测试还没有完成，直到承诺也解决。

test.concurrent(name, fn, timeout)

同样在别名下： it.concurrent(name, fn, timeout)

如果希望测试同时运行，请使用test.concurrent。

注意：test.concurrent被认为是实验性的 - 请参阅 [此处]) https://github.com/facebook/jest/labels/Area%3A%20Concurrent ) 了解有关缺失功能和其他问题的详细信息

第一个参数是测试名称；第二个参数是一个包含要测试的期望的异步函数。第三个参数（可选）是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: Arrayof 带有传递到fn每一行测试中的参数的数组。

○ 注意如果你传入一个一维基元数组，它在内部将被映射到一个表，即[1, 2, 3] -> [[1], [2], [3]]

name:String测试块的标题。

○ 通过位置注入带有printf格式的参数来生成唯一的测试标题：

■ %p- Pretty-format。

■ %s- String。

■ %d- Number。

■ %i - Integer。

■ %f - Float。

■ %j - JSON。

■ %o - Object。

■ %# - 测试用例的索引。

■ %%- 单个百分号 ('%')。这不消耗参数。

fn：Function要运行的测试，这是将接收每一行中的参数作为函数参数的函数，这必须是一个异步函数。
或者，可以提供timeout（以毫秒为单位）用于指定在中止之前等待每一行的时间。注意：默认超时为 5 秒。

示例：

test.concurrent.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', (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 $b', ({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 ran', () => {
  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 $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});
test('will not be ran', () => {
  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 ran
});
test('will be ran', () => {
  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 $b', async ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be ran
});
test('will be ran', () => {
  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: Arrayof 带有传递到fn每一行测试中的参数的数组。

○ 注意如果你传入一个一维基元数组，它在内部将被映射到一个表，即[1, 2, 3] -> [[1], [2], [3]]

name:String测试块的标题。

○ 通过位置注入带有printf格式的参数来生成唯一的测试标题：

■ %p- Pretty-format。

■ %s- String。

■ %d- Number。

■ %i - Integer。

■ %f- Float。

■ %j - JSON。

■ %o - Object。

■ %# - 测试用例的索引。

■ %%- 单个百分号 ('%')。这不消耗参数。

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

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 $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});

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

只有“it is raining”测试会在该测试文件中运行，因为它使用test.only.

通常，不会使用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 ran', () => {
  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 $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected);
});
test('will not be ran', () => {
  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);
});

只有“it is raining”测试才会运行，因为另一个测试是使用test.skip。

可以将测试注释掉，但使用起来通常会更好一些，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 ran
});
test('will be ran', () => {
  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 $b', ({a, b, expected}) => {
  expect(a + b).toBe(expected); // will not be ran
});
test('will be ran', () => {
  expect(1 / 0).toBe(Infinity);
});

test.todo(name)

同样在别名下： it.todo(name)

使用test.todo当你在编写测试计划。这些测试将在最后的摘要输出中突出显示，以便您知道还需要执行多少测试。

注意：如果你提供测试回调函数，test.todo则将引发错误。如果已经实施了测试并且它已损坏并且你不希望它运行，那么请test.skip改用。

API

name:String测试计划的标题。

示例：

const add = (a, b) => a + b;
test.todo('add should be associative');

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

← Jest 测试Web框架

Jest expect API →

写笔记

我要补充

Jest 全局API

方法

参考

​afterAll(fn, timeout)​

​afterEach(fn, timeout)​

​beforeAll(fn, timeout)​

​beforeEach(fn, timeout)​

​describe(name, fn)​

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

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

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

​describe.only(name, fn)​

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

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

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

​describe.skip(name, fn)​

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

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

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

​test(name, fn, timeout)​

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

​test.skip(name, fn)​

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

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

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

​test.todo(name)​

API

afterAll(fn, timeout)

afterEach(fn, timeout)

beforeAll(fn, timeout)

beforeEach(fn, timeout)

describe(name, fn)

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

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

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

describe.only(name, fn)

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

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

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

describe.skip(name, fn)

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

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

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

test(name, fn, timeout)

test.concurrent(name, fn, timeout)

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

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

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

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

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

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

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

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

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

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

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

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

test.only(name, fn, timeout)

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

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

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

test.skip(name, fn)

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

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

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

test.todo(name)