Перейти к содержанию

Тестирование

v18.x.x

Стабильность: 2 – Стабильная

АПИ является удовлетворительным. Совместимость с NPM имеет высший приоритет и не будет нарушена кроме случаев явной необходимости.

Модуль node:assert предоставляет набор функций утверждения для проверки инвариантов.

Режим строгого утверждения

В режиме строгого утверждения нестрогие методы ведут себя как соответствующие им строгие методы. Например, assert.deepEqual() будет вести себя как assert.deepStrictEqual().

В режиме strict assertion сообщения об ошибках для объектов отображают diff. В режиме legacy assertion сообщения об ошибках для объектов отображают сами объекты, часто в усеченном виде.

Чтобы использовать режим строгого утверждения:

1
import { strict as assert } from 'node:assert';

1
const assert = require('node:assert').strict;

1
import assert from 'node:assert/strict';

1
const assert = require('node:assert/strict');

Пример разницы ошибок:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import { strict as assert } from 'node:assert';


assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]]);
// AssertionError: Ожидается, что входные данные будут строго равны по глубине:
// + фактические - ожидаемые ... Строки пропущены
//
// [
// [
// ...
// 2,
// + 3
// - '3'
// ],
// ...
// 5
// ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
const assert = require('node:assert/strict');

assert.deepEqual(
    [[[1, 2, 3]], 4, 5],
    [[[1, 2, '3']], 4, 5]
);
// AssertionError: Ожидается, что входные данные будут строго равны по глубине:
// + фактические - ожидаемые ... Строки пропущены
//
// [
// [
// ...
// 2,
// + 3
// - '3'
// ],
// ...
// 5
// ]

Чтобы отключить цвета, используйте переменные окружения NO_COLOR или NODE_DISABLE_COLORS. Это также отключит цвета в REPL. Подробнее о поддержке цветов в терминальных средах читайте в документации по tty getColorDepth().

Устаревший режим утверждения

Наследный режим утверждения использует оператор == в:

Чтобы использовать унаследованный режим утверждения:

1
import assert from 'node:assert';

1
const assert = require('node:assert');

Наследие режима assertion может привести к неожиданным результатам, особенно при использовании assert.deepEqual():

1
2
3
// ВНИМАНИЕ: Это не приводит к ошибке AssertionError
// в унаследованном режиме утверждения!
assert.deepEqual(/a/gi, new Date());

Класс: assert.AssertionError

Указывает на неудачу утверждения. Все ошибки, выбрасываемые модулем node:assert, будут экземплярами класса AssertionError.

new assert.AssertionError(options)

  • options <Object>
    • message <string> Если предоставлено, сообщение об ошибке устанавливается в это значение.
    • actual <any> Свойство actual экземпляра ошибки.
    • expected <any> Свойство expected экземпляра ошибки.
    • operator <string> Свойство operator для экземпляра ошибки.
    • stackStartFn <Function> Если задано, то в сгенерированной трассировке стека будут опущены кадры до этой функции.

Подкласс Error, который указывает на неудачу утверждения.

Все экземпляры содержат встроенные свойства Error (message и name) и:

  • actual <any> Устанавливается в аргумент actual для таких методов, как assert.strictEqual().
  • expected <any> Устанавливается на ожидаемое значение для таких методов, как assert.strictEqual().
  • generatedMessage <boolean> Указывает, было ли сообщение сгенерировано автоматически (true) или нет.
  • code <string> Значение всегда ERR_ASSERTION, чтобы показать, что ошибка является ошибкой утверждения.
  • operator <string> Устанавливается в переданное значение оператора.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
import assert from 'node:assert';

// Generate an AssertionError to compare the error message later:
const { message } = new assert.AssertionError({
    actual: 1,
    expected: 2,
    operator: 'strictEqual',
});

