Expect
Під час написання тестів, часто потрібно перевіряти, що значення задовольняють певним умовам. expect надає вам доступ до ряду так званих матчерів, які дозволяють вам виконувати різні перевірки.
Методи #
Довідка #
expect(value) #
Функція expect використовується кожного разу, коли ви хочете перевірити якесь значення. Дуже рідко потрібно викликати expect саму по собі. Замість цього, ви будете використовувати expect разом з "матчер" функціями, щоб перевірити твердження щодо якогось значення.
Найпростіше зрозуміти це на прикладі. Уявімо, що у вас є метод bestLaCroixFlavor(), який повинен повертати рядок 'grapefruit'. Ось, як ви можете це протестувати:
test('the best flavor is grapefruit', () => { expect(bestLaCroixFlavor()).toBe('grapefruit'); });
В цьому випадку toBe - це функція-матчер. Існує багато різних функцій-матчерів, описаних нижче, які допомогають тестувати різні речі.
Аргументом для expect повинне бути значення, яке генерує ваш код, а аргументом для матчера повинне бути правильне значення. Якщо ви їх переплутаєте місцями, то ваші тести працюватимуть, але повідомлння про помилки в тестах будуть виглядати дуже дивно.
expect.extend(matchers) #
Ви можете використовувати expect.extend щоб додати ваші власні матчери для Jest. Наприклад, скажімо ви тестуєте бібліотеку для роботи з теорією чисел і ви часто перевіряєте, що числа діляться на інші числа без залишку. Ви могли би написати для цього матчер toBeDivisibleBy:
expect.extend({ toBeDivisibleBy(received, argument) { const pass = (received % argument == 0); if (pass) { return { message: () => ( `expected ${received} not to be divisible by ${argument}` ), pass: true, }; } else { return { message: () => (`expected ${received} to be divisible by ${argument}`), pass: false, }; } }, }); test('even and odd numbers', () => { expect(100).toBeDivisibleBy(2); expect(101).not.toBeDivisibleBy(2); });
Матчер повинен повертати об’єкт з двома ключами. pass вказує на те, чи було співпадіння, а message надає функцію без аргументів, яка повертає повідомлення про помилку, на випадок невдачі. Таким чином, коли pass має значення false, message повинна повернути повідомлення про помилку, якщо твердження expect(x).yourMatcher() не виконується. А коли pass має значення true, message повинна повернути повідомленя про помилку, якщо не виконується твердження expect(x).not.yourMatcher().
Наступні допоміжні властивості доступні в this всередині власних матчерів:
this.isNot #
Булеве значення, яке дає вам можливість дізнатися, чи цей матчер був викликаний з модифікатором заперечення .not, щоб ви могли інвертувати свою перевірку.
this.equals(a, b) #
Це функція глибокого порівняння, яка повертає true, якщо два об’єкти мають те саме значення (рекурсивно).
this.utils #
Існує багато корисних інструментів, доступних через this.utils, які, в основному, складаються з функцій, які експортуються в пакеті jest-matcher-utils.
Найбільш корисні з них - це matcherHint, printExpected і printReceived для форматування повідомлень про помилки. Наприклад, ось як це реалізовано для матчера toBe:
const diff = require('jest-diff'); expect.extend({ toBe(received, expected) { const pass = received === expected; const message = pass ? () => this.utils.matcherHint('.not.toBe') + '\n\n' + `Expected value to not be (using ===):\n` + ` ${this.utils.printExpected(expected)}\n` + `Received:\n` + ` ${this.utils.printReceived(received)}` : () => { const diffString = diff(expected, received, { expand: this.expand, }); return this.utils.matcherHint('.toBe') + '\n\n' + `Expected value to be (using ===):\n` + ` ${this.utils.printExpected(expected)}\n` + `Received:\n` + ` ${this.utils.printReceived(received)}` + (diffString ? `\n\nDifference:\n\n${diffString}` : ''); }; return {actual: received, message, pass}; }, });
Виведеться щось таке:
expect(received).toBe(expected) Expected value to be (using ===): "banana" Received: "apple"
Коли твердження не виконується, повідомлення про помилку повинне давати користувачеві якомога більше інформації, щоб він міг швидко вирішити проблему. Варто робити точні і зрозумілі поідомлення про помилки, щоб переконатися, що б ваші власні матчери були зручні у використанні.
expect.anything() #
expect.anything() відповідає будь-якому значенню, окрім null та undefined. Ви можете використовувати його всередині toEqual чи toBeCalledWith замість явного вказання значень. Наприклад, якщо ви хочете перевірити, що мок функція була викликана з аргументом, не рівним null:
test('map calls its argument with a non-null argument', () => { const mock = jest.fn(); [1].map(mock); expect(mock).toBeCalledWith(expect.anything()); });
expect.any(constructor) #
expect.any(constructor) перевіряє, що значення було створене з допомогою заданого конструктора. Ви можете використовувати його всередині toEqual чи toBeCalledWith замість явного вказання значень. Наприклад, якщо ви хочете перевірити, що мок функція була викликана з аргументом типу Number:
function randocall(fn) { return fn(Math.floor(Math.random() * 6 + 1)); } test('randocall calls its callback with a number', () => { const mock = jest.fn(); randocall(mock); expect(mock).toBeCalledWith(expect.any(Number)); });
expect.arrayContaining(array) #
expect.arrayContaining(array) перевіряє, чи отриманий масив містить всі елементи очікуваного. Іншими словами, що очікуваний масив є підмножиною отриманого. Отже, отриманий масив може містити елементи, яких немає в очікуваному.
Ви можете використовувати його замість явного вказання значень:
- в
toEqualабоtoBeCalledWith - щоб вказати відповідність властивості в
objectContainingабоtoMatchObject
describe('arrayContaining', () => { const expected = ['Alice', 'Bob']; it('matches even if received contains additional elements', () => { expect(['Alice', 'Bob', 'Eve']).toEqual(expect.arrayContaining(expected)); }); it('does not match if received does not contain expected elements', () => { expect(['Bob', 'Eve']).not.toEqual(expect.arrayContaining(expected)); }); });
describe('Beware of a misunderstanding! A sequence of dice rolls', () => { const expected = [1, 2, 3, 4, 5, 6]; it('matches even with an unexpected number 7', () => { expect([4, 1, 6, 7, 3, 5, 2, 5, 4, 6]) .toEqual(expect.arrayContaining(expected)); }); it('does not match without an expected number 2', () => { expect([4, 1, 6, 7, 3, 5, 7, 5, 4, 6]) .not.toEqual(expect.arrayContaining(expected)); }); });
expect.assertions(number) #
expect.assertions(number) перевіряє, що певна кількість тверджень було викликано в межах тесту. Це часто буває корисним при тестуванні асинхронного коду, щоб переконатися, що твердження в зворотніх викликах було викликано.
Наприклад, нехай у нас є функція doAsync, яка приймає два зворотні виклики callback1 і callback2 і асинхронно викликає їх в невідомому порядку. Ми можемо протестувати це так:
test('doAsync calls both callbacks', () => { expect.assertions(2); function callback1(data) { expect(data).toBeTruthy(); } function callback2(data) { expect(data).toBeTruthy(); } doAsync(callback1, callback2); });
Виклик expect.assertions(2) перевіряє, що обидва зворотні виклики дійсно були викликані.
expect.hasAssertions() #
expect.hasAssertions() перевіряє, що хоча б одне твердження було викликане в межах тесту. Це часто буває корисним при тестуванні асинхронного коду, щоб переконатися, що твердження в зворотніх викликах було викликано.
Наприклад, нехай у нас є кілька функцій, які працюють з якимось спільним станом. prepareState викликає функцію зворотнього виклику з об’єктом стану, validateState виконує над цим об’єктом якусь операцію, а waitOnState повертає проміс, який очікує поки виконається зворотній виклик prepareState. Ми можемо протестувати це так:
test('prepareState prepares a valid state', () => { expect.hasAssertions(); prepareState(state => { expect(validateState(state)).toBeTruthy(); }); return waitOnState(); });
Виклик expect.hasAssertions() перевіряє, що зворотній виклик prepareState дійсно було викликано.
expect.objectContaining(object) #
expect.objectContaining(object) відповідає будь-якому об’єкту, який рекурсивно відповідає очікуваному. Іншими словами, що очікуваний об’єкт є підмножиною отриманого. Отже, він відповідає отриманому об’єкту, що містить властивості, яких немає в очікуваному.
Замість значень властивостей в очікуваному об’єкті ви можете використовувати матчери типу expect.anything() та інші.
Наприклад, нехай ми очікуємо, що функція onPress буде викликана з об’єктом Event і нам потрібно перевірити, що цей об’єкт має властивості event.x і event.y. Ми можемо зробити це так:
test('onPress gets called with the right thing', () => { const onPress = jest.fn(); simulatePresses(onPress); expect(onPress).toBeCalledWith(expect.objectContaining({ x: expect.any(Number), y: expect.any(Number), })); });
expect.stringContaining(string) #
доступно в Jest 19.0.0+ #
expect.stringContaining(string) відповідає будь-якому отриманому рядку, який містить в собі очікуваний.
expect.stringMatching(regexp) #
expect.stringMatching(regexp) відповідає будь якому рядку, який співпадає з оікуваним регулярним виразом.
Ви можете використовувати його замість явного вказання значень:
- в
toEqualабоtoBeCalledWith - щоб вказати відповідність елементу в
arrayContaining - щоб вказати відповідність властивості в
objectContainingабоtoMatchObject
Наступний приклад показує як можна використовувати кілька вкладених матчерів з expect.stringMatching всередині expect.arrayContaining.
describe('stringMatching in arrayContaining', () => { const expected = [ expect.stringMatching(/^Alic/), expect.stringMatching(/^[BR]ob/), ]; it('matches even if received contains additional elements', () => { expect(['Alicia', 'Roberto', 'Evelina']) .toEqual(expect.arrayContaining(expected)); }); it('does not match if received does not contain expected elements', () => { expect(['Roberto', 'Evelina']) .not.toEqual(expect.arrayContaining(expected)); }); });
expect.addSnapshotSerializer(serializer) #
Ви можете викликати expect.addSnapshotSerializer, щоб додати модуль, який форматує специфічні для вашої програми структури даних.
Для откремого файлу з тестами, вказаний модуль буде мати пріорітет над модулями з розділу snapshotSerializers файла конфігурації, які мають пріорітет над серіалізаторами для вбудованих типів JavaScript та React елементів. Останній доданий модуль буде використаний першим.
import serializer from 'my-serializer-module'; expect.addSnapshotSerializer(serializer); // впливає на всі твердження expect(value).toMatchSnapshot() в межах файла з тестами
Якщо ви додаєте серіалізатор знімків для окремого файла з тестами замість додавання його в розділ snapshotSerializers файлу конфігурації, то:
- Ви робити залежність явною, замість неявної.
- Ви уникаєте обмежень на зміну конфігурації, які можуть призвести до необхідності виконувати команду
ejectдля create-react-app.
Для додаткової інформації звертайтеся до розділу налаштування Jest.
.not #
Якщо ви знаєте, як перевірити якесь твердження, то .not дозволяє перевірити протилежне до цього твердження. Наприклад наступний код перевіряє,що найклащий смак Ла-Круа — не кокосовий:
test('the best flavor is not coconut', () => { expect(bestLaCroixFlavor()).not.toBe('coconut'); });
.resolves #
Доступно в Jest 20.0.0+ #
Використовуйте resolves для отримання значення виконаного промісу, щоб будь-який інший матчер міг його перевірити. Якщо проміс буде відхилено, твердження не виконається.
Наприклад, цей код перевіряє, що проміс виконується успішно і його значення — це 'lemon':
test('resolves to lemon', () => { // не забудьте додати оператор return return expect(Promise.resolve('lemon')).resolves.toBe('lemon'); });
Крім того, ви можете використовувати async/await у поєднання з .resolves:
test('resolves to lemon', async () => { await expect(Promise.resolve('lemon')).resolves.toBe('lemon'); await expect(Promise.resolve('lemon')).resolves.not.toBe('octopus'); });
.rejects #
Доступно в Jest 20.0.0+ #
Використовуйте resolves для отримання значення відхиленого промісу, щоб будь-який інший матчер міг його перевірити. Якщо проміс буде виконано успішно, твердження не виконається.
Наприклад, цей код перевіряє, що проміс було відхилено з вказанням причини:
test('fetchData() rejects to be error', () => { // не забудьте додати оператор return return expect(Promise.reject('octopus')).rejects.toBeDefined(); });
Крім того, ви можете використовувати async/await у поєднанні з .rejects. Більше того, наступний код перевіряє, що причина відхилення містить рядок 'octopus':
test('fetchData() rejects to be error', async () => { const drinkOctopus = new Promise(() => { throw new DisgustingFlavorError('yuck, octopus flavor'); }); await expect(drinkOctopus).rejects.toMatch('octopus'); });
.toBe(value) #
toBe перевіряє, що значення є саме таким, як ви очікуєте. Він використовує === для перевірки суворої рівності.
Наприклад, наступний код буде валідувати деякі властивості об’єкту can:
const can = { name: 'pamplemousse', ounces: 12, }; describe('the can', () => { test('has 12 ounces', () => { expect(can.ounces).toBe(12); }); test('has a sophisticated name', () => { expect(can.name).toBe('pamplemousse'); }); });
Не використовуйте toBe для чисел з плаваючою комою. Наприклад, через округлення в JavaScript, 0.2 + 0.1 не дорівнює 0.3. Якщо вам потрібно перевіряти числа з плаваючою комою, використовуйте .toBeCloseTo.
.toHaveBeenCalled() #
Також має псевдонім .toBeCalled()
Використовуйте .toHaveBeenCalled, щоб переконатися, що мок функція була викликана.
Наприклад, нехай у вас є функція drinkAll(drink, flavor), яка приймає функцію drink та викликає її для всіх доступних напоїв. Ви можете перевірити, що функція drink викликається для 'lemon', але не викликається для 'octopus'. Це можна зробити наступним чином:
describe('drinkAll', () => { test('drinks something lemon-flavored', () => { const drink = jest.fn(); drinkAll(drink, 'lemon'); expect(drink).toHaveBeenCalled(); }); test('does not drink something octopus-flavored', () => { const drink = jest.fn(); drinkAll(drink, 'octopus'); expect(drink).not.toHaveBeenCalled(); }); });
.toHaveBeenCalledTimes(number) #
Використовуйте .toHaveBeenCalledTimes, щоб переконатися, що мок функція була викликана певну кількість разів.
Наприклад, нехай у вас є функція drinkEach(drink, Array<flavor>), яка приймає функцію drink та викликає її для масиву переданих напоїв. Ви можете захотіти перевірити, що передана функція була викликана рівно вказану кількість разів. Це можна зробити наступним чином:
test('drinkEach drinks each drink', () => { const drink = jest.fn(); drinkEach(drink, ['lemon', 'octopus']); expect(drink).toHaveBeenCalledTimes(2); });
.toHaveBeenCalledWith(arg1, arg2, ...) #
Також має псевдонім .toBeCalledWith()
Використовуйте .toHaveBeenCalledWith(), щоб переконатися, що мок функція була викликана зі вказаними аргументами.
Наприклад, нехай ви можете зареєструвати напій з допомогою функції register(), а функція applyToAll(f) повинна застосувати функцію f до всіх зареєстрованих напоїв. Щоб переконатися, що це працює, ви можете написати:
test('registration applies correctly to orange La Croix', () => { const beverage = new LaCroix('orange'); register(beverage); const f = jest.fn(); applyToAll(f); expect(f).toHaveBeenCalledWith(beverage); });
.toHaveBeenLastCalledWith(arg1, arg2, ...) #
Також має псевдонім .lastCalledWith(arg1, arg2, ...)
Ви можете використати .toHaveBeenLastCalledWith, щоб перевірити аргументи, з якими мок функція була викликана востаннє. Наприклад, нехай у вас є функція applyToAllFlavors(f), яка застосовує функцію f до набору смаків і ви хочете переконатися, що коли ви її викличите, то останній смак, з яким вона буде працювати - це 'mango'. Ви можете написати:
test('applying to all flavors does mango last', () => { const drink = jest.fn(); applyToAllFlavors(drink); expect(drink).toHaveBeenLastCalledWith('mango'); });
.toBeCloseTo(number, numDigits) #
Використання суворого порівняння для чисел з плаваючою кмою - це погана ідея. Через проблему округлення, інтуітивно правильне твердження не буде виконуватися. Наприклад наступний тест виконається з помилкою:
test('adding works sanely with simple decimals', () => { expect(0.2 + 0.1).toBe(0.3); // Помилка! });
Тут буде помилка, оскільки 0.2 + 0.1 в JavaScript насправді дорівнює 0.30000000000000004.
Тому краще використовувати .toBeCloseTo. Використовуйте параметр numDigits, щоб вказувати як багато знаків після коми перевіряти. Наприклад, якщо ви хочете переконатися, що 0.2 + 0.1 дорівнює 0.3 з точністю до 5 знаків після коми, ви можете використати наступний тест:
test('adding works sanely with simple decimals', () => { expect(0.2 + 0.1).toBeCloseTo(0.3, 5); });
Значення numDigits за замовчуванням — 2, що зазвичай достатньо для більшості випадків.
.toBeDefined() #
Висористовуйте .toBeDefined(), щоб переірити, що змінна визначена. Наприклад, якщо ви хочете перевірити, що функція fetchNewFlavorIdea() щось повертає, ви можете написати:
test('there is a new flavor idea', () => { expect(fetchNewFlavorIdea()).toBeDefined(); });
Ви також можете написати expect(fetchNewFlavorIdea()).not.toBe(undefined), але хорошою практикою є уникати прямого використання undefined в коді.
.toBeFalsy() #
Використовуйте .toBeFalsy(), коли вам не важливо, яким є значення і ви всього лише хочете переконатися, що значення приводиться до false в булевому контексті. Наприклад, нехай у вас є наступний код:
drinkSomeLaCroix(); if (!getErrors()) { drinkMoreLaCroix(); }
Вас може не цікавити, яке саме значення повертає getErrors. Це може бути false, null чи `` — ваш код все одно буде працювати. Отже, якщо в ихочете перевірити, що немає помилок після вживання Ла-Круа, ви можете написати:
test('drinking La Croix does not lead to errors', () => { drinkSomeLaCroix(); expect(getErrors()).toBeFalsy(); });
В JavaScript існує шість значень, які приводяться до false в булевому контексті: false, `,'',null,undefinedіNaN. Все інше приводиться доtrue`.
.toBeGreaterThan(number) #
Для порівняння чисел з плаваючою комою, ви можете використовувати toBeGreaterThan. Наприклад, якщо ви хочете протестувати, що ouncesPerCan() повертає значення, більше за 10, напишіть:
test('ounces per can is more than 10', () => { expect(ouncesPerCan()).toBeGreaterThan(10); });
.toBeGreaterThanOrEqual(number) #
Для порівняння чисел з плаваючою комою, ви можете використовувати toBeGreaterThanOrEqual. Наприклад, якщо ви хочете протестувати, що ouncesPerCan() повертає щонайменше 12, напишіть:
test('ounces per can is at least 12', () => { expect(ouncesPerCan()).toBeGreaterThanOrEqual(12); });
.toBeLessThan(number) #
Для порівняння чисел з плаваючою комою, ви можете використовувати toBeLessThan. Наприклад, якщо ви хочете протестувати, що ouncesPerCan() повертає значення, менше за 10, напишіть:
test('ounces per can is less than 20', () => { expect(ouncesPerCan()).toBeLessThan(20); });
.toBeLessThanOrEqual(number) #
Для порівняння чисел з плаваючою комою, ви можете використовувати toBeLessThanOrEqual. Наприклад, якщо ви хочете протестувати, що ouncesPerCan() повертає щонайбільше 12, напишіть:
test('ounces per can is at most 12', () => { expect(ouncesPerCan()).toBeLessThanOrEqual(12); });
.toBeInstanceOf(Class) #
Використовуйте .toBeInstanceOf(Class), щоб перевірити, що об’єкт є екземпляром певного класу. Цей матчер використовує instanceof всередині.
class A {} expect(new A()).toBeInstanceOf(A); expect(() => {}).toBeInstanceOf(Function); expect(new A()).toBeInstanceOf(Function); // помилка
.toBeNull() #
.toBeNull() — це те ж саме, що і .toBe(null), але має трохи краще повідомлення про помилку. Тож використовуйте .toBeNull(), коли ви хочете перевірити, що якесь значення дорівнює null.
function bloop() { return null; } test('bloop returns null', () => { expect(bloop()).toBeNull(); });
.toBeTruthy() #
Використовуйте . toBeTruthy(), коли вам не важливо, яким є значення і ви всього лише хочете переконатися, що значення приводиться до true в булевому контексті. Наприклад, нехай у вас є наступний код:
drinkSomeLaCroix(); if (thirstInfo()) { drinkMoreLaCroix(); }
Вас може не цікавити, яке саме значення повертає thirstInfo. Це може бути true або складний об’єкт — ваш код все одно буде працювати. Тому, якщо ви просто хочете перевірити, що результат thirstInfo буде приведено до true, ви можете написати:
test('drinking La Croix leads to having thirst info', () => { drinkSomeLaCroix(); expect(thirstInfo()).toBeTruthy(); });
В JavaScript існує шість значень, які приводяться до false в булевому контексті: false, `,'',null,undefinedіNaN. Все інше приводиться доtrue`.
.toBeUndefined() #
Висористовуйте .toBeUndefined(), щоб переірити, що змінна не визначена. Наприклад, якщо ви хочете перевірити, що функція bestDrinkForFlavor(flavor) повертає undefined, якщо їй передати смак 'octopus':
test('the best drink for octopus flavor is undefined', () => { expect(bestDrinkForFlavor('octopus')).toBeUndefined(); });
Ви також можете написати expect(bestDrinkForFlavor()).toBe(undefined), але хорошою практикою є уникати прямого використання undefined в коді.
.toContain(item) #
Використовуйте .toContain, коли ви хочете перевірити, що елемент присутній у списку. Для порівняння з елементами списку, цей метод використовує === — суворе порівняння.
Наприклад, якщо getAllFlavors() повертає список смаків і ви хчете переконатися, що lime присутній в цьому списку, ви можете написати:
test('the flavor list contains lime', () => { expect(getAllFlavors()).toContain('lime'); });
.toContainEqual(item) #
Використовуйте .toContainEqual, коли ви хочете перевірити, що елемент присутній у списку. Для порівняння елементів цей метод рекурсивно перевіряє рівність усіх полів, замість порівняння самих об’єктів.
describe('my beverage', () => { test('is delicious and not sour', () => { const myBeverage = {delicious: true, sour: false}; expect(myBeverages()).toContainEqual(myBeverage); }); });
.toEqual(value) #
Використовуйте .toEqual, коли ви хочете перевірити, що два об’єкти мають однакове значення. Цей матчер рекурсивно порівнує всі поля об’єктів, замість перевірки їх рівності. Така перевірка також відома, як глибоке порівняння. Наприклад, toEqual і toBe поводяться по-різному в наступному наборі тестів, тому всі тести проходять успішно:
const can1 = { flavor: 'grapefruit', ounces: 12, }; const can2 = { flavor: 'grapefruit', ounces: 12, }; describe('the La Croix cans on my desk', () => { test('have all the same properties', () => { expect(can1).toEqual(can2); }); test('are not the exact same can', () => { expect(can1).not.toBe(can2); }); });
Примітка:
.toEqualне виконує порівняння на глибоку рівність для двох об’єктів помилок. Порівнюються лише їх властивостіmessage. Рекомендується використовувати матчер.toThrowдля тестування об’єктів помилок.
.toHaveLength(number) #
Використовуйте .toHaveLength, щоб перевірити, що об’єкт має властивість .length і вона дорівнює певному числовому значенню.
Це особливо корисно для перевірки розміру масивів або довжини рядків.
expect([1, 2, 3]).toHaveLength(3); expect('abc').toHaveLength(3); expect('').not.toHaveLength(5);
.toMatch(regexpOrString) #
Використовуйте .toMatch, щоб перевірити, що рядок відповідає регулярному виразу.
Наприклад, ви можете не знати точно, що повертає essayOnTheBestFlavor(), але ви знаєте, що це досить довгий рядок і він повинен містити в собі рядок grapefruit. Ви можете протестувати це так:
describe('an essay on the best flavor', () => { test('mentions grapefruit', () => { expect(essayOnTheBestFlavor()).toMatch(/grapefruit/); expect(essayOnTheBestFlavor()).toMatch(new RegExp('grapefruit')); }); });
Цей матчер також приймає рядок, який він намагатиметься знайти:
describe('grapefruits are healthy', () => { test('grapefruits are a fruit', () => { expect('grapefruits').toMatch('fruit'); }); });
.toMatchObject(object) #
Використовуйте .toMatchObject, щоб перевірити, що JavaScript об’єкт відповідає підмножині властивостей очікуваного об’єкту. Він відповідає отриманому об’єкту, який місить властивості, яких немає у очікуваному об’єкті.
Ви можете передати масив об’єктів. В такому випадку метод поверне true тільки якщо кожен з об’єктів масиву проходить сходиться (у сенсі toMatchObject, який описаний вище) з відповідним об’єктом очікуваного масиву. Це корисно, якщо в ихочете перевірити, що два масиви збігаються за кількістю елементів на противагу arrayContaining, який дозволяє додаткові елементи в отриманому масиві.
Ви можете поівнювати властивості зі значеннями або з матчерами.
const houseForSale = { bath: true, bedrooms: 4, kitchen: { amenities: ['oven', 'stove', 'washer'], area: 20, wallColor: 'white', }, }; const desiredHouse = { bath: true, kitchen: { amenities: ['oven', 'stove', 'washer'], wallColor: expect.stringMatching(/white|yellow/), }, }; test('the house has my desired features', () => { expect(houseForSale).toMatchObject(desiredHouse); });
describe('toMatchObject applied to arrays arrays', () => { test('the number of elements must match exactly', () => { expect([ { foo: 'bar' }, { baz: 1 } ]).toMatchObject([ { foo: 'bar' }, { baz: 1 } ]); }); // .arrayContaining "matches a received array which contains elements that are *not* in the expected array" test('.toMatchObject does not allow extra elements', () => { expect([ { foo: 'bar' }, { baz: 1 } ]).toMatchObject([ { foo: 'bar' } ]); }); test('.toMatchObject is called for each elements, so extra object properties are okay', () => { expect([ { foo: 'bar' }, { baz: 1, extra: 'quux' } ]).toMatchObject([ { foo: 'bar' }, { baz: 1 } ]); }); });
.toHaveProperty(keyPath, value) #
Використовуйте .toHaveProperty, щоб перевірити, чи властивість за заданим в keyPath посиланням існує для об’єкта. Для перевірки вкладених властивостей об’єкта, використовуйте запис через крапку для вказання назви вкладених полів.
Опціонально, ви можете вказати значення value, яке має містити властивість keyPath цільового об’єкту. Цей матчер використовує глибоке порівняння (як toEqual()) і рекурсивно перевіряє рівність усіх полів.
Наступий приклад містить об’єкт houseForSale з двома вкладеними властивостями. Ми використовуємо toHaveProperty, щоб перевірити наявність і значення різних властивостей об’єкта.
// об’єкт, що містить властивості будинку, які потрібно протестувати const houseForSale = { bath: true, bedrooms: 4, kitchen: { amenities: ['oven', 'stove', 'washer'], area: 20, wallColor: 'white', }, }; test('this house has my desired features', () => { // Simple Referencing expect(houseForSale).toHaveProperty('bath'); expect(houseForSale).toHaveProperty('bedrooms', 4); expect(houseForSale).not.toHaveProperty('pool'); // Deep referencing using dot notation expect(houseForSale).toHaveProperty('kitchen.area', 20); expect(houseForSale).toHaveProperty('kitchen.amenities', [ 'oven', 'stove', 'washer', ]); expect(houseForSale).not.toHaveProperty('kitchen.open'); });
.toMatchSnapshot(optionalString) #
Цей матчер дозволяє переконатися, що значення співпадає з останнім знімком. Зверніться до тестування з допомогою знімків для додаткової інформації.
Ви також можете вказати опціональне ім’я знімка. Інакше, ім’я буде взято з назви тесту.
Примітка: хоча тестування з допомогою знімків найчастіше використовується для React компонентів, будь-яке значення, яке можна серіалізувати, може бути використане як знімок.
.toThrow(error) #
Також має псевдонім . toThrowError(error)
Використовуйте .toThrow, щоб переконатися, що функція викликає помилку під час виконання. Наприклад, якщо ми хочемо перевірити, що drinkFlavor('octopus') викликає помилку через те, що смак восминога занадто огидний для пиття, ми можемо написати:
test('throws on octopus', () => { expect(() => { drinkFlavor('octopus'); }).toThrow(); });
Якщо ви хочете перевірити, що викликається конкретна помилка, ви можете вказати аргумент для toThrow. Аргументом може бути рядок повідомлення про помилку, клас помилки або регулярний вираз, якому має відповідати помилка. Наприклад, нехай функція drinkFlavor написана так:
function drinkFlavor(flavor) { if (flavor == 'octopus') { throw new DisgustingFlavorError('yuck, octopus flavor'); } // Робіть інші речі }
Ми можемо протестувати, що вона викликає помилку кількома способами:
test('throws on octopus', () => { function drinkOctopus() { drinkFlavor('octopus'); } // Перевірка точного співпадіння повідомлення про помилку expect(drinkOctopus).toThrowError('yuck, octopus flavor'); // Перевірка, що рядок "yuck" присутній в повідомленні про помилку expect(drinkOctopus).toThrowError(/yuck/); // Перевірка, що помилка має тип DisgustingFlavorError expect(drinkOctopus).toThrowError(DisgustingFlavorError); });
.toThrowErrorMatchingSnapshot() #
Використовуйте .toThrowErrorMatchingSnapshot, щоб протестувати, що функція викликає помилку під час виконання, яка співпадає з останнім знімком. Наприклад, нехай у вас є функція drinkFlavor, яка викликає помилку, коли отримує смак 'octopus', і вона написана так:
function drinkFlavor(flavor) { if (flavor == 'octopus') { throw new DisgustingFlavorError('yuck, octopus flavor'); } // Робіть інші речі }
Тест для цієї функції виглядатиме наступним чином:
test('throws on octopus', () => { function drinkOctopus() { drinkFlavor('octopus'); } expect(drinkOctopus).toThrowErrorMatchingSnapshot(); });
І він створить наступний знімок:
exports[`drinking flavors throws on octopus 1`] = `"yuck, octopus flavor"`;
Ознайомтеся з розділом Тестування дерева React за допомогою знімків для додаткової інформації про тестування зі знімками.