Версія: 29.5

Глобальні методи

Під час виконання тестів, Jest додає кожен з цих методів і об’єктів в глобальну область видимості. Вам не потрібно нічого підключати або імпортувати, щоб їх використовувати. Проте, якщо ви надаєте перевагу явним імпортам, ви можете робити це з допомогою import {describe, expect, test} from '@jest/globals'.

info

Приклади TypeScript з цієї сторінки будуть працювати, як задокументовано, тільки якщо ви явно імпортуєте Jest API:

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

Інструкцію щодо налаштування Jest за допомогою TypeScript можна знайти на сторінці Початок роботи.

Довідка

`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 блоку, функція виконується в кінці цього блоку.

Якщо ви хочете виконати очистку після кожного тесту, використовуйте afterEach натомість.

`afterEach(fn, timeout)`

Запускає функцію після завершення кожного тесту в цьому файлі. Якщо функція повертає проміс, або генератор, Jest очікує на виконання цього промісу, перш ніж продовжити.

Наприклад:

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 очікує на виконання цього промісу, перш ніж запускати тести.

Наприклад:

const globalDatabase = makeGlobalDatabase();

beforeAll(() => {
  // Очищає базу даних і додає деякі тестові дані.
  // Jest чекатиме поки цей проміс буде виконано перед запуском тестів.
  return globalDatabase.clear().then(() => {
    return globalDatabase.insert({testData: 'foo'});
  });
});

// Оскільки ми створили базу даних тільки один раз, в цьому прикладі, то важливо
// щоб наші тести не змінювали її
test('can find things', () => {
  return globalDatabase.find('thing', {}, results => {
    expect(results.length).toBeGreaterThan(0);
  });
});

Тут beforeAll гарантує, що база даних буде створена, перед запуском тестів. Якщо налаштування були синхронними, ви можете зробити це без beforeAll. Основна перевага полягає в тому, що Jest чекатиме, поки виконається проміс, що дозволяє використання асинхронних налаштувань.

Якщо beforeAll знаходиться всередині describe блоку, функція запуститься на початку цього блоку.

Якщо ви хочете виконувати якісь команди перед запуском кожного тесту, використовуйте beforeEach натомість.

`beforeEach(fn, timeout)`

Запускає функцію перед виконанням кожного тесту в цьому файлі. Якщо функція повертає проміс, або генератор, Jest очікує на виконання цього промісу, перш ніж запускати тест.

Наприклад:

const globalDatabase = makeGlobalDatabase();

beforeEach(() => {
  // Очищує базу даних та додає деякі тестові дані.
  // Jest чекатиме поки цей проміс буде виконано перед запуском тестів.
  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 який повинен мати властивість delicious і не мати властивості sour, ви можете протестувати це так:

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 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 ('%'). Це не розглядається як аргумент.
- Або ж генеруйте унікальні заголовки тестів шляхом впровадження властивостей об'єкту теста за допомогою $variable
  - Для введення значень вкладеного об'єкта, можна зазначити keyPath, тобто $variable.path.to.value
  - Ви можете використати $# для додавання індексу тесту
  - You cannot use $variable with the printf formatting except for %%
fn: Function набір тестів для виконання; функція, що отримуватиме параметри у вигляді аргументів функції в кожному рядку.
Додатково, ви можете надати timeout (у мілісекундах), щоб вказати, як довго чекати кожного рядка перед перериванням. За замовчуванням, тайм-аут становить 5 секунд.

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
- Перший рядок змінних іменують заголовки стовпців, розділених |
- Один або кілька наступних рядків даних надаються як шаблонні літеральні вирази з використанням синтаксису ${value}.
name: String назва набору тестів, використовуйте $variable для введення тестових даних з шаблонних виразів з тегами в назву набору, а також $# для індексу рядку.
- Для введення значень вкладеного об'єкта, можна зазначити keyPath, тобто $variable.path.to.value
fn: Function набір тестів для виконання; функція, що отримає об'єкт тестових даних.
Додатково, ви можете надати timeout (у мілісекундах), щоб вказати, як довго чекати кожного рядка перед перериванням. За замовчуванням, тайм-аут становить 5 секунд.

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

Також має псевдонім fdescribe(name, fn)

Ви можете використовувати describe.only, якщо ви хочете виконати лише один блок 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)`

Також має псевдоніми: 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.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
});

Using describe.skip is often a cleaner alternative to temporarily commenting out a chunk of tests. Майте на увазі, що блок describe все ще буде запускатися. Якщо у вас є деякі налаштування, які також слід скасувати, зробіть це в beforeAll або beforeEach.

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

Також має псевдоніми: xdescribe.each(table)(name, fn) і xdescribe.each`table`(name, fn)

Використовуйте describe.skip.each, якщо ви хочете припинити виконувати набір тестів (data driven tests).

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 секунд.

If a promise is returned from test, Jest will wait for the promise to resolve before letting the test complete. Наприклад, скажімо, fetchBeverageList() повертає проміс, який повинен виконатися і повернути список, який містить lemon у собі. Ви можете протестувати це так:

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

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

порада

Jest також буде чекати, якщо ви підставите аргумент тестової функції, зазвичай називається done. This could be handy when you want to test callbacks.

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

Також має псевдонім: it.concurrent(name, fn, timeout)

caution

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

Використовуйте 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 allows you to write the test once and pass data in, the tests are all run asynchronously.

test.concurrent.each доступний з двома API:

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