// Verify error output:
try {
    assert.strictEqual(1, 2);
} catch (err) {
    assert(err instanceof assert.AssertionError);
    assert.strictEqual(err.message, message);
    assert.strictEqual(err.name, 'AssertionError');
    assert.strictEqual(err.actual, 1);
    assert.strictEqual(err.expected, 2);
    assert.strictEqual(err.code, 'ERR_ASSERTION');
    assert.strictEqual(err.operator, 'strictEqual');
    assert.strictEqual(err.generatedMessage, true);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
const assert = require('node:assert');

// Generate an AssertionError to compare the error message later:
const { message } = new assert.AssertionError({
    actual: 1,
    expected: 2,
    operator: 'strictEqual',
});

// Verify error output:
try {
    assert.strictEqual(1, 2);
} catch (err) {
    assert(err instanceof assert.AssertionError);
    assert.strictEqual(err.message, message);
    assert.strictEqual(err.name, 'AssertionError');
    assert.strictEqual(err.actual, 1);
    assert.strictEqual(err.expected, 2);
    assert.strictEqual(err.code, 'ERR_ASSERTION');
    assert.strictEqual(err.operator, 'strictEqual');
    assert.strictEqual(err.generatedMessage, true);
}

Класс: assert.CallTracker

Стабильность: 1 – Экспериментальная

Фича изменяется и не допускается флагом командной строки. Может быть изменена или удалена в последующих версиях.

Эта функция в настоящее время является экспериментальной, и ее поведение может измениться.

new assert.CallTracker()

Создает новый объект CallTracker, который можно использовать для отслеживания того, вызывались ли функции определенное количество раз. Для проверки необходимо вызвать tracker.verify(). Обычная схема - вызвать его в обработчике process.on('exit').

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import assert from 'node:assert';
import process from 'node:process';

const tracker = new assert.CallTracker();

function func() {}

// callsfunc() должна быть вызвана ровно 1 раз перед tracker.verify().
const callsfunc = tracker.calls(func, 1);

callsfunc();

// Вызывает tracker.verify() и проверяет, все ли функции tracker.calls()
// были вызваны точное количество раз.
process.on('exit', () => {
    tracker.verify();
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
const assert = require('node:assert');

const tracker = new assert.CallTracker();

function func() {}

// callsfunc() должен быть вызван ровно 1 раз перед tracker.verify().
const callsfunc = tracker.calls(func, 1);

callsfunc();

// Вызывает tracker.verify() и проверяет, все ли функции tracker.calls()
// были вызваны точное количество раз.
process.on('exit', () => {
    tracker.verify();
});

tracker.calls([fn][, exact])

  • fn <Function> По умолчанию: Безотказная функция.
  • exact <number> По умолчанию: 1.
  • Возвращает: <Function>, которая обертывает fn.

Ожидается, что функция-обертка будет вызвана ровно exact раз. Если на момент вызова tracker.verify() функция не была вызвана ровно точное количество раз, то tracker.verify() выдаст ошибку.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert';

// Создает трекер вызовов.
const tracker = new assert.CallTracker();

function func() {}

// Возвращает функцию, обертывающую func(), которая должна быть вызвана точное время
// перед tracker.verify().
const callsfunc = tracker.calls(func);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert');

// Создает трекер вызовов.
const tracker = new assert.CallTracker();

function func() {}

// Возвращает функцию, обертывающую func(), которая должна быть вызвана точное время
// перед tracker.verify().
const callsfunc = tracker.calls(func);

tracker.getCalls(fn)

  • fn <Function>.

  • Возвращает: <Array> со всеми вызовами отслеживаемой функции.

  • Объект <Object>

    • thisArg <Object>
    • arguments <Array> аргументы, переданные отслеживаемой функции.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import assert from 'node:assert';

const tracker = new assert.CallTracker();

function func() {}
const callsfunc = tracker.calls(func);
callsfunc(1, 2, 3);

assert.deepStrictEqual(tracker.getCalls(callsfunc), [
    { thisArg: this, arguments: [1, 2, 3] },
]);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
const assert = require('node:assert');

// Создает трекер вызовов.
const tracker = new assert.CallTracker();

function func() {}
const callsfunc = tracker.calls(func);
callsfunc(1, 2, 3);

assert.deepStrictEqual(tracker.getCalls(callsfunc), [
    { thisArg: this, arguments: [1, 2, 3] },
]);

tracker.report()

  • Возвращает: <Array> объектов, содержащих информацию о функциях-обертках, возвращаемых tracker.calls().
  • Объект <Object>
    • сообщение <string>
    • actual <number> Фактическое количество раз, когда функция была вызвана.
    • expected <number> Ожидаемое количество вызовов функции.
    • operator <string> Имя функции, которая обернута.
    • stack <Object> Трассировка стека функции.

Массивы содержат информацию об ожидаемом и фактическом количестве вызовов функций, которые не были вызваны ожидаемое количество раз.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import assert from 'node:assert';

// Создается трекер вызовов.
const tracker = new assert.CallTracker();

function func() {}

// Возвращает функцию, обертывающую func(), которая должна быть вызвана точное время
// перед tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Возвращает массив, содержащий информацию о callfunc()
tracker.report();
// [
// {
// сообщение: 'Ожидалось, что функция func будет выполнена 2 раза(а), но было выполнено...
// выполнена 0 раз(ов).',
// фактическое: 0,
// ожидаемое: 2,
// оператор: 'func',
// стек: трассировка стека
// }
// ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const assert = require('node:assert');

// Создает трекер вызовов.
const tracker = new assert.CallTracker();

function func() {}

// Возвращает функцию, обертывающую func(), которая должна быть вызвана точное время
// перед tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Возвращает массив, содержащий информацию о callfunc()
tracker.report();
// [
// {
// сообщение: 'Ожидалось, что функция func будет выполнена 2 раза(а), но было выполнено...
// выполнена 0 раз(ов).',
// фактическое: 0,
// ожидаемое: 2,
// оператор: 'func',
// стек: трассировка стека
// }
// ]

tracker.reset([fn])

  • fn <Function> отслеживаемая функция для сброса.

сбрасывает вызовы трекера вызовов. если отслеживаемая функция передана в качестве аргумента, вызовы будут сброшены для нее. если аргументы не переданы, все отслеживаемые функции будут сброшены.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import assert from 'node:assert';

const tracker = new assert.CallTracker();

function func() {}
const callsfunc = tracker.calls(func);

callsfunc();
// Tracker was called once
tracker.getCalls(callsfunc).length === 1;

tracker.reset(callsfunc);
tracker.getCalls(callsfunc).length === 0;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
const assert = require('node:assert');

function func() {}
const callsfunc = tracker.calls(func);

callsfunc();
// Tracker was called once
tracker.getCalls(callsfunc).length === 1;

tracker.reset(callsfunc);
tracker.getCalls(callsfunc).length === 0;

tracker.verify()

Просматривает список функций, переданных в tracker.calls(), и выдает ошибку для функций, которые не были вызваны ожидаемое количество раз.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import assert from 'node:assert';

// Создает трекер вызовов.
const tracker = new assert.CallTracker();

function func() {}

// Возвращает функцию, обертывающую func(), которая должна быть вызвана точное время
// перед tracker.verify().
const callsfunc = tracker.calls(func, 2);

callsfunc();

// Выбросит ошибку, так как callsfunc() была вызвана только один раз.
tracker.verify();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
const assert = require('node:assert');

// Создает трекер вызовов.
const tracker = new assert.CallTracker();

function func() {}

// Возвращает функцию, обертывающую func(), которая должна быть вызвана точное время
// перед tracker.verify().
const callsfunc = tracker.calls(func, 2);

callsfunc();

// Выбросит ошибку, так как callsfunc() была вызвана только один раз.
tracker.verify();

assert(value[, message])

  • value <any> Входные данные, которые проверяются на истинность.
  • message <string> | <Error>

Псевдоним assert.ok().

assert.deepEqual(actual, expected[, message])

Строгий режим утверждения.

Псевдоним assert.deepStrictEqual().

Режим утверждения Legacy.

Стабильность: 3 – Закрыто

Принимаются только фиксы, связанные с безопасностью, производительностью или баг-фиксы. Пожалуйста, не предлагайте изменений АПИ в разделе с таким индикатором, они будут отклонены.

Вместо этого используйте assert.deepStrictEqual().

Проверяет глубокое равенство между параметрами actual и expected. Вместо этого используйте assert.deepStrictEqual(). assert.deepEqual() может привести к неожиданным результатам.

Глубокое равенство означает, что перечислимые "собственные" свойства дочерних объектов также рекурсивно оцениваются по следующим правилам.

Детали сравнения

  • Примитивные значения сравниваются с помощью оператора ==, за исключением NaN. Оно считается идентичным, если обе стороны NaN.
  • Теги типов объектов должны быть одинаковыми.
  • Учитываются только перечислимые "собственные" свойства.
  • Error имена и сообщения всегда сравниваются, даже если это не перечислимые свойства.
  • Object wrappers сравниваются как объекты, так и развернутые значения.
  • Свойства Object сравниваются неупорядоченно.
  • Ключи Map и элементы Set сравниваются неупорядоченно.
  • Рекурсия останавливается, когда обе стороны различаются или обе стороны встречают круговую ссылку.
  • Реализация не проверяет [[Prototype]] объектов.
  • Свойства Symbol не сравниваются.
  • Сравнение WeakMap и WeakSet не опирается на их значения.
  • RegExp lastIndex, флаги и источник всегда сравниваются, даже если это не перечислимые свойства.

Следующий пример не вызывает AssertionError, потому что примитивы сравниваются с помощью оператора ==.

1
2
3
4
import assert from 'node:assert';
// ВНИМАНИЕ: Это не приводит к ошибке утверждения!

assert.deepEqual('+000000', false);

1
2
3
4
const assert = require('node:assert');
// ВНИМАНИЕ: Это не приводит к ошибке утверждения!

assert.deepEqual('+000000', false);

"Глубокое" равенство означает, что перечислимые "собственные" свойства дочерних объектов также оцениваются:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import assert from 'node:assert';

const obj1 = {
    a: {
        b: 1,
    },
};
const obj2 = {
    a: {
        b: 2,
    },
};
const obj3 = {
    a: {
        b: 1,
    },
};
const obj4 = { __proto__: obj1 };

assert.deepEqual(obj1, obj1);
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3);
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
const assert = require('node:assert');

const obj1 = {
    a: {
        b: 1,
    },
};
const obj2 = {
    a: {
        b: 2,
    },
};
const obj3 = {
    a: {
        b: 1,
    },
};
const obj4 = { __proto__: obj1 };

assert.deepEqual(obj1, obj1);
// OK

// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3);
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}

Если значения не равны, возникает AssertionError со свойством message, установленным равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.deepStrictEqual(actual, expected[, message])

Проверяет глубокое равенство между параметрами actual и expected. "Глубокое" равенство означает, что перечислимые "собственные" свойства дочерних объектов рекурсивно оцениваются также по следующим правилам.

Детали сравнения

  • Примитивные значения сравниваются с помощью Object.is().
  • Теги типов объектов должны быть одинаковыми.
  • [[Прототип]] объектов сравниваются с помощью оператора ===.
  • Учитываются только перечислимые "собственные" свойства.
  • Имена и сообщения Error всегда сравниваются, даже если они не являются перечислимыми свойствами.
  • Перечислимые собственные свойства Symbol также сравниваются.
  • Object wrappers сравниваются как объекты, так и развернутые значения.
  • Свойства Object сравниваются неупорядоченно.
  • Ключи Map и элементы Set сравниваются неупорядоченно.
  • Рекурсия прекращается, когда обе стороны различаются или обе стороны встречают круговую ссылку.
  • Сравнение WeakMap и WeakSet не зависит от их значений. Более подробную информацию см. ниже.
  • RegExp lastIndex, флаги и источник всегда сравниваются, даже если это не перечислимые свойства.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
import assert from 'node:assert/strict';

// This fails because 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// The following objects don't have own properties
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);

