Version: 27.2

全局设定

In your test files, Jest puts each of these methods and objects into the global environment. You don’t have to require or import anything to use them. In your test files, Jest puts each of these methods and objects into the global environment. You don’t have to require or import anything to use them. However, if you prefer explicit imports, you can do import {describe, expect, test} from '@jest/globals'.

方法

• afterAll(fn, timeout)
• afterEach(fn, timeout)
• beforeAll(fn, timeout)
• beforeEach(fn, timeout)
• describe(name, fn)
• describe.each(table)(name, fn, timeout)
• describe.only(name, fn)
• describe.only.each(table)(name, fn)
• describe.skip(name, fn)
• describe.skip.each(table)(name, fn)
• test(name, fn, timeout)
• 1. test.concurrent(name, fn, timeout)
• 1. test.concurrent.each(table)(name, fn, timeout)
• test.concurrent.only.each(table)(name, fn)
• test.concurrent.skip.each(table)(name, fn)
• 1. test.each(table)(name, fn, timeout)
• 1. test.only(name, fn, timeout)
• test.only.each(table)(name, fn)
• test.skip(name, fn)
• test.skip.each(table)(name, fn)
• test.todo(name)

Reference

afterAll(fn, timeout)

Runs a function after all the tests in this file have completed. If the function returns a promise or is a generator, Jest waits for that promise to resolve before continuing.

Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

例如：

例如：

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 是在 describe 块的内部，它运行在 describe 块结尾。

如果你想要在每个测试后运行一些清理，请使用 afterEach。

Runs a function after each one of the tests in this file completes. If the function returns a promise or is a generator, Jest waits for that promise to resolve before continuing.

afterEach(fn, timeout)

Runs a function after each one of the tests in this file completes. If the function returns a promise or is a generator, Jest waits for that promise to resolve before continuing.

Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

例如：

例如：

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 是在 describe 块的内部，它运行在 describe 块结尾。

如果你想要一些清理只运行一次，在所有测试运行后，使用 afterAll 。

Runs a function before any of the tests in this file run. If the function returns a promise or is a generator, Jest waits for that promise to resolve before running tests.

beforeAll(fn, timeout)

Runs a function before any of the tests in this file run. If the function returns a promise or is a generator, Jest waits for that promise to resolve before running tests.

Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

例如：

例如：

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);
  });
});
  // Jest will wait for this promise to resolve before running tests.
  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();
  });
});

在这里 beforeAll 确保数据库设置运行测试之前。 If setup was synchronous, you could do this without beforeAll. 关键是Jest将等待承诺解决，所以您也可以进行异步设置。 关键是Jest将等待承诺解决，所以您也可以进行异步设置。

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

Runs a function before each of the tests in this file runs. If the function returns a promise or is a generator, Jest waits for that promise to resolve before running the test.

beforeEach(fn, timeout)

Runs a function before each of the tests in this file runs. Runs a function after all the tests in this file have completed. If the function returns a promise or is a generator, Jest waits for that promise to resolve before continuing.

Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

例如：

例如：

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在describe块内，则它将在 describe 块中为每个测试运行。

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

describe(name, fn) creates a block that groups together several related tests. 例如，如果您有一个myBeverage对象，该对象应该是美味但不酸，您可以通过以下方式测试：

describe(name, fn)

describe(name, fn) creates a block that groups together several related tests. 例如，如果您有一个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();
  });
});

This isn’t required - you can write the test blocks directly at the top level. But this can be handy if you prefer your tests to be organized into groups. But this can be handy if you prefer your tests to be organized into groups.

You can also nest describe blocks if you have a hierarchy of tests:

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)

Use describe.each if you keep duplicating the same test suites with different data. describe.each allows you to write the test suite once and pass data in. describe.each allows you to write the test suite once and pass data in.

describe.each is available with two APIs:

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

• table: 数组 of Arrays with the arguments that are passed into the fn for each row.
  • Note If you pass in a 1D array of primitives, internally it will be mapped to a table i.e. [1, 2, 3] -> [[1], [2], [3]]
