Использование assert

Mocha — это популярный фреймворк для тестирования в JavaScript, предоставляющий мощный набор инструментов для создания, выполнения и анализа тестов. Одним из ключевых элементов Mocha является библиотека утверждений, с помощью которой можно проверять правильность работы тестируемого кода. В этом контексте библиотека assert представляет собой стандартный способ выполнения проверок в тестах, позволяя удобно проверять ожидаемые результаты.

Что такое assert?

assert — это библиотека для создания утверждений, которая позволяет проверять, соответствуют ли значения некоторым ожиданиям. В Mocha она используется для выполнения различных типов проверок, таких как сравнение значений, проверки типов данных, наличие объектов или свойств и другие распространенные условия. Эти проверки помогают убедиться, что тестируемый код работает корректно и возвращает правильные результаты.

Основные методы assert позволяют проверять:

Равенство значений.
Существование значений.
Типы данных.
Ошибки и исключения.

Основные методы assert

assert.equal(actual, expected)

Проверяет, равны ли два значения. Если они не равны, тест не пройдет.
```
assert.equal(2 + 2, 4); // Успешный тест
assert.equal(2 + 2, 5); // Ошибка: 2 + 2 не равно 5
```
Этот метод выполняет строгую проверку на равенство. Для проверки можно использовать любые типы данных, и если значения не совпадают, будет выброшено исключение.
assert.notEqual(actual, expected)

Проверяет, не равны ли два значения. Если они равны, тест не пройдет.
```
assert.notEqual(2 + 2, 5); // Успешный тест
assert.notEqual(2 + 2, 4); // Ошибка: 2 + 2 равно 4
```
Полезен для ситуаций, когда ожидается, что два значения не должны быть равными.
assert.deepEqual(actual, expected)

Проводит глубокую проверку на равенство объектов или массивов. Это значит, что метод проверяет не только ссылки на объекты, но и их содержимое.
```
assert.deepEqual({a: 1, b: 2}, {a: 1, b: 2}); // Успешный тест
assert.deepEqual({a: 1, b: 2}, {a: 1, b: 3}); // Ошибка
```
Этот метод особенно полезен при работе с массивами или объектами, когда важно сравнивать их содержимое, а не ссылки.
assert.notDeepEqual(actual, expected)

Проверяет, что объекты или массивы не равны, сравнивая их содержимое.
```
assert.notDeepEqual({a: 1, b: 2}, {a: 1, b: 3}); // Успешный тест
assert.notDeepEqual({a: 1, b: 2}, {a: 1, b: 2}); // Ошибка
```
assert.strictEqual(actual, expected)

Проверяет строгое равенство между значениями, включая тип данных.
```
assert.strictEqual(2 + 2, 4); // Успешный тест
assert.strictEqual(2 + '2', '22'); // Успешный тест
assert.strictEqual(2 + '2', 22); // Ошибка: '22' !== 22
```
В отличие от assert.equal, этот метод учитывает и тип данных, то есть проверка проходит только если значения равны и по типу, и по значению.
assert.notStrictEqual(actual, expected)

Проверяет, что два значения не равны с учетом их типов данных.
```
assert.notStrictEqual(2 + 2, '4'); // Успешный тест
assert.notStrictEqual(2 + '2', '22'); // Ошибка
```
assert.isTrue(value)

Проверяет, что переданное значение является истинным (true). Для этого значение должно быть истинным булевым значением или выражением, которое при приведении к логическому типу дает true.
```
assert.isTrue(1 === 1); // Успешный тест
assert.isTrue(0); // Ошибка: 0 — это falsy-значение
```
assert.isFalse(value)

Проверяет, что переданное значение является ложным (false). Это значит, что значение должно быть false или любым значением, которое при приведении к булевому типу дает false.
```
assert.isFalse(0); // Успешный тест
assert.isFalse(1); // Ошибка: 1 — это truthy-значение
```

assert.isNull(value)

Проверяет, что переданное значение равно null.

assert.isNull(null); // Успешный тест
assert.isNull(undefined); // Ошибка: undefined не равно null

assert.isNotNull(value)

Проверяет, что переданное значение не равно null.

assert.isNotNull(5); // Успешный тест
assert.isNotNull(null); // Ошибка: null не должно быть значением

assert.isUndefined(value)

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

assert.isUndefined(undefined); // Успешный тест
assert.isUndefined(0); // Ошибка: 0 не равно undefined

assert.isDefined(value)

Проверяет, что значение определено, то есть оно не равно undefined.

assert.isDefined(5); // Успешный тест
assert.isDefined(undefined); // Ошибка: значение не должно быть undefined

assert.throws(block, [error], [message])

Проверяет, что при выполнении кода возникает ошибка. Этот метод полезен для тестирования функций, которые должны выбрасывать исключения.
```
assert.throws(() => { throw new Error('Error occurred'); }, /Error/); // Успешный тест
assert.throws(() => { }, /Error/); // Ошибка: исключение не было выброшено
```
Также можно указать регулярное выражение для проверки текста ошибки.

assert.doesNotThrow(block, [error], [message])

Проверяет, что при выполнении кода не возникает ошибка.

assert.doesNotThrow(() => { return 1 + 1; }); // Успешный тест
assert.doesNotThrow(() => { throw new Error('Error occurred'); }); // Ошибка: исключение было выброшено

Использование assert в тестах Mocha

Mocha предоставляет тестовые функции, такие как describe, it, которые можно комбинировать с утверждениями assert для проверки логики кода.

Пример использования:

const assert = require('assert');

describe('Сложение', () => {
  it('должно возвращать правильный результат для 2 + 2', () => {
    assert.equal(2 + 2, 4);
  });

  it('не должно быть равным 5', () => {
    assert.notEqual(2 + 2, 5);
  });
});

describe('Массивы', () => {
  it('должны быть равными', () => {
    assert.deepEqual([1, 2, 3], [1, 2, 3]);
  });
});

Этот пример показывает, как с помощью assert можно проверять логику работы сложения чисел и сравнивать массивы.

Заключение

assert является важным инструментом в арсенале разработчиков, использующих Mocha для тестирования. Он предоставляет широкие возможности для проверки различных типов данных и условий, позволяя гарантировать правильность работы кода. Тесты, написанные с использованием assert, становятся понятными, читаемыми и легко поддерживаемыми, что делает процесс тестирования простым и эффективным.