Assert

Исходный код: 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> Если задано, в созданной трассировке стека отсутствуют кадры до этой функции.
- diff <string> Если задано значение 'full', в ошибках утверждений отображаются полные различия. По умолчанию — 'simple'. Допустимые значения: 'simple', 'full'.

Подкласс <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.Assert`

Добавлено в: v22.19.0

Класс Assert позволяет создавать независимые экземпляры утверждений с пользовательскими параметрами.

`new assert.Assert([options])`

options <Object>
- diff <string> Если задано значение 'full', в ошибках утверждений отображаются полные различия. По умолчанию — 'simple'. Допустимые значения: 'simple', 'full'.
- strict <boolean> Если задано значение true, нестрогие методы ведут себя как соответствующие им строгие методы. По умолчанию — true.

Создаёт новый экземпляр утверждений. Параметр diff управляет подробностью различий в сообщениях об ошибках утверждений.

const { Assert } = require('node:assert');
const assertInstance = new Assert({ diff: 'full' });
assertInstance.deepStrictEqual({ a: 1 }, { a: 2 });
// Shows a full diff in the error message. copy

Важно: при деструктуризации методов утверждений из экземпляра Assert они теряют связь с параметрами конфигурации экземпляра (например, настройками diff и strict). Вместо этого деструктурированные методы возвращаются к поведению по умолчанию.

const myAssert = new Assert({ diff: 'full' });

// This works as expected - uses 'full' diff
myAssert.strictEqual({ a: 1 }, { b: { c: 1 } });

// This loses the 'full' diff setting - falls back to default 'simple' diff
const { strictEqual } = myAssert;
strictEqual({ a: 1 }, { b: { c: 1 } }); copy

После деструктуризации методы теряют доступ к контексту this экземпляра и возвращаются к поведению утверждений по умолчанию (различия: «простые», нестрогий режим). Чтобы сохранить пользовательские параметры при использовании деструктурированных методов, не выполняйте деструктуризацию и вызывайте методы непосредственно у экземпляра.

Класс: `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])`

История

Версия	Изменения
v22.2.0	Теперь также сравниваются причина ошибки и свойства errors.
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, флаги и исходный текст <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])`

История

Версия	Изменения
v22.2.0	Теперь также сравниваются причина ошибки и свойства errors.
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, флаги и исходный текст <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 не задан, ошибка передаётся вызывающему коду.

Например, следующий код выбросит <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 - Наследуемый API: вместо него используйте 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 - Устаревший API: используйте вместо него 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 - Наследуемый API: вместо него используйте 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 - Наследуемый API: вместо него используйте 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]

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

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

История

Версия	Изменения
v22.17.0	partialDeepStrictEqual теперь имеет стабильный статус. Ранее он имел экспериментальный статус.
v22.13.0	Добавлено в: v22.13.0

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

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

Этот метод всегда проходит те же тесты, что и assert.deepStrictEqual(), и является его надмножеством.

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

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

Модули JavaScript

import assert from 'node:assert';

assert.partialDeepStrictEqual(
  { a: { b: { c: 1 } } },
  { a: { b: { c: 1 } } },
);
// OK

assert.partialDeepStrictEqual(
  { a: 1, b: 2, c: 3 },
  { b: 2 },
);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [4, 5, 8],
);
// OK

assert.partialDeepStrictEqual(
  new Set([{ a: 1 }, { b: 1 }]),
  new Set([{ a: 1 }]),
);
// OK

assert.partialDeepStrictEqual(
  new Map([['key1', 'value1'], ['key2', 'value2']]),
  new Map([['key2', 'value2']]),
);
// OK

assert.partialDeepStrictEqual(123n, 123n);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [5, 4, 8],
);
// AssertionError

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

assert.partialDeepStrictEqual(
  { a: { b: 2 } },
  { a: { b: '2' } },
);
// AssertionError

CommonJS

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

assert.partialDeepStrictEqual(
  { a: { b: { c: 1 } } },
  { a: { b: { c: 1 } } },
);
// OK

assert.partialDeepStrictEqual(
  { a: 1, b: 2, c: 3 },
  { b: 2 },
);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [4, 5, 8],
);
// OK

assert.partialDeepStrictEqual(
  new Set([{ a: 1 }, { b: 1 }]),
  new Set([{ a: 1 }]),
);
// OK

assert.partialDeepStrictEqual(
  new Map([['key1', 'value1'], ['key2', 'value2']]),
  new Map([['key2', 'value2']]),
);
// OK

assert.partialDeepStrictEqual(123n, 123n);
// OK

assert.partialDeepStrictEqual(
  [1, 2, 3, 4, 5, 6, 7, 8, 9],
  [5, 4, 8],
);
// AssertionError

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

assert.partialDeepStrictEqual(
  { a: { b: 2 } },
  { a: { b: '2' } },
);
// AssertionError

© 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-v22.x/docs/api/assert.html

Assert

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

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

Класс: assert.AssertionError

new assert.AssertionError(options)

Класс: assert.Assert

new assert.Assert([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])

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

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

Класс: `assert.AssertionError`

`new assert.AssertionError(options)`

Класс: `assert.Assert`

`new assert.Assert([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])`

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