Assert — Node.js 20 LTS

Проверка утверждений

Исходный код: lib/assert.js

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

Режим строгой проверки утверждений

История

Версия	Изменения
v15.0.0	Экспортируется как `require('node:assert/strict')`.
v13.9.0, v12.16.2	«Строгий режим» заменён на «режим строгой проверки утверждений», а «устаревший режим» — на «режим устаревшей проверки утверждений», чтобы избежать путаницы с более распространённым значением термина «строгий режим».
v9.9.0	В режим строгой проверки утверждений добавлены различия в ошибках.
v9.9.0	В модуль assert добавлен режим строгой проверки утверждений.
v9.9.0	Добавлено в: v9.9.0

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

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

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

Модули JavaScript

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

CommonJS

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

Модули JavaScript

import assert from 'node:assert/strict';

CommonJS

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

Пример различий в ошибке:

Модули JavaScript

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

CommonJS

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

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

Режим устаревшей проверки утверждений

В режиме устаревшей проверки утверждений используется оператор == в следующих методах:

assert.deepEqual()
assert.equal()
assert.notDeepEqual()
assert.notEqual()

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

Модули JavaScript

import assert from 'node:assert';

CommonJS

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

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

// WARNING: This does not throw an AssertionError in legacy assertion mode!
assert.deepEqual(/a/gi, new Date()); copy

Класс: assert.AssertionError[исходный код]

Расширяет: <errors.Error>

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

`new assert.AssertionError(options)`

Добавлено в: v0.1.21

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> Устанавливается в значение аргумента expected для таких методов, как assert.strictEqual().
generatedMessage <boolean> Указывает, было ли сообщение сгенерировано автоматически (true).
code <string> Значение всегда равно ERR_ASSERTION, что указывает на то, что ошибка является ошибкой проверки утверждения.
operator <string> Устанавливается в переданное значение оператора.

Модули JavaScript

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);
}