// Different [[Prototype]]:
assert.deepStrictEqual(object, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Different type tags:
assert.deepStrictEqual(date, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN);
// OK because Object.is(NaN, NaN) is true.

// Different unwrapped numbers:
assert.deepStrictEqual(new Number(1), new Number(2));
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'));
// OK because the object and the string are identical when unwrapped.

assert.deepStrictEqual(-0, -0);
// OK

// Different zeros:
assert.deepStrictEqual(0, -0);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol();
const symbol2 = Symbol();
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });
// OK, because it is the same symbol on both objects.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap();
const weakMap2 = new WeakMap([[{}, {}]]);
const weakMap3 = new WeakMap();
weakMap3.unequal = true;

assert.deepStrictEqual(weakMap1, weakMap2);
// OK, because it is impossible to compare the entries

// Fails because weakMap3 has a property that weakMap1 does not contain:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
const assert = require('node:assert/strict');

// This fails because 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// The following objects don't have own properties
const date = new Date();
const object = {};
const fakeDate = {};
Object.setPrototypeOf(fakeDate, Date.prototype);

// Different [[Prototype]]:
assert.deepStrictEqual(object, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Different type tags:
assert.deepStrictEqual(date, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN);
// OK because Object.is(NaN, NaN) is true.

// Different unwrapped numbers:
assert.deepStrictEqual(new Number(1), new Number(2));
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'));
// OK because the object and the string are identical when unwrapped.

assert.deepStrictEqual(-0, -0);
// OK

// Different zeros:
assert.deepStrictEqual(0, -0);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol();
const symbol2 = Symbol();
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 });
// OK, because it is the same symbol on both objects.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 });
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap();
const weakMap2 = new WeakMap([[{}, {}]]);
const weakMap3 = new WeakMap();
weakMap3.unequal = true;