table: Array of Arrays with the arguments that are passed into the test fn for each row. Якщо ви передасте 1D масив примітивів, його буде перетворено на таблицю, тобто [1, 2, 3] -> [[1], [2], [3]]
name: name назва тестового блоку.
- Генеруйте унікальні заголовки тестів за допомогою позиційних вбудованих параметрів за допомогою 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 ('%'). Це не розглядається як аргумент.
fn: Function тест для виконання; функція, яка отримає параметри в кожному рядку у вигляді аргументів функції, вона має бути асинхронною функцією.
Додатково, ви можете надати timeout (у мілісекундах), щоб вказати, як довго чекати кожного рядка перед перериванням. За замовчуванням, тайм-аут становить 5 секунд.

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
- Перший рядок змінних іменують заголовки стовпців, розділених |
- Один або кілька наступних рядків даних надаються як шаблонні літеральні вирази з використанням синтаксису ${value}.
name: String назва набору тестів, використовуйте $variable для введення тестових даних з шаблонних виразів з тегами в назву набору.
- Для введення значень вкладеного об'єкта, можна зазначити keyPath, тобто $variable.path.to.value
fn: Function тест для виконання; функція, що отримає об'єкт тестових даних, вона має бути асинхронною функцією.
Додатково, ви можете надати timeout (у мілісекундах), щоб вказати, як довго чекати кожного рядка перед перериванням. За замовчуванням, тайм-аут становить 5 секунд.

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)

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

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); // не виконається
});

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); // не виконається
});

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

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

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

table: Array of Arrays with the arguments that are passed into the test fn for each row. Якщо ви передасте 1D масив примітивів, його буде перетворено на таблицю, тобто [1, 2, 3] -> [[1], [2], [3]]
name: name назва тестового блоку.
- Генеруйте унікальні заголовки тестів за допомогою позиційних вбудованих параметрів за допомогою 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 ('%'). Це не розглядається як аргумент.
- Або ж генеруйте унікальні заголовки тестів шляхом впровадження властивостей об'єкту теста за допомогою $variable
  - Для введення значень вкладеного об'єкта, можна зазначити keyPath, тобто $variable.path.to.value
  - Ви можете використати $# для додавання індексу тесту
  - You cannot use $variable with the printf formatting except for %%
fn: Function тест для виконання; функція, яка отримає параметри в кожному рядку у вигляді аргументів функції.
Додатково, ви можете надати timeout (у мілісекундах), щоб вказати, як довго чекати кожного рядка перед перериванням. За замовчуванням, тайм-аут становить 5 секунд.

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
- Перший рядок змінних іменують заголовки стовпців, розділених |
- Один або кілька наступних рядків даних надаються як шаблонні літеральні вирази з використанням синтаксису ${value}.
name: String назва набору тестів, використовуйте $variable для введення тестових даних з шаблонних виразів з тегами в назву набору.
- Для введення значень вкладеного об'єкта, можна зазначити keyPath, тобто $variable.path.to.value
fn: Function тест для виконання; функція, що отримає об'єкт тестових даних.
Додатково, ви можете надати timeout (у мілісекундах), щоб вказати, як довго чекати кожного рядка перед перериванням. За замовчуванням, тайм-аут становить 5 секунд.

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)

note

This is only available with the default jest-circus runner.

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

порада

Ви можете використовувати цей тип тестів, наприклад, при написанні коду способом BDD. In that case the tests will not show up as failing until they pass. Then you can just remove the failing modifier to make them pass.

It can also be a nice way to contribute failing tests to a project, even if you don't know how to fix the bug.

Example:

test.failing('it is not equal', () => {
  expect(5).toBe(6); // цей тест буде успішним
});

test.failing('it is equal', () => {
  expect(10).toBe(10); // цей тест буде провальним
});

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

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

note

This is only available with the default jest-circus runner.

You can also run multiple tests at once by adding each after failing.

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)

note

This is only available with the default jest-circus runner.

Use test.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)

note

This is only available with the default jest-circus runner.

Use test.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), and fit(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.

Наприклад, нехай у вас є наступні тести:

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

Лише тест "it is raining" буде виконано, оскільки інший тест запускається з test.skip.

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); // не виконається
});

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); // не виконається
});

test('will be run', () => {
  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. These tests will be highlighted in the summary output at the end so you know how many tests you still need todo.

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

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

порада

test.todo викине помилку, якщо передати тестову функцію зворотного виклику. Use test.skip instead, if you already implemented the test, but do not want it to run.

Використання TypeScript

info

Приклади TypeScript з цієї сторінки будуть працювати, як задокументовано, тільки якщо ви явно імпортуєте Jest API:

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

Інструкцію щодо налаштування Jest за допомогою TypeScript можна знайти на сторінці Початок роботи.

`.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 to describe or test callback functions. Let's take a look at each of them.

note

For simplicity test.each is picked for the examples, but the type inference is identical in all cases where .each modifier can be used: describe.each, test.concurrent.only.each, test.skip.each, etc.

Array of objects

The array of objects API is most verbose, but it makes the type inference a painless task. A table 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}) => {
  // типи аргументів відповідають очікуванням, наприклад, `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}) => {
  // знову, типи відповідають очікуванням, наприклад, `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) => {
  // типи аргументів відповідають очікуванням, наприклад, 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) => {
  // без анотації, типи є некоректними, наприклад, `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}) => {
  // всі аргументи мають тип `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}) => {
  // в цьому випадку, без загального аргументу, типи за замовчуванням дорівнюватимуть `unknown`
});

Методи​

Довідка​

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.failing(name, fn, timeout)​

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

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

test.skip.failing(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)​

Використання TypeScript​

.each​

Array of objects​

Array of arrays​

Template literal​

Методи

Довідка

`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.failing(name, fn, timeout)`

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

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

`test.skip.failing(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)`

Використання TypeScript

`.each`

Array of objects

Array of arrays

Template literal