CommonJS

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`

История

Версия	Изменения
v20.1.0	Класс `assert.CallTracker` устарел и будет удалён в будущей версии.
v14.2.0, v12.19.0	Добавлено в: v14.2.0, v12.19.0

Стабильность: 0 — Устарело

Эта функция устарела и будет удалена в будущей версии. Рекомендуется использовать альтернативы, например вспомогательную функцию mock.

`new assert.CallTracker()`

Добавлено в: v14.2.0, v12.19.0

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

Модули JavaScript

import assert from 'node:assert';
import process from 'node:process';

const tracker = new assert.CallTracker();

function func() {}

// callsfunc() must be called exactly 1 time before tracker.verify().
const callsfunc = tracker.calls(func, 1);

callsfunc();

// Calls tracker.verify() and verifies if all tracker.calls() functions have
// been called exact times.
process.on('exit', () => {
  tracker.verify();
});

CommonJS

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

const tracker = new assert.CallTracker();

function func() {}

// callsfunc() must be called exactly 1 time before tracker.verify().
const callsfunc = tracker.calls(func, 1);

callsfunc();

// Calls tracker.verify() and verifies if all tracker.calls() functions have
// been called exact times.
process.on('exit', () => {
  tracker.verify();
});

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

Добавлено в: v14.2.0, v12.19.0

fn <Function> По умолчанию: Функция, ничего не выполняющая.
exact <number> По умолчанию: 1.
Возвращает: <Function> Функция-обёртка для fn.

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

Модули JavaScript

import assert from 'node:assert';

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func);

CommonJS

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

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func);

`tracker.getCalls(fn)`

Добавлено в: v18.8.0, v16.18.0

fn <Function>
Возвращает: <Array> Массив со всеми вызовами отслеживаемой функции.
Объект <Object>
- thisArg <Object>
- arguments <Array> аргументы, переданные отслеживаемой функции

Модули JavaScript

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: undefined, arguments: [1, 2, 3] }]);

CommonJS

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

// Creates call tracker.
const tracker = new assert.CallTracker();

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

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

`tracker.report()`

Добавлено в: v14.2.0, v12.19.0

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

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

Модули JavaScript

import assert from 'node:assert';

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Returns an array containing information on callsfunc()
console.log(tracker.report());
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]

CommonJS

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

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Returns an array containing information on callsfunc()
console.log(tracker.report());
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]

`tracker.reset([fn])`

Добавлено в: v18.8.0, v16.18.0

fn <Function> отслеживаемая функция, вызовы которой нужно сбросить.

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

Модули JavaScript

import assert from 'node:assert';

const tracker = new assert.CallTracker();

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

callsfunc();
// Tracker was called once
assert.strictEqual(tracker.getCalls(callsfunc).length, 1);

tracker.reset(callsfunc);
assert.strictEqual(tracker.getCalls(callsfunc).length, 0);

CommonJS

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

const tracker = new assert.CallTracker();

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

callsfunc();
// Tracker was called once
assert.strictEqual(tracker.getCalls(callsfunc).length, 1);

tracker.reset(callsfunc);
assert.strictEqual(tracker.getCalls(callsfunc).length, 0);

`tracker.verify()`

Добавлено в: v14.2.0, v12.19.0

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

Модули JavaScript

import assert from 'node:assert';

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

callsfunc();

// Will throw an error since callsfunc() was only called once.
tracker.verify();

CommonJS

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

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

callsfunc();

// Will throw an error since callsfunc() was only called once.
tracker.verify();

`assert(value[, message])`

Добавлено в: v0.5.9

value <any> Входное значение, проверяемое на истинность.
message <string> | <Error>

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

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

История

Версия	Изменения
v20.15.0	Теперь также сравниваются причина ошибки и свойства ошибок.
v18.0.0	Теперь также сравнивается свойство lastIndex регулярных выражений.
v16.0.0, v14.18.0	В режиме устаревшей проверки утверждений статус изменён с «Устарело» на «Устаревшее поведение».
v14.0.0	Теперь NaN считается идентичным, если обе стороны равны NaN.
v12.0.0	Теперь теги типов сравниваются корректно; также внесены несколько небольших изменений в сравнение, чтобы проверка давала менее неожиданные результаты.
v9.0.0	Теперь имена и сообщения `Error` сравниваются корректно.
v8.0.0	Также сравнивается содержимое `Set` и `Map`.
v6.4.0, v4.7.1	Срезы типизированных массивов теперь обрабатываются корректно.
v6.1.0, v4.5.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v5.10.1, v4.4.3	Некорректно типизированные массивы, не являющиеся `Uint8Array`, теперь обрабатываются правильно.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгой проверки утверждений

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

Режим устаревшей проверки утверждений

Стабильность: 3 — Устаревшее поведение: вместо этого используйте assert.deepStrictEqual().

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

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

Подробности сравнения

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

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

Модули JavaScript

import assert from 'node:assert';
// WARNING: This does not throw an AssertionError!

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

CommonJS

const assert = require('node:assert');
// WARNING: This does not throw an AssertionError!

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

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

Модули JavaScript

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 {}

CommonJS

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

История

Версия	Изменения
v20.15.0	Теперь также сравниваются причина ошибки и свойства ошибок.
v18.0.0	Теперь также сравнивается свойство lastIndex регулярных выражений.
v9.0.0	Теперь сравниваются перечисляемые свойства-символы.
v9.0.0	Теперь `NaN` сравнивается с помощью сравнения SameValueZero.
v8.5.0	Теперь имена и сообщения `Error` сравниваются корректно.
v8.0.0	Также сравнивается содержимое `Set` и `Map`.
v6.1.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v6.4.0, v4.7.1	Срезы типизированных массивов теперь обрабатываются корректно.
v5.10.1, v4.4.3	Некорректно типизированные массивы, не являющиеся `Uint8Array`, теперь обрабатываются правильно.
v1.2.0	Добавлено в: v1.2.0

actual <any>
expected <any>
message <string> | <Error>

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

Подробности сравнения

Примитивные значения сравниваются с помощью Object.is().
Теги типов объектов должны совпадать.
[[Prototype]] объектов сравниваются с помощью оператора ===.
Учитываются только перечисляемые «собственные» свойства.
Имена, сообщения, причины и ошибки Error сравниваются всегда, даже если они не являются перечисляемыми свойствами. Также сравнивается errors.
Также сравниваются перечисляемые собственные свойства Symbol.
Объекты-обёртки сравниваются и как объекты, и как распакованные значения.
Свойства Object сравниваются без учёта порядка.
Ключи Map и элементы Set сравниваются без учёта порядка.
Рекурсия прекращается, когда стороны различаются или обе стороны встречают циклическую ссылку.
Экземпляры WeakMap и WeakSet не сравниваются структурно. Они считаются равными, только если ссылаются на один и тот же объект. Любое сравнение различных экземпляров WeakMap или WeakSet даст результат «не равны», даже если они содержат одинаковые элементы.
Свойства lastIndex, flags и source у RegExp всегда сравниваются, даже если они не являются перечисляемыми свойствами.

Модули JavaScript

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 obj = {};

weakMap1.set(obj, 'value');
weakMap2.set(obj, 'value');

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakMap1, weakMap2);
// AssertionError: Values have same structure but are not reference-equal:
//
// WeakMap {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakMap1, weakMap1);
// OK

const weakSet1 = new WeakSet();
const weakSet2 = new WeakSet();
weakSet1.add(obj);
weakSet2.add(obj);

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakSet1, weakSet2);
// AssertionError: Values have same structure but are not reference-equal:
// + actual - expected
//
// WeakSet {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakSet1, weakSet1);
// OK

CommonJS

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 obj = {};

weakMap1.set(obj, 'value');
weakMap2.set(obj, 'value');

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakMap1, weakMap2);
// AssertionError: Values have same structure but are not reference-equal:
//
// WeakMap {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakMap1, weakMap1);
// OK

const weakSet1 = new WeakSet();
const weakSet2 = new WeakSet();
weakSet1.add(obj);
weakSet2.add(obj);

// Comparing different instances fails, even with same contents
assert.deepStrictEqual(weakSet1, weakSet2);
// AssertionError: Values have same structure but are not reference-equal:
// + actual - expected
//
// WeakSet {
//   <items unknown>
// }

// Comparing the same instance to itself succeeds
assert.deepStrictEqual(weakSet1, weakSet1);
// OK

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

История

Версия	Изменения
v16.0.0	Этот API больше не является экспериментальным.
v13.6.0, v12.16.0	Добавлено в: v13.6.0, v12.16.0

string <string>
regexp <RegExp>
message <string> | <Error>

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

Модули JavaScript

import assert from 'node:assert/strict';

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

CommonJS

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

assert.doesNotMatch('I will fail', /fail/);
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

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

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

Добавлено в: v10.0.0

asyncFn <Function> | <Promise>
error <RegExp> | <Function>
message <string>
Возвращает: <Promise>

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

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

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

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

Помимо асинхронного ожидания завершения, функция ведёт себя так же, как assert.doesNotThrow().

Модули JavaScript

import assert from 'node:assert/strict';

await assert.doesNotReject(
  async () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);

CommonJS

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

(async () => {
  await assert.doesNotReject(
    async () => {
      throw new TypeError('Wrong value');
    },
    SyntaxError,
  );
})();

Модули JavaScript

import assert from 'node:assert/strict';

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

CommonJS

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

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

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

История

Версия	Изменения
v5.11.0, v4.4.5	Теперь учитывается параметр `message`.
v4.2.0	Теперь параметр `error` может быть стрелочной функцией.
v0.1.21	Добавлено в: v0.1.21

fn <Function>
error <RegExp> | <Function>
message <string>

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

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

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

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

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

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

Модули JavaScript

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);

CommonJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  SyntaxError,
);

Однако следующий код приведёт к выбросу AssertionError с сообщением «Получено нежелательное исключение...»:

Модули JavaScript

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
);

CommonJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
);

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

Модули JavaScript

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  /Wrong value/,
  'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoops

CommonJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  /Wrong value/,
  'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoops

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

История

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревших проверок статус изменён с «Устаревший» на «Старый режим».
v14.0.0	Теперь NaN считается идентичным значением, если обе стороны равны NaN.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгих проверок

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

Режим устаревших проверок

Стабильность: 3 — Старый режим: вместо этого используйте assert.strictEqual().

Проверяет поверхностное равенство с приведением типов между параметрами actual и expected с помощью оператора ==. Значение NaN обрабатывается особым образом и считается идентичным, если обе стороны равны NaN.

Модули JavaScript

import assert from 'node:assert';

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 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 } }

CommonJS

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

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 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])`

