Версія: Next

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

Під час виконання тестів, 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).
  - %# - Індекс тестового випадку.
  - %$ - Number of the test case.
  - %% одинарний знак відсотку ('%'). Це не розглядається як аргумент.
- Або ж генеруйте унікальні заголовки тестів шляхом впровадження властивостей об'єкту теста за допомогою $variable
  - Для введення значень вкладеного об'єкта, можна зазначити keyPath, тобто $variable.path.to.value
  - Ви можете використати $# для додавання індексу тесту
  - Ви не можете використовувати $variable з printf форматуванням, окрім %%
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 секунд.

Якщо test повертає проміс, Jest буде очікувати на його виконання перед тим, як дати тесту закінчитися. Наприклад, скажімо, fetchBeverageList() повертає проміс, який повинен виконатися і повернути список, який містить lemon у собі. Ви можете протестувати це так:

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

Незважаючи на те, що test відразу поверне значення, тест не буде виконано, поки не буде виконано проміс. Для більш детальної інформації дивіться Тестування асинхронного коду сторінки.

порада

Jest також буде чекати, якщо ви підставите аргумент тестової функції, зазвичай називається done. Це може бути зручно, коли ви хочете перевірити зворотні виклики.

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

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

caution

test.concurrent винятково експериментальна функція - дивися тут детальну інформацію про відсутні функції та інші проблеми.

Використовуйте test.concurrent, якщо хочете запускати тест в конкурентному режимі.

Перший аргумент - це назва тесту; другий - асинхронна функція, яка містить очікування для перевірки. Третій аргумент (необов'язковий) - timeout (у мілісекундах) для визначення, як довго чекати перед перериванням. За замовчуванням, тайм-аут становить 5 секунд.

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

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

порада

Використовуйте параметр конфігурації maxConcurrency, аби заборонити Jest виконувати більше зазначеної кількості тестів одночасно.

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

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

Використовуйте test.concurrent.each якщо ви дублюєте один і той самий тест з різними даними. test.each дозволяє написати тест один раз і далі передавати в нього дані, які виконуються асинхронно.

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

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

table: Array масивів з аргументами, які передаються в функцію fn для кожного рядка. Якщо ви передасте 1D масив примітивів, його буде перетворено на таблицю, тобто [1, 2, 3] -> [[1], [2], [3]]
name: name назва тестового блоку.
- Генеруйте унікальні заголовки тестів за допомогою позиційних вбудованих параметрів за допомогою printf formatting:
  - %p - pretty-format.
  - %s- Рядок (String).
  - %d- Число (Number).
  - %i - Ціле число (Integer).
  - %f - Число з плаваючою комою (Floating point value).
  - %j - JSON.
  - %o - Об'єкт (Object).
  - %# - Індекс тестового випадку.
  - %$ - Number of the test case.
  - %% одинарний знак відсотку ('%'). Це не розглядається як аргумент.
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)`

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

Використовуйте test.concurrent.failing, якщо ви хочете запустити лише певні тести з різними даними конкурентно.

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

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

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

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

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

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

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

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

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

Використовуйте test.concurrent.skip.each, якщо ви хочете припинити виконувати асинхронний набір тестів.

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

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

test.concurrent.skip.each([
  [1, 1, 2],
  [1, 2, 3],
  [2, 1, 3],
])('.add(%i, %i)', async (a, b, expected) => {
  expect(a + b).toBe(expected); // не виконається
});

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

Також має псевдонім: 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 дозволяє написати тест один раз і далі передавати в нього дані.

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

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

table: Array масивів з аргументами, які передаються в функцію fn для кожного рядка. Якщо ви передасте 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).
  - %# - Індекс тестового випадку.
  - %$ - Number of the test case.
  - %% одинарний знак відсотку ('%'). Це не розглядається як аргумент.
- Або ж генеруйте унікальні заголовки тестів шляхом впровадження властивостей об'єкту теста за допомогою $variable
  - Для введення значень вкладеного об'єкта, можна зазначити keyPath, тобто $variable.path.to.value
  - Ви можете використати $# для додавання індексу тесту
  - Ви не можете використовувати $variable з printf форматуванням, окрім %%
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)`

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

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

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

note

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

Використовуйте test.only.failing, якщо ви хочете запустити лише певні тести.

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

Також має псевдоніми: it.skip.failing(name, fn, timeout), xit.failing(name, fn, timeout), xtest.failing(name, fn, timeout)

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

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

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

Використовуйте test.only.each, якщо ви хочете запустити лише певні тести.

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

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

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

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

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

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

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

`test.skip(name, fn)`

Також має псевдоніми: it.skip(name, fn), xit(name, fn), 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)`

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

Використовуйте test.concurrent.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); // не виконається
});

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

Також має псевдонім: 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 input 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 same type', ({a, b, expected}) => {
  // all arguments are of type `number` because all inputs (a, b, expected) are of type `number`
});

If the inputs have different types, the arguments will be typed as a union of all the input types (i.e. type of the variables inside the template literal):

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

test.each`
  a    | b    | expected
  ${1} | ${2} | ${'three'}
  ${3} | ${4} | ${'seven'}
  ${5} | ${6} | ${'eleven'}
`('template literal example different types', ({a, b, expected}) => {
  // all arguments are of type `number | string` because some inputs (a, b) are of type `number` and some others (expected) are of type `string`
});

Otherwise, if you want each argument to have the right type, you have to explicitly provide the 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}) => {
  // all arguments are typed as expected, e.g. `a: number`, `expected: string`, `extra: boolean | undefined`
});

caution

Keep in mind the variables inside the template literal are not type checked, so you have to ensure that their types are correct.

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

test.each<{a: number; expected: string}>`
  a                            | expected
  ${1}                         | ${'one'}
  ${'will not raise TS error'} | ${'two'}
  ${3}                         | ${'three'}
`('template literal with wrongly typed input', ({a, expected}) => {
  // all arguments are typed as stated in the generic: `a: number`, `expected: string`
  // WARNING: `a` is of type `number` but will be a string in the 2nd test case.
});

Методи​

Довідка​

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