Утверждения и матчеры

В процессе написания тестов для JavaScript с использованием Jest важным моментом является проверка правильности работы кода. Для этого в Jest предусмотрены утверждения и матчеры. Эти инструменты позволяют сравнивать фактические значения с ожидаемыми и определять, прошел ли тест успешно.

Утверждения в Jest

Утверждения в Jest — это методы, которые проверяют, соответствуют ли результаты выполнения функций или значений ожиданиям. Основной принцип работы утверждений — это проверка истинности или ложности утверждений, основанных на сравнении значений. Если утверждение истинно, тест проходит, если ложь — тест не проходит.

Основные методы утверждений

  • toBe Метод toBe используется для проверки примитивных значений на строгую идентичность (с использованием оператора ===). Он проверяет, равны ли два значения.

    test('сравнение чисел', () => {
  expect(5).toBe(5); // Пройдено
  expect(5).toBe(6); // Ошибка
});

  • toEqual Метод toEqual предназначен для глубокого сравнения объектов и массивов. Он проверяет, что все свойства объекта или элементы массива совпадают.

    test('сравнение объектов', () => {
  const obj1 = { name: 'Alice', age: 25 };
  const obj2 = { name: 'Alice', age: 25 };
  expect(obj1).toEqual(obj2); // Пройдено
  obj1.age = 26;
  expect(obj1).toEqual(obj2); // Ошибка
});

  • toBeNull Используется для проверки, что значение является null.

    test('проверка на null', () => {
  const value = null;
  expect(value).toBeNull(); // Пройдено
  expect(value).not.toBeNull(); // Ошибка
});

  • toBeUndefined Проверяет, что значение равно undefined.

    test('проверка на undefined', () => {
  let value;
  expect(value).toBeUndefined(); // Пройдено
  value = 5;
  expect(value).toBeUndefined(); // Ошибка
});

  • toBeDefined Проверяет, что значение определено (не undefined).

    test('проверка на определенность', () => {
  const value = 5;
  expect(value).toBeDefined(); // Пройдено
  let value2;
  expect(value2).toBeDefined(); // Ошибка
});

  • toBeTruthy и toBeFalsy Эти методы проверяют, что значение является истинным или ложным, соответственно. Они основываются на преобразовании значения в булевый тип.

    test('проверка истинности и ложности', () => {
  const value = 1;
  expect(value).toBeTruthy(); // Пройдено
  const value2 = 0;
  expect(value2).toBeFalsy(); // Пройдено
});

  • toContain Используется для проверки, что массив или строка содержит указанный элемент или подстроку.

    test('проверка на вхождение', () => {
  const array = [1, 2, 3];
  expect(array).toContain(2); // Пройдено
  expect(array).toContain(4); // Ошибка

  const string = 'Hello World';
  expect(string).toContain('World'); // Пройдено
  expect(string).toContain('world'); // Ошибка
});

Матчеры в Jest

Матчеры — это функции, которые используются в утверждениях для определения, соответствует ли результат выполненной операции ожидаемому значению. Jest поставляется с набором стандартных матчеров, которые покрывают большинство потребностей при тестировании.

Типы матчеров

  • toBe и toEqual Как уже было сказано, toBe используется для строгих сравнений, а toEqual — для глубоких сравнений объектов и массивов.

  • toBeGreaterThan и toBeLessThan Эти матчеры сравнивают два числа на большее или меньшее значение. Они полезны для тестирования числовых данных.

    test('сравнение чисел', () => {
  expect(10).toBeGreaterThan(5); // Пройдено
  expect(10).toBeLessThan(15); // Пройдено
  expect(10).toBeGreaterThan(20); // Ошибка
});

  • toBeCloseTo Используется для проверки, что два числа близки друг к другу с заданной точностью. Полезно для работы с числами с плавающей запятой.

    test('проверка на точность', () => {
  expect(0.1 + 0.2).toBeCloseTo(0.3, 5); // Пройдено
  expect(0.1 + 0.2).toBeCloseTo(0.3, 15); // Ошибка
});

  • toMatch Этот матчеры используется для проверки строк с использованием регулярных выражений. Он полезен для проверки того, соответствует ли строка определенному шаблону.

    test('проверка строки на соответствие регулярному выражению', () => {
  const string = 'test@example.com';
  expect(string).toMatch(/\S+@\S+\.\S+/); // Пройдено
  expect(string).toMatch(/abc/); // Ошибка
});

  • toHaveLength Применяется для проверки длины строк, массивов или любых других объектов, у которых можно измерить длину.

    test('проверка длины массива', () => {
  const array = [1, 2, 3];
  expect(array).toHaveLength(3); // Пройдено
  const string = 'hello';
  expect(string).toHaveLength(5); // Пройдено
});

  • toHaveProperty Проверяет, что объект содержит свойство с заданным именем, а также позволяет указать его значение.

    test('проверка наличия свойства объекта', () => {
  const person = { name: 'Alice', age: 25 };
  expect(person).toHaveProperty('name'); // Пройдено
  expect(person).toHaveProperty('name', 'Alice'); // Пройдено
  expect(person).toHaveProperty('age', 30); // Ошибка
});

  • toThrow Этот матчеры проверяет, что при выполнении функции будет выброшено исключение.

    test('проверка на выброс исключения', () => {
  const func = () => {
    throw new Error('Ошибка!');
  };
  expect(func).toThrow('Ошибка!'); // Пройдено
  expect(func).toThrow(); // Пройдено
  expect(func).toThrow('Не ошибка!'); // Ошибка
});

Комбинирование утверждений и матчеров

Очень часто в процессе написания тестов возникает необходимость комбинировать несколько утверждений для проверки различных условий. Jest позволяет применять несколько матчеров подряд для детальной проверки значений, например:

test('проверка объекта', () => {
  const obj = { name: 'Alice', age: 25 };
  expect(obj).toHaveProperty('name');
  expect(obj.name).toBe('Alice');
  expect(obj.age).toBeGreaterThan(20);
});

Такой подход позволяет убедиться в корректности работы кода на нескольких уровнях.

Использование с асинхронным кодом

Jest также поддерживает асинхронные тесты. В случае с асинхронными операциями для проверки результатов можно использовать такие методы как resolves и rejects.

  • resolves Применяется для асинхронных функций, которые должны вернуть значение. Например:

    test('проверка асинхронного кода', async () => {
  const promise = Promise.resolve(42);
  await expect(promise).resolves.toBe(42); // Пройдено
});

  • rejects Используется для асинхронных функций, которые должны выбросить ошибку.

    test('проверка на выброс ошибки', async () => {
  const promise = Promise.reject(new Error('Ошибка!'));
  await expect(promise).rejects.toThrow('Ошибка!'); // Пройдено
});

Заключение

Понимание работы утверждений и матчеров является ключевым аспектом при написании тестов с использованием Jest. Эти инструменты позволяют гибко проверять различные аспекты работы кода, от примитивных значений до сложных объектов и асинх

Оглавление