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 doimport {describe, expect, test} from '@jest/globals'.

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

Methods​

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 atimeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.

This is often useful if you want to clean up some global setup state that is shared across tests.

For example:

const globalDatabase=makeGlobalDatabase();

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

Here theafterAll ensures thatcleanUpDatabase is called after all tests run.

IfafterAll is inside adescribe block, it runs at the end of the describe block.

If you want to run some cleanup after every test instead of after all tests, useafterEach instead.

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 atimeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.

This is often useful if you want to clean up some temporary state that is created by each test.

For example:

const globalDatabase=makeGlobalDatabase();

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

Here theafterEach ensures thatcleanUpDatabase is called after each test runs.

IfafterEach is inside adescribe block, it only runs after the tests that are inside this describe block.

If you want to run some cleanup just once, after all of the tests run, useafterAll instead.

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 atimeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.

This is often useful if you want to set up some global state that will be used by many tests.

For example:

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

Here thebeforeAll ensures that the database is set up before tests run. If setup was synchronous, you could do this withoutbeforeAll. The key is that Jest will wait for a promise to resolve, so you can have asynchronous setup as well.

IfbeforeAll is inside adescribe block, it runs at the beginning of the describe block.

If you want to run something before every test instead of before any test runs, usebeforeEach instead.

beforeEach(fn, timeout)​

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.

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

This is often useful if you want to reset some global state that will be used by many tests.

For example:

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

Here thebeforeEach ensures that the database is reset for each test.

IfbeforeEach is inside adescribe block, it runs for each test in the describe block.

If you only need to run some setup code once, before any tests run, usebeforeAll instead.

describe(name, fn)​

describe(name, fn) creates a block that groups together several related tests. For example, if you have amyBeverage object that is supposed to be delicious but not sour, you could test it with:

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 thetest blocks directly at the top level. But this can be handy if you prefer your tests to be organized into groups.

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

constbinaryStringToNumber=binString=>{
if(!/^[01]+$/.test(binString)){
thrownewCustomError('Not a binary number.');
}

returnparseInt(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)​

Usedescribe.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 is available with two APIs:

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

• table:Array of Arrays with the arguments that are passed into thefn for each row. 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:String the title of the test suite.

  • Generate unique test titles by positionally injecting parameters withprintf 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 (only works for"own" properties, e.g.$variable.constructor.name wouldn't work)
    • You can use$# to inject the index of the test case
    • You cannot use$variable with theprintf formatting except for%%

• fn:Function the suite of tests to be run, this is the function that will receive the parameters in each row as function arguments.

• Optionally, you can provide atimeout (in milliseconds) for specifying how long to wait for each row before aborting. 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.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 (only works for"own" properties, e.g.$variable.constructor.name wouldn't work)
• fn:Function the suite of tests to be run, this is the function that will receive the test data object.
• Optionally, you can provide atimeout (in milliseconds) for specifying how long to wait for each row before aborting. 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)​

Also under the alias:fdescribe(name, fn)

You can usedescribe.only if you want to run only one describe block:

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

Usedescribe.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 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)​

Also under the alias:xdescribe(name, fn)

You can usedescribe.skip if you do not want to run the tests of a particulardescribe block:

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

Usingdescribe.skip is often a cleaner alternative to temporarily commenting out a chunk of tests. Beware that thedescribe block will still run. If you have some setup that also should be skipped, do it in abeforeAll orbeforeEach block.

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

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

Usedescribe.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 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)​

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

All you need in a test file is thetest method which runs a test. For example, let's say there's a functioninchesOfRain() that should be zero. Your whole test could be:

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

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

If apromise is returned fromtest, Jest will wait for the promise to resolve before letting the test complete. For example, let's sayfetchBeverageList() returns a promise that is supposed to resolve to a list that haslemon in it. You can test this with:

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

Even though the call totest will return right away, the test doesn't complete until the promise resolves. For more details, seeTesting Asynchronous Code page.

test.concurrent(name, fn, timeout)​

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

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

The first argument is the test name; the second argument is an asynchronous function that contains the expectations to test. The third argument (optional) istimeout (in milliseconds) for specifying how long to wait before aborting. 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);
});

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

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

Usetest.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.concurrent.each is available with two APIs:

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

• table:Array of Arrays with the arguments that are passed into the testfn for each row. 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:String the title of the test block.
  • Generate unique test titles by positionally injecting parameters withprintf 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 run, 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 atimeout (in milliseconds) for specifying how long to wait for each row before aborting. 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.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:String 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 (only works for"own" properties, e.g.$variable.constructor.name wouldn't work)
• fn:Function the test to be run, this is the function that will receive the test data object,this will have to be an asynchronous function.
• Optionally, you can provide atimeout (in milliseconds) for specifying how long to wait for each row before aborting. 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 to $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)

Usetest.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 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)​

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

Usetest.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 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)​

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

Usetest.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 is available with two APIs:

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

• table:Array of Arrays with the arguments that are passed into the testfn for each row. 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:String the title of the test block.
  • Generate unique test titles by positionally injecting parameters withprintf 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 (only works for"own" properties, e.g.$variable.constructor.name wouldn't work)
    • You can use$# to inject the index of the test case
    • You cannot use$variable with theprintf formatting except for%%
• fn:Function the test to be run, this is the function that will receive the parameters in each row as function arguments.
• Optionally, you can provide atimeout (in milliseconds) for specifying how long to wait for each row before aborting. 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.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:String 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 (only works for"own" properties, e.g.$variable.constructor.name wouldn't work)
• fn:Function the test to be run, this is the function that will receive the test data object.
• Optionally, you can provide atimeout (in milliseconds) for specifying how long to wait for each row before aborting. 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 to $b',({a, b, expected})=>{
expect(a+ b).toBe(expected);
});

test.failing(name, fn, timeout)​

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

Usetest.failing when you are writing a test and expecting it to fail. These tests will behave the other way normal tests do. Iffailing test will throw any errors then it will pass. If it does not throw it will fail.

Example:

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)​

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

You can also run multiple tests at once by addingeach afterfailing.

Example:

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)​

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

Usetest.only.failing if you want to only run a specific failing test.

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

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

Usetest.skip.failing if you want to skip running a specific failing test.

test.only(name, fn, timeout)​

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

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.

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

For example, let's say you had these tests:

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 withtest.only.

Usually you wouldn't check code usingtest.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) andfit.each`table`(name, fn)

Usetest.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 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)​

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

When you are maintaining a large codebase, you may sometimes find a test that is temporarily broken for some reason. If you want to skip running this test, but you don't want to delete this code, you can usetest.skip to specify some tests to skip.

For example, let's say you had these tests:

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

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

Only the "it is raining" test will run, since the other test is run withtest.skip.

You could comment the test out, but it's often a bit nicer to usetest.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) andxtest.each`table`(name, fn)

Usetest.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 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)​

Also under the alias:it.todo(name)

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

constadd=(a, b)=> a+ b;

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

TypeScript Usage​

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

.each​

The.each modifier offers few different ways to define a table of the test cases. Some of the APIs have caveats related with the type inference of the arguments which are passed todescribe ortest callback functions. Let's take a look at each of them.

Array of objects​

The array of objects API is most verbose, but it makes the type inference a painless task. Atable can be inlined:

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

Or declared separately as a variable:

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

Array of arrays​

The array of arrays style will work smoothly with inlined tables:

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

However, if a table is declared as a separate variable, it must be typed as an array of tuples for correct type inference (this is not needed only if all elements of a row are of the same type):

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

Template literal​

If all values are of the same type, the template literal API will type the arguments correctly:

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

Otherwise it will require a generic type argument:

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