Добавлено в: v0.1.21

message <string> | <Error> По умолчанию: 'Failed'

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

Модули JavaScript

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

CommonJS

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

История

Версия	Изменения
v10.0.0	Вызов `assert.fail()` более чем с одним аргументом считается устаревшим и вызывает предупреждение.
v0.1.21	Добавлено в: v0.1.21

Стабильность: 0 — Устарело: вместо этого используйте assert.fail([message]) или другие функции assert.

actual <any>
expected <any>
message <string> | <Error>
operator <string> По умолчанию: '!='
stackStartFn <Function> По умолчанию: assert.fail

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

Модули JavaScript

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

CommonJS

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 для усечения трассировки стека исключения:

Модули JavaScript

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)
//     ...

CommonJS

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

История

Версия	Изменения
v10.0.0	Теперь вместо исходной ошибки выбрасывается обёртка [`AssertionError`][], содержащая полную трассировку стека.
v10.0.0	Теперь значение может быть только `undefined` или `null`. Ранее все ложные значения обрабатывались так же, как `null`, и не приводили к выбросу ошибки.
v0.1.97	Добавлено в: v0.1.97

value <any>

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

Модули JavaScript

import assert from 'node:assert/strict';

assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err;
(function errorFrame() {
  err = new Error('test error');
})();