• name: 字符串 the title of the test suite.
  • Generate unique test titles by positionally injecting parameters with printf formatting:
    • %p - pretty-format.
    • %s- String.
    • %d- Number.
    • %i - Integer.
    • %f - Floating point value.
    • %j - JSON.
    • %o - Object.
    • %# - Index of the test case.
    • %% - single percent sign (‘%’). This does not consume an argument.
  • Or generate unique test titles by injecting properties of test case object with $variable
    • To inject nested object values use you can supply a keyPath i.e. $variable.path.to.value
    • You can use $# to inject the index of the test case
    • You cannot use $variable with the printf formatting except for %%
• fn: Function the suite of tests to be ran, this is the function that will receive the parameters in each row as function arguments.
• Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

Example:

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. 2. describe.each`table`(name, fn, timeout)

• table: Tagged Template Literal
  • First row of variable name column headings separated with |
  • One or more subsequent rows of data supplied as template literal expressions using ${value} syntax.
• name: String the title of the test suite, use $variable to inject test data into the suite title from the tagged template expressions, and $# for the index of the row.
  • To inject nested object values use you can supply a keyPath i.e. $variable.path.to.value
• fn: Function the suite of tests to be ran, this is the function that will receive the test data object.
• Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

Example:

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)

如果你只想运行一个描述块中的test用例，你可以使用describe.only：

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

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)

Also under the aliases: fdescribe.each(table)(name, fn) and fdescribe.each`table`(name, fn)

Use describe.only.each if you want to only run specific tests suites of data driven tests.

describe.only.each is available with two APIs:

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)

Also under the aliases: xdescribe.each(table)(name, fn) and xdescribe.each`table`(name, fn)

Use describe.skip.each if you want to stop running a suite of data driven tests.

describe.skip.each is available with two APIs:

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

第一个参数是测试名称; 第二个参数是包含测试期望的函数。 The third argument (optional) is timeout (in milliseconds) for specifying how long to wait before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

Note: If a promise is returned from test, Jest will wait for the promise to resolve before letting the test complete. Jest will also wait if you provide an argument to the test function, usually called done. This could be handy when you want to test callbacks. See how to test async code here. Jest will also wait if you provide an argument to the test function, usually called done. This could be handy when you want to test callbacks. See how to test async code here.

例如，假设fetchBeverageList()返回一个应该解析为具有lemon的列表的承诺。 You can test this with:

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

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

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

Also under the alias: it.concurrent(name, fn, timeout)

Use test.concurrent if you want the test to run concurrently.

Note: test.concurrent is considered experimental - see here for details on missing features and other issues

The first argument is the test name; the second argument is an asynchronous function that contains the expectations to test. The third argument (optional) is timeout (in milliseconds) for specifying how long to wait before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

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

Note: Use maxConcurrency in configuration to prevents Jest from executing more than the specified amount of tests at the same time

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

Also under the alias: it.concurrent.each(table)(name, fn, timeout)

Use test.concurrent.each if you keep duplicating the same test with different data. test.each allows you to write the test once and pass data in, the tests are all run asynchronously. test.each allows you to write the test once and pass data in, the tests are all run asynchronously.

test.concurrent.each is available with two APIs:

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

• table: 数组 of Arrays with the arguments that are passed into the test fn for each row.
  • Note If you pass in a 1D array of primitives, internally it will be mapped to a table i.e. [1, 2, 3] -> [[1], [2], [3]]
• name: 字符串 the title of the test block.
  • Generate unique test titles by positionally injecting parameters with printf formatting:
    • %p - pretty-format.
    • %s- String.
    • %d- Number.
    • %i - Integer.
    • %f - Floating point value.
    • %j - JSON.
    • %o - Object.
    • %# - Index of the test case.
    • %% - single percent sign (‘%’). This does not consume an argument.
• fn: Function the test to be ran, this is the function that will receive the parameters in each row as function arguments, this will have to be an asynchronous function.
• Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

Example:

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. 2. test.concurrent.each`table`(name, fn, timeout)

• table: Tagged Template Literal
  • First row of variable name column headings separated with |
  • One or more subsequent rows of data supplied as template literal expressions using ${value} syntax.
• name: 字符串 the title of the test, use $variable to inject test data into the test title from the tagged template expressions.
  • To inject nested object values use you can supply a keyPath i.e. $variable.path.to.value
• fn: Function the test to be ran, this is the function that will receive the test data object, this will have to be an asynchronous function.
• Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

Example:

test.concurrent.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.concurrent.only.each(table)(name, fn)