assert.deepStrictEqual(weakMap1, weakMap2);
// OK, because it is impossible to compare the entries

// Fails because weakMap3 has a property that weakMap1 does not contain:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

Если значения не равны, возникает AssertionError со свойством message, установленным равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.doesNotMatch(string, regexp[, message])

Ожидает, что входная строка не будет соответствовать регулярному выражению.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert/strict';

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: Ожидалось, что входные данные не будут соответствовать ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.doesNotMatch('Я сдам', /different/);
// OK

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert/strict');

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: Ожидалось, что входные данные не будут соответствовать ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.doesNotMatch('Я сдам', /different/);
// OK

Если значения совпадают, или аргумент string имеет тип, отличный от string, то возникает ошибка AssertionError со свойством message, равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.doesNotReject(asyncFn[, error][, message])

Ожидает промис asyncFn или, если asyncFn является функцией, немедленно вызывает функцию и ожидает выполнения возвращенного промиса. Затем проверяется, что промис не был отклонен.

Если asyncFn является функцией и синхронно выбрасывает ошибку, assert.doesNotReject() вернет отвергнутое Promise с этой ошибкой. Если функция не возвращает промис, assert.doesNotReject() вернет отклоненный Promise с ошибкой ERR_INVALID_RETURN_VALUE. В обоих случаях обработчик ошибки пропускается.

Использование assert.doesNotReject() на самом деле бесполезно, потому что мало пользы от перехвата отказа и последующего повторного отказа. Вместо этого следует добавить комментарий к определенному пути кода, который не должен отклоняться, и сделать сообщения об ошибках как можно более выразительными.

Если указано, error может быть Class, RegExp или функцией проверки. Подробнее см. в assert.throws().

Помимо асинхронной природы await завершение ведет себя идентично assert.doesNotThrow().

1
2
3
4
5
import assert from 'node:assert/strict';

await assert.doesNotReject(async () => {
    throw new TypeError('Неверное значение');
}, SyntaxError);

1
2
3
4
5
6
7
const assert = require('node:assert/strict');

(async () => {
    await assert.doesNotReject(async () => {
        throw new TypeError('Неверное значение');
    }, SyntaxError);
})();

1
2
3
4
5
6
7
import assert from 'node:assert/strict';


assert.doesNotReject(Promise.reject(new TypeError('Wrong value'))))
  .then(() => {
    // ...
  });

1
2
3
4
5
6
7
const assert = require('node:assert/strict');


assert.doesNotReject(Promise.reject(new TypeError('Wrong value'))))
  .then(() => {
    // ...
  });

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

Утверждает, что функция fn не выбрасывает ошибку.

Использование assert.doesNotThrow() на самом деле бесполезно, потому что нет никакой пользы от перехвата ошибки и ее повторного выброса. Вместо этого следует добавить комментарий к определенному пути кода, который не должен выбрасывать ошибку, и сделать сообщения об ошибках как можно более выразительными.

Когда вызывается assert.doesNotThrow(), немедленно вызывается функция fn.

Если возникла ошибка, тип которой совпадает с типом, заданным параметром error, то возникает AssertionError. Если ошибка другого типа, или если параметр error не определен, то ошибка передается обратно вызывающей стороне.

Если указано, error может быть Class, RegExp или функцией проверки. Подробнее см. в assert.throws().

Например, следующее утверждение выбросит TypeError, потому что в утверждении нет соответствующего типа ошибки:

1
2
3
4
5
import assert from 'node:assert/strict';

assert.doesNotThrow(() => {
    throw new TypeError('Неверное значение');
}, SyntaxError);

1
2
3
4
5
const assert = require('node:assert/strict');

assert.doesNotThrow(() => {
    throw new TypeError('Неверное значение');
}, SyntaxError);

Однако, следующее приведет к AssertionError с сообщением 'Got unwanted exception...':

1
2
3
4
5
import assert from 'node:assert/strict';

assert.doesNotThrow(() => {
    throw new TypeError('Неверное значение');
}, TypeError);

1
2
3
4
5
const assert = require('node:assert/strict');

assert.doesNotThrow(() => {
    throw new TypeError('Неверное значение');
}, TypeError);

Если выброшен AssertionError и для параметра message указано значение, то значение message будет добавлено к сообщению AssertionError:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert/strict';

assert.doesNotThrow(
    () => {
        throw new TypeError('Wrong value');
    },
    /Wrong value/,
    'Whoops'
);
// Throws: AssertionError: Получено нежелательное исключение: Whoops

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert/strict');

assert.doesNotThrow(
    () => {
        throw new TypeError('Wrong value');
    },
    /Wrong value/,
    'Whoops'
);
// Throws: AssertionError: Получено нежелательное исключение: Whoops

assert.equal(actual, expected[, message])

Строгий режим утверждения.

Псевдоним assert.strictEqual().

Строгий режим утверждения

Стабильность: 3 – Закрыто

Принимаются только фиксы, связанные с безопасностью, производительностью или баг-фиксы. Пожалуйста, не предлагайте изменений АПИ в разделе с таким индикатором, они будут отклонены.

Вместо этого используйте assert.strictEqual().

Проверяет неглубокое, принудительное равенство между фактическим и ожидаемым параметрами, используя == оператор. Оператор NaN специально обрабатывается и рассматривается как идентичный, если обе стороны являются NaN.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
import assert from 'node:assert';

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// ОК, 1 == '1'
assert.equal(NaN, NaN);
// OK

assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
const assert = require('node:assert');

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// ОК, 1 == '1'
assert.equal(NaN, NaN);
// OK

assert.equal(1, 2);
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

Если значения не равны, возникает ошибка AssertionError со свойством message, равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.fail([message])

Выбрасывает AssertionError с предоставленным сообщением об ошибке или сообщением об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert/strict';

assert.fail();
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom');
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'));
// TypeError: need array

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert/strict');

assert.fail();
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom');
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'));
// TypeError: need array

Использование assert.fail() с более чем двумя аргументами возможно, но устарело. Более подробную информацию смотрите ниже.

assert.fail(actual, expected[, message[, operator[, stackStartFn]]])

Стабильность: 0 – устарело или набрало много негативных отзывов

Вместо этого используйте assert.fail([message]) или другие функции assert.

Если message является falsy, сообщение об ошибке устанавливается как значения actual и expected, разделенные предоставленным оператором. Если указаны только два аргумента actual и expected, то operator по умолчанию будет равен '!='. Если в качестве третьего аргумента указано message, то оно будет использоваться в качестве сообщения об ошибке, а остальные аргументы будут сохранены как свойства брошенного объекта. Если указан stackStartFn, то все кадры стека выше этой функции будут удалены из трассировки стека (см. Error.captureStackTrace). Если аргументы не указаны, будет использовано сообщение по умолчанию Failed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
import assert from 'node:assert/strict';

assert.fail('a', 'b');
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>');
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail');
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>');
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'));
// TypeError: need array

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
const assert = require('node:assert/strict');

assert.fail('a', 'b');
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>');
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail');
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>');
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'));
// TypeError: need array

В последних трех случаях actual, expected и operator не влияют на сообщение об ошибке.

Пример использования stackStartFn для усечения стек-трейса исключения:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert/strict';

function suppressFrame() {
    assert.fail('a', 'b', undefined, '!==', suppressFrame);
}
suppressFrame();
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
// at repl:1:1
// at ContextifyScript.Script.runInThisContext (vm.js:44:33)
// ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert/strict');

function suppressFrame() {
    assert.fail('a', 'b', undefined, '!==', suppressFrame);
}
suppressFrame();
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
// at repl:1:1
// at ContextifyScript.Script.runInThisContext (vm.js:44:33)
// ...

assert.ifError(value)

Выбрасывает value, если value не является undefined или null. Это полезно при проверке аргумента error в обратных вызовах. Трассировка стека содержит все кадры из ошибки, переданной в ifError(), включая потенциальные новые кадры для самой ifError().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import assert from 'node:assert/strict';

assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: Error

// Создайте несколько случайных фреймов ошибок.
let err;
(function errorFrame() {
    err = new Error('ошибка теста');
})();

(function ifErrorFrame() {
    assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: ошибка теста
// в ifErrorFrame
// в errorFrame

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const assert = require('node:assert/strict');

assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: Error

// Создайте несколько случайных фреймов ошибок.
let err;
(function errorFrame() {
    err = new Error('ошибка теста');
})();

(function ifErrorFrame() {
    assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: ошибка теста
// в ifErrorFrame
// в errorFrame

assert.match(string, regexp[, message])

Ожидает, что входная string будет соответствовать регулярному выражению.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert/strict';

assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: Входные данные не соответствуют регулярному ...

assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.match('I will pass', /pass/);
// OK

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert/strict');

assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: Входные данные не соответствуют регулярному ...

assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.match('I will pass', /pass/);
// OK

Если значения не совпадают или аргумент string имеет тип, отличный от string, возникает ошибка AssertionError со свойством message, равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.notDeepEqual(actual, expected[, message])

Строгий режим утверждения.

Псевдоним assert.notDeepStrictEqual().

Режим утверждения Legacy.

Стабильность: 3 – Закрыто

Принимаются только фиксы, связанные с безопасностью, производительностью или баг-фиксы. Пожалуйста, не предлагайте изменений АПИ в разделе с таким индикатором, они будут отклонены.

Вместо этого используйте assert.notDeepStrictEqual().

Проверяет любое глубокое неравенство. Противоположность assert.deepEqual().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import assert from 'node:assert';

const obj1 = {
    a: {
        b: 1,
    },
};
const obj2 = {
    a: {
        b: 2,
    },
};
const obj3 = {
    a: {
        b: 1,
    },
};
const obj4 = { __proto__: obj1 };

assert.notDeepEqual(obj1, obj1);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2);
// OK

assert.notDeepEqual(obj1, obj3);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4);
// OK

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
const assert = require('node:assert');

const obj1 = {
    a: {
        b: 1,
    },
};
const obj2 = {
    a: {
        b: 2,
    },
};
const obj3 = {
    a: {
        b: 1,
    },
};
const obj4 = { __proto__: obj1 };

assert.notDeepEqual(obj1, obj1);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2);
// OK

assert.notDeepEqual(obj1, obj3);
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4);
// OK

Если значения глубоко равны, возникает ошибка AssertionError со свойством message, равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.notDeepStrictEqual(actual, expected[, message])

Проверяет глубокое строгое неравенство. Противоположность assert.deepStrictEqual().

1
2
3
4
import assert from 'node:assert/strict';

assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// OK

1
2
3
4
const assert = require('node:assert/strict');

assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
// OK

Если значения глубоко и строго равны, то выбрасывается AssertionError со свойством message, установленным равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.notEqual(actual, expected[, message])

Строгий режим утверждения.

Псевдоним assert.notStrictEqual().

Режим утверждения Legacy.

Стабильность: 3 – Закрыто

Принимаются только фиксы, связанные с безопасностью, производительностью или баг-фиксы. Пожалуйста, не предлагайте изменений АПИ в разделе с таким индикатором, они будут отклонены.

Вместо этого используйте assert.notStrictEqual().

Проверяет неглубокое принудительное неравенство с помощью оператора !=. NaN специально обрабатывается и рассматривается как идентичное, если обе стороны NaN.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert';

assert.notEqual(1, 2);
// OK

assert.notEqual(1, 1);
// AssertionError: 1 != 1

assert.notEqual(1, '1');
// AssertionError: 1 != '1'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert');

assert.notEqual(1, 2);
// OK

assert.notEqual(1, 1);
// AssertionError: 1 != 1

assert.notEqual(1, '1');
// AssertionError: 1 != '1'

Если значения равны, возникает AssertionError со свойством message, равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.notStrictEqual(actual, expected[, message])

Проверяет строгое неравенство между параметрами actual и expected, определяемое Object.is().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import assert from 'node:assert/strict';

assert.notStrictEqual(1, 2);
// OK

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Ожидалось, что "actual" будет строго неравнозначно:
//
// 1

assert.notStrictEqual(1, '1');
// OK

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
const assert = require('node:assert/strict');

assert.notStrictEqual(1, 2);
// OK

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Ожидалось, что "actual" будет строго неравнозначно:
//
// 1

assert.notStrictEqual(1, '1');
// OK

Если значения строго равны, возникает ошибка AssertionError со свойством message, равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

assert.ok(value[, message])

Проверяет, является ли значение истинным. Это эквивалентно assert.equal(!!value, true, message).

Если значение не является истинным, то возникает AssertionError со свойством message, равным значению параметра message. Если параметр message равен undefined, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError. Если аргументы не переданы вообще, то message будет установлен в строку: `Нет аргумента значения, переданного вassert.ok()```.

Имейте в виду, что в repl сообщение об ошибке будет отличаться от того, которое выводится в файле! Более подробную информацию смотрите ниже.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import assert from 'node:assert/strict';

assert.ok(true);
// OK
assert.ok(1);
// OK

assert.ok();
// AssertionError: В `assert.ok()` не передан аргумент value

assert.ok(false, "it's false");
// AssertionError: it's false

// В реплике:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// В файле (например, test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: Выражение оценивается в ложное значение:
//
// assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: Выражение оценивается в ложное значение:
//
// assert.ok(false)

assert.ok(0);
// AssertionError: Выражение оценивается в ложное значение:
//
// assert.ok(0)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
const assert = require('node:assert/strict');

assert.ok(true);
// OK
assert.ok(1);
// OK

assert.ok();
// AssertionError: В `assert.ok()` не передан аргумент value

assert.ok(false, "it's false");
// AssertionError: it's false

// В реплике:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// В файле (например, test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: Выражение оценивается в ложное значение:
//
// assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: Выражение оценивается в ложное значение:
//
// assert.ok(false)

assert.ok(0);
// AssertionError: Выражение оценивается в ложное значение:
//
// assert.ok(0)

1
2
3
4
5
6
7
import assert from 'node:assert/strict';

// Использование `assert()` работает так же:
assert(0);
// AssertionError: Выражение оценивается в ложное значение:
//
// assert(0)

1
2
3
4
5
6
7
const assert = require('node:assert');

// Использование `assert()` работает так же:
assert(0);
// AssertionError: Выражение оценивается в ложное значение:
//
// assert(0)

assert.rejects(asyncFn[, error][, message])

Ожидает промис asyncFn или, если asyncFn является функцией, немедленно вызывает функцию и ожидает выполнения возвращенного промиса. Затем проверяется, что промис отклонен.

Если asyncFn является функцией и синхронно выбрасывает ошибку, assert.rejects() вернет отклоненное Promise с этой ошибкой. Если функция не возвращает промис, assert.rejects() вернет отклоненный Promise с ошибкой ERR_INVALID_RETURN_VALUE. В обоих случаях обработчик ошибки пропускается.

Помимо асинхронного характера ожидания, завершение ведет себя идентично assert.throws().

Если указано, то error может быть Class, RegExp, функцией проверки, объектом, где каждое свойство будет проверяться, или экземпляром ошибки, где каждое свойство будет проверяться, включая неперечислимые свойства message и name.

Если указано, message будет сообщением, предоставляемым AssertionError, если asyncFn не удастся отклонить.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import assert from 'node:assert/strict';

await assert.rejects(
    async () => {
        throw new TypeError('Неверное значение');
    },
    {
        name: 'TypeError',
        message: 'Неверное значение',
    }
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
const assert = require('node:assert/strict');

(async () => {
    await assert.rejects(
        async () => {
            throw new TypeError('Неверное значение');
        },
        {
            name: 'TypeError',
            message: 'Неверное значение',
        }
    );
})();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import assert from 'node:assert/strict';

await assert.rejects(
    async () => {
        throw new TypeError('Неверное значение');
    },
    (err) => {
        assert.strictEqual(err.name, 'TypeError');
        assert.strictEqual(
            err.message,
            'Неверное значение'
        );
        return true;
    }
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
const assert = require('node:assert/strict');

(async () => {
    await assert.rejects(
        async () => {
            throw new TypeError('Неверное значение');
        },
        (err) => {
            assert.strictEqual(err.name, 'TypeError');
            assert.strictEqual(
                err.message,
                'Неверное значение'
            );
            return true;
        }
    );
})();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import assert from 'node:assert/strict';

assert
    .rejects(
        Promise.reject(new Error('Неверное значение')),
        Error
    )
    .then(() => {
        // ...
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
const assert = require('node:assert/strict');

assert
    .rejects(
        Promise.reject(new Error('Неверное значение')),
        Error
    )
    .then(() => {
        // ...
    });

error не может быть строкой. Если в качестве второго аргумента указана строка, то считается, что error опущен, и строка будет использована для message. Это может привести к легко пропущенным ошибкам. Пожалуйста, внимательно прочитайте пример в assert.throws(), если использование строки в качестве второго аргумента будет рассмотрено.

assert.strictEqual(actual, expected[, message])

Проверяет строгое равенство между параметрами actual и expected, определяемое Object.is().

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import assert from 'node:assert/strict';

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Ожидается, что входные данные будут строго равны:
//
// 1 !== 2

assert.strictEqual(1, 1);
// OK

assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Ожидается, что входные данные будут строго равны:
// + фактический - ожидаемый
//
// + 'Hello foobar'
// - 'Hello World!'
// ^

const apples = 1;
const oranges = 2;
assert.strictEqual(
    apples,
    oranges,
    `apples ${apples} !== oranges ${oranges}`
);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(
    1,
    '1',
    new TypeError('Входы не идентичны')
);
// TypeError: Входные данные не идентичны

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const assert = require('node:assert/strict');

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Ожидалось, что входные данные будут строго равны:
//
// 1 !== 2

assert.strictEqual(1, 1);
// OK

assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Ожидается, что входные данные будут строго равны:
// + фактический - ожидаемый
//
// + 'Hello foobar'
// - 'Hello World!'
// ^

const apples = 1;
const oranges = 2;
assert.strictEqual(
    apples,
    oranges,
    `apples ${apples} !== oranges ${oranges}`
);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(
    1,
    '1',
    new TypeError('Входы не идентичны')
);
// TypeError: Входные данные не идентичны

Если значения не являются строго равными, возникает AssertionError со свойством message, установленным равным значению параметра message. Если параметр message не определен, назначается сообщение об ошибке по умолчанию. Если параметр message является экземпляром Error, то он будет выброшен вместо AssertionError.

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

Ожидает, что функция fn выдаст ошибку.

Если указано, error может быть Class, RegExp, функцией проверки, объектом проверки, где каждое свойство будет проверяться на строгое равенство, или экземпляром ошибки, где каждое свойство будет проверяться на строгое равенство, включая неперечислимые свойства message и name. При использовании объекта можно также использовать регулярное выражение при проверке строкового свойства. Примеры смотрите ниже.

Если указано, message будет добавлено к сообщению, предоставленному AssertionError, если вызов fn не сможет бросить или если валидация ошибки не удалась.

Пользовательский объект валидации/экземпляр ошибки:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import assert from 'node:assert/strict';

const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
    nested: true,
    baz: 'text',
};
err.reg = /abc/i;

assert.throws(
    () => {
        throw err;
    },
    {
        name: 'TypeError',
        message: 'Wrong value',
        info: {
            nested: true,
            baz: 'text',
        },
        // Only properties on the validation object will be tested for.
        // Using nested objects requires all properties to be present. Otherwise
        // the validation is going to fail.
    }
);

// Using regular expressions to validate error properties:
assert.throws(
    () => {
        throw err;
    },
    {
        // The `name` and `message` properties are strings and using regular
        // expressions on those will match against the string. If they fail, an
        // error is thrown.
        name: /^TypeError$/,
        message: /Wrong/,
        foo: 'bar',
        info: {
            nested: true,
            // It is not possible to use regular expressions for nested properties!
            baz: 'text',
        },
        // The `reg` property contains a regular expression and only if the
        // validation object contains an identical regular expression, it is going
        // to pass.
        reg: /abc/i,
    }
);

// Fails due to the different `message` and `name` properties:
assert.throws(
    () => {
        const otherErr = new Error('Not found');
        // Copy all enumerable properties from `err` to `otherErr`.
        for (const [key, value] of Object.entries(err)) {
            otherErr[key] = value;
        }
        throw otherErr;
    },
    // The error's `message` and `name` properties will also be checked when using
    // an error as validation object.
    err
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
const assert = require('node:assert/strict');

const err = new TypeError('Wrong value');
err.code = 404;
err.foo = 'bar';
err.info = {
    nested: true,
    baz: 'text',
};
err.reg = /abc/i;

assert.throws(
    () => {
        throw err;
    },
    {
        name: 'TypeError',
        message: 'Wrong value',
        info: {
            nested: true,
            baz: 'text',
        },
        // Only properties on the validation object will be tested for.
        // Using nested objects requires all properties to be present. Otherwise
        // the validation is going to fail.
    }
);

// Using regular expressions to validate error properties:
assert.throws(
    () => {
        throw err;
    },
    {
        // The `name` and `message` properties are strings and using regular
        // expressions on those will match against the string. If they fail, an
        // error is thrown.
        name: /^TypeError$/,
        message: /Wrong/,
        foo: 'bar',
        info: {
            nested: true,
            // It is not possible to use regular expressions for nested properties!
            baz: 'text',
        },
        // The `reg` property contains a regular expression and only if the
        // validation object contains an identical regular expression, it is going
        // to pass.
        reg: /abc/i,
    }
);

// Fails due to the different `message` and `name` properties:
assert.throws(
    () => {
        const otherErr = new Error('Not found');
        // Copy all enumerable properties from `err` to `otherErr`.
        for (const [key, value] of Object.entries(err)) {
            otherErr[key] = value;
        }
        throw otherErr;
    },
    // The error's `message` and `name` properties will also be checked when using
    // an error as validation object.
    err
);

Проверьте instanceof с помощью конструктора:

1
2
3
4
5
import assert from 'node:assert/strict';

assert.throws(() => {
    throw new Error('Wrong value');
}, Error);

1
2
3
4
5
const assert = require('node:assert/strict');

assert.throws(() => {
    throw new Error('Wrong value');
}, Error);

Проверьте сообщение об ошибке с помощью RegExp:

Использование регулярного выражения запускает .toString для объекта ошибки и, следовательно, включает в себя также имя ошибки.

1
2
3
4
5
import assert from 'node:assert/strict';

assert.throws(() => {
    throw new Error('Wrong value');
}, /^Error: Wrong value$/);

1
2
3
4
5
const assert = require('node:assert/strict');

assert.throws(() => {
    throw new Error('Wrong value');
}, /^Error: Wrong value$/);

Пользовательская валидация ошибок:

Функция должна возвращать true, чтобы показать, что все внутренние проверки пройдены. В противном случае она завершится с ошибкой AssertionError.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
import assert from 'node:assert/strict';

assert.throws(
    () => {
        throw new Error('Wrong value');
    },
    (err) => {
        assert(err instanceof Error);
        assert(/value/.test(err));
        // Avoid returning anything from validation functions besides `true`.
        // Otherwise, it's not clear what part of the validation failed. Instead,
        // throw an error about the specific validation that failed (as done in this
        // example) and add as much helpful debugging information to that error as
        // possible.
        return true;
    },
    'unexpected error'
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
const assert = require('node:assert/strict');

assert.throws(
    () => {
        throw new Error('Wrong value');
    },
    (err) => {
        assert(err instanceof Error);
        assert(/value/.test(err));
        // Avoid returning anything from validation functions besides `true`.
        // Otherwise, it's not clear what part of the validation failed. Instead,
        // throw an error about the specific validation that failed (as done in this
        // example) and add as much helpful debugging information to that error as
        // possible.
        return true;
    },
    'unexpected error'
);

error не может быть строкой. Если в качестве второго аргумента указана строка, то считается, что error опущен, и строка будет использована для message. Это может привести к легко пропущенным ошибкам. Использование того же сообщения, что и брошенное сообщение об ошибке, приведет к ошибке ERR_AMBIGUOUS_ARGUMENT. Пожалуйста, внимательно прочитайте приведенный ниже пример, если в качестве второго аргумента будет использоваться строка:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import assert from 'node:assert/strict';

function throwingFirst() {
    throw new Error('First');
}

function throwingSecond() {
    throw new Error('Second');
}

function notThrowing() {}

// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/);

// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
const assert = require('node:assert/strict');

function throwingFirst() {
    throw new Error('First');
}

function throwingSecond() {
    throw new Error('Second');
}

function notThrowing() {}

// The second argument is a string and the input function threw an Error.
// The first case will not throw as it does not match for the error message
// thrown by the input function!
assert.throws(throwingFirst, 'Second');
// In the next example the message has no benefit over the message from the
// error and since it is not clear if the user intended to actually match
// against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// The string is only used (as message) in case the function does not throw:
assert.throws(notThrowing, 'Second');
// AssertionError [ERR_ASSERTION]: Missing expected exception: Second

// If it was intended to match for the error message do this instead:
// It does not throw because the error messages match.
assert.throws(throwingSecond, /Second$/);

// If the error message does not match, an AssertionError is thrown.
assert.throws(throwingFirst, /Second$/);
// AssertionError [ERR_ASSERTION]

Из-за запутанной нотации, приводящей к ошибкам, избегайте строки в качестве второго аргумента.

Комментарии