(function ifErrorFrame() {
  assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame

CommonJS

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

assert.ifError(null);
// OK
assert.ifError(0);
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
assert.ifError('error');
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
assert.ifError(new Error());
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error

// Create some random error frames.
let err;
(function errorFrame() {
  err = new Error('test error');
})();

(function ifErrorFrame() {
  assert.ifError(err);
})();
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame

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

История

Версия	Изменения
v16.0.0	Этот API больше не является экспериментальным.
v13.6.0, v12.16.0	Добавлено в: v13.6.0, v12.16.0

string <string>
regexp <RegExp>
message <string> | <Error>

Проверяет, соответствует ли входная строка string регулярному выражению.

Модули JavaScript

import assert from 'node:assert/strict';

assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

CommonJS

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

assert.match('I will fail', /pass/);
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/);
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

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

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

История

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревших проверок статус изменён с «Устаревший» на «Старый режим».
v14.0.0	Теперь NaN считается идентичным значением, если обе стороны равны NaN.
v9.0.0	Теперь имена и сообщения `Error` сравниваются корректно.
v8.0.0	Теперь также сравнивается содержимое `Set` и `Map`.
v6.4.0, v4.7.1	Теперь срезы типизированных массивов обрабатываются корректно.
v6.1.0, v4.5.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v5.10.1, v4.4.3	Корректная обработка типизированных массивов, не являющихся `Uint8Array`.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгих проверок

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

Режим устаревших проверок

Стабильность: 3 — Старый режим: вместо этого используйте assert.notDeepStrictEqual().

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

Модули JavaScript

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

CommonJS

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

История

Версия	Изменения
v9.0.0	Теперь `-0` и `+0` больше не считаются равными.
v9.0.0	Теперь `NaN` сравнивается с использованием сравнения SameValueZero.
v9.0.0	Теперь имена и сообщения `Error` сравниваются корректно.
v8.0.0	Теперь также сравнивается содержимое `Set` и `Map`.
v6.1.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v6.4.0, v4.7.1	Теперь срезы типизированных массивов обрабатываются корректно.
v5.10.1, v4.4.3	Корректная обработка типизированных массивов, не являющихся `Uint8Array`.
v1.2.0	Добавлено в: v1.2.0

actual <any>
expected <any>
message <string> | <Error>

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

Модули JavaScript

import assert from 'node:assert/strict';

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

CommonJS

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

История

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревших проверок статус изменён с «Устаревший» на «Старый режим».
v14.0.0	Теперь NaN считается идентичным значением, если обе стороны равны NaN.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

Режим строгих проверок

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

Режим устаревших проверок

Стабильность: 3 — Старый режим: вместо этого используйте assert.notStrictEqual().

Проверяет поверхностное неравенство с приведением типов с помощью оператора !=. Значение NaN обрабатывается особым образом и считается идентичным, если обе стороны равны NaN.

Модули JavaScript

import assert from 'node:assert';

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

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

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

CommonJS

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

История

Версия	Изменения
v10.0.0	Используемый способ сравнения изменён со строгого равенства на `Object.is()`.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

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

Модули JavaScript

import assert from 'node:assert/strict';

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

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

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

CommonJS

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

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

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

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

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

`assert.ok(value[, message])`

История

Версия	Изменения
v10.0.0	Теперь вызов `assert.ok()` без аргументов использует заранее заданное сообщение об ошибке.
v0.1.21	Добавлено в: v0.1.21

value <any>
message <string> | <Error>

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

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

Обратите внимание: в repl сообщение об ошибке будет отличаться от сообщения, выброшенного в файле. Дополнительные сведения приведены ниже.

Модули JavaScript

import assert from 'node:assert/strict';

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

assert.ok();
// AssertionError: No value argument passed to `assert.ok()`

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

// In the repl:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)

CommonJS

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

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

assert.ok();
// AssertionError: No value argument passed to `assert.ok()`

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

// In the repl:
assert.ok(typeof 123 === 'string');
// AssertionError: false == true

// In a file (e.g. test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)

Модули JavaScript

import assert from 'node:assert/strict';

// Using `assert()` works the same:
assert(0);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

CommonJS

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

// Using `assert()` works the same:
assert(0);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

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

Добавлено в: v10.0.0

asyncFn <Function> | <Promise>
error <RegExp> | <Function> | <Object> | <Error>
message <string>
Возвращает: <Promise>

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

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

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

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

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

Модули JavaScript

import assert from 'node:assert/strict';

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value');
  },
  {
    name: 'TypeError',
    message: 'Wrong value',
  },
);