Also under the alias: it.concurrent.only.each(table)(name, fn)

Use test.concurrent.only.each if you want to only run specific tests with different test data concurrently.

test.concurrent.only.each is available with two APIs:

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)

Also under the alias: it.concurrent.skip.each(table)(name, fn)

Use test.concurrent.skip.each if you want to stop running a collection of asynchronous data driven tests.

test.concurrent.skip.each is available with two APIs:

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

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

Also under the alias: it.each(table)(name, fn) and it.each`table`(name, fn)

Use test.each if you keep duplicating the same test with different data. test.each allows you to write the test once and pass data in. test.each allows you to write the test once and pass data in.

test.each is available with two APIs:

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

• table: 数组 of Arrays with the arguments that are passed into the test fn for each row.
  • Note If you pass in a 1D array of primitives, internally it will be mapped to a table i.e. [1, 2, 3] -> [[1], [2], [3]]
• name: 字符串 the title of the test block.
  • Generate unique test titles by positionally injecting parameters with printf formatting:
    • %p - pretty-format.
    • %s- String.
    • %d- Number.
    • %i - Integer.
    • %f - Floating point value.
    • %j - JSON.
    • %o - Object.
    • %# - Index of the test case.
    • %% - single percent sign (‘%’). This does not consume an argument.
  • Or generate unique test titles by injecting properties of test case object with $variable
    • To inject nested object values use you can supply a keyPath i.e. $variable.path.to.value
    • You can use $# to inject the index of the test case
    • You cannot use $variable with the printf formatting except for %%
• fn: Function the test to be ran, this is the function that will receive the parameters in each row as function arguments.
• Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

Example:

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. 2. test.each`table`(name, fn, timeout)

• table: Tagged Template Literal
  • First row of variable name column headings separated with |
  • One or more subsequent rows of data supplied as template literal expressions using ${value} syntax.
• name: 字符串 the title of the test, use $variable to inject test data into the test title from the tagged template expressions.
  • To inject nested object values use you can supply a keyPath i.e. $variable.path.to.value
• fn: Function the test to be ran, this is the function that will receive the test data object.
• Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

Example:

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

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

Also under the aliases: it.only(name, fn, timeout), and fit(name, fn, timeout)

当你维护一个很大的代码库时，有时可能会发现一个由于某种原因被暂时破坏的测试。 If you want to skip running this test, but you don’t want to delete this code, you can use test.skip to specify some tests to skip.

Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. Note: The default timeout is 5 seconds. Note: The default timeout is 5 seconds.

比如说，你有这些测试︰

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

Only the “it is raining” test will run in that test file, since it is run with test.only.

Usually you wouldn’t check code using test.only into source control - you would use it for debugging, and remove it once you have fixed the broken tests.

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

Also under the aliases: it.only.each(table)(name, fn), fit.each(table)(name, fn), it.only.each`table`(name, fn) and fit.each`table`(name, fn)

Use test.only.each if you want to only run specific tests with different test data.

test.only.each is available with two APIs:

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)

Also under the aliases: it.skip(name, fn), xit(name, fn), and xtest(name, fn)

当你维护一个很大的代码库时，有时可能会发现一个由于某种原因被暂时破坏的测试。 If you want to skip running this test, but you don’t want to delete this code, you can use test.skip to specify some tests to skip.

比如说，你有这些测试︰

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

When you are debugging a large test file, you will often only want to run a subset of tests. You can use .only to specify which tests are the only ones you want to run in that test file.

You could comment the test out, but it’s often a bit nicer to use test.skip because it will maintain indentation and syntax highlighting.

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

Also under the aliases: 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) and xtest.each`table`(name, fn)

Use test.skip.each if you want to stop running a collection of data driven tests.

test.skip.each is available with two APIs:

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)

Also under the alias: it.todo(name)

Use test.todo when you are planning on writing tests. Use test.todo when you are planning on writing tests. These tests will be highlighted in the summary output at the end so you know how many tests you still need todo.

Note: If you supply a test callback function then the test.todo will throw an error. If you have already implemented the test and it is broken and you do not want it to run, then use test.skip instead. If you have already implemented the test and it is broken and you do not want it to run, then use test.skip instead.

API

• name: String the title of the test plan.

Example:

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