CommonJS

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

(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value');
    },
    {
      name: 'TypeError',
      message: 'Wrong value',
    },
  );
})();

Модули JavaScript

import assert from 'node:assert/strict';

await assert.rejects(
  async () => {
    throw new TypeError('Wrong value');
  },
  (err) => {
    assert.strictEqual(err.name, 'TypeError');
    assert.strictEqual(err.message, 'Wrong value');
    return true;
  },
);

CommonJS

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

(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Wrong value');
    },
    (err) => {
      assert.strictEqual(err.name, 'TypeError');
      assert.strictEqual(err.message, 'Wrong value');
      return true;
    },
  );
})();

Модули JavaScript

import assert from 'node:assert/strict';

assert.rejects(
  Promise.reject(new Error('Wrong value')),
  Error,
).then(() => {
  // ...
});

CommonJS

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

assert.rejects(
  Promise.reject(new Error('Wrong value')),
  Error,
).then(() => {
  // ...
});

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

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

История

Версия	Изменения
v10.0.0	Используемое сравнение изменено со строгого равенства на `Object.is()`.
v0.1.21	Добавлено в: v0.1.21

actual <any>
expected <any>
message <string> | <Error>

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

Модули JavaScript

import assert from 'node:assert/strict';

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

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

assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + '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('Inputs are not identical'));
// TypeError: Inputs are not identical

CommonJS

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

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

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

assert.strictEqual('Hello foobar', 'Hello World!');
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + '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('Inputs are not identical'));
// TypeError: Inputs are not identical

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

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

История

Версия	Изменения
v10.2.0	Теперь параметр `error` может быть объектом, содержащим регулярные выражения.
v9.9.0	Теперь параметр `error` также может быть объектом.
v4.2.0	Теперь параметр `error` может быть стрелочной функцией.
v0.1.21	Добавлено в: v0.1.21

fn <Function>
error <RegExp> | <Function> | <Object> | <Error>
message <string>

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

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

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

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

Модули JavaScript

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,
);

CommonJS

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 с помощью конструктора:

Модули JavaScript

import assert from 'node:assert/strict';

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

CommonJS

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

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

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

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

Модули JavaScript

import assert from 'node:assert/strict';

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

CommonJS

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

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

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

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

Модули JavaScript

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',
);

CommonJS

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. Если вы рассматриваете возможность использовать строку в качестве второго аргумента, внимательно прочитайте приведённый ниже пример:

Модули JavaScript

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]

CommonJS

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]

Из-за запутанного и подверженного ошибкам синтаксиса не используйте строку в качестве второго аргумента.

© Joyent, Inc. and other Node contributors
Licensed under the MIT License.
Node.js is a trademark of Joyent, Inc. and is used with its permission.
We are not endorsed by or affiliated with Joyent.
https://nodejs.org/dist/latest-v20.x/docs/api/assert.html

Проверка утверждений

Режим строгой проверки утверждений

Режим устаревшей проверки утверждений

Класс: assert.AssertionError[исходный код]

new assert.AssertionError(options)

Класс: assert.CallTracker

new assert.CallTracker()

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

tracker.getCalls(fn)

tracker.report()

tracker.reset([fn])

tracker.verify()

assert(value[, message])

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

Подробности сравнения

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

Подробности сравнения

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

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

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

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

assert.fail([message])

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

assert.ifError(value)

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

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

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

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

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

assert.ok(value[, message])

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

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

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

`new assert.AssertionError(options)`

Класс: `assert.CallTracker`

`new assert.CallTracker()`

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

`tracker.getCalls(fn)`

`tracker.report()`

`tracker.reset([fn])`

`tracker.verify()`

`assert(value[, message])`

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

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

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

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

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

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

`assert.fail([message])`

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

`assert.ifError(value)`

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

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

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

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

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

`assert.ok(value[, message])`

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

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

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