Spec-Zone.ru › Node.js

Утверждения

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

Стабильность: 2 — Стабильный

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

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

Добавлено в: v9.9.0
История
Версия Изменения
v15.0.0

Предоставлено как require('node:assert/strict').
v13.9.0, v12.16.2

«Строгий режим» переименован в «строгий режим утверждений», а «устаревший режим» — в «устаревший режим утверждений», чтобы избежать путаницы с более распространённым значением термина «строгий режим».
v9.9.0

В строгий режим утверждений добавлены различия ошибок.
v9.9.0

В модуль assert добавлен строгий режим утверждений.

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

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

Семантика параметра сообщения

Для методов проверки утверждений, принимающих необязательный параметр message, сообщение можно передать в одном из следующих форматов:

  • строка: Используется как есть. Если после строки message указаны дополнительные аргументы, они интерпретируются как подстановки в стиле printf (см. util.format()).
  • Error: Если в качестве message передан экземпляр Error, эта ошибка выбрасывается напрямую вместо AssertionError.
  • функция: Функция вида (actual, expected) => string. Она вызывается только при сбое проверки утверждения и должна возвращать строку, которая будет использоваться как сообщение об ошибке. Возвращаемые значения, не являющиеся строками, игнорируются, и вместо них используется сообщение по умолчанию.

Если вместе с Error или функцией в качестве message переданы дополнительные аргументы, вызов отклоняется с ERR_AMBIGUOUS_ARGUMENT.

Если первый элемент не является строкой, Error или функцией, выбрасывается ERR_INVALID_ARG_TYPE.

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

Модули 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. Подробнее о поддержке цветов в терминальных средах см. в документации 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());
cjscopy

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

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

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

new assert.Assert([options])

История
Версия Изменения
v24.9.0

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

Создаёт новый экземпляр проверки утверждений. Параметр 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.
jscopy

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

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

Параметр skipPrototype влияет на все методы проверки глубокого равенства:

class Foo {
  constructor(a) {
    this.a = a;
  }
}

class Bar {
  constructor(a) {
    this.a = a;
  }
}

const foo = new Foo(1);
const bar = new Bar(1);

// Default behavior - fails due to different constructors
const assert1 = new Assert();
assert1.deepStrictEqual(foo, bar); // AssertionError

// Skip prototype comparison - passes if properties are equal
const assert2 = new Assert({ skipPrototype: true });
assert2.deepStrictEqual(foo, bar); // OK
jscopy

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

assert(value[, message])

Добавлено в: v0.5.9
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой формата, подобной printf, или функцией.
  • value <any> Входное значение, проверяемое на истинность.
  • message <string> | <Error> | <Function>

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

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

Добавлено в: v0.1.21
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой формата, подобной printf, или функцией.
v25.0.0

Промисы больше не считаются равными, если они не являются экземплярами одного и того же объекта.
v25.0.0

Недопустимые даты теперь считаются равными.
v24.0.0

Рекурсия теперь останавливается, когда одна из сторон встречает циклическую ссылку.
v22.2.0, v20.15.0

Теперь также сравниваются причина ошибки и свойства errors.
v18.0.0

Теперь также сравнивается свойство lastIndex регулярных выражений.
v16.0.0, v14.18.0

В устаревшем режиме утверждений статус изменён с Deprecated на Legacy.
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.
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

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

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

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

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

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

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

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

  • Примитивные значения сравниваются с помощью оператора ==, за исключением значения <NaN>. Оно считается идентичным, если обе стороны имеют значение <NaN>.
  • Теги типов объектов должны совпадать.
  • Учитываются только перечисляемые «собственные» свойства.
  • При наличии сравниваются конструкторы объектов.
  • Имена, сообщения, причины и ошибки <Error> сравниваются всегда, даже если они не являются перечисляемыми свойствами.
  • Объекты-обёртки сравниваются как объекты, а также как развёрнутые значения.
  • Свойства Object сравниваются без учёта порядка.
  • Ключи <Map> и элементы <Set> сравниваются без учёта порядка.
  • Рекурсия останавливается, когда обе стороны различаются или одна из сторон встречает циклическую ссылку.
  • Реализация не проверяет [[Prototype]] объектов.
  • Свойства <Symbol> не сравниваются.
  • Экземпляры <WeakMap>, <WeakSet> и <Promise> не сравниваются структурно. Они считаются равными, только если ссылаются на один и тот же объект. Любое сравнение разных экземпляров WeakMap, WeakSet или Promise даст неравенство, даже если их содержимое совпадает.
  • Свойства 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])

Добавлено в: v1.2.0
История
Версия Изменения
v25.1.0

Теперь сообщение может быть строкой формата, подобной printf, или функцией.
v25.0.0

Промисы больше не считаются равными, если они не являются экземплярами одного и того же объекта.
v25.0.0

Недопустимые даты теперь считаются равными.
v24.0.0

Рекурсия теперь останавливается, когда одна из сторон встречает циклическую ссылку.
v22.2.0, v20.15.0

Теперь также сравниваются причина ошибки и свойства errors.
v18.0.0

Теперь также сравнивается свойство lastIndex регулярных выражений.
v9.0.0

Теперь сравниваются перечисляемые символьные свойства.
v9.0.0

Теперь NaN сравнивается с использованием сравнения SameValueZero.
v8.5.0

Теперь имена и сообщения Error сравниваются корректно.
v8.0.0

Также сравнивается содержимое Set и Map.
v6.4.0, v4.7.1

Теперь срезы типизированных массивов обрабатываются корректно.
v6.1.0

Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v5.10.1, v4.4.3

Корректная обработка типизированных массивов, не являющихся Uint8Array.
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

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

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

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

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

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

Добавлено в: v13.6.0, v12.16.0
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой формата, подобной printf, или функцией.
v16.0.0

Этот API больше не является экспериментальным.
  • string <string>
  • regexp <RegExp>
  • message <string> | <Error> | <Function>

Ожидается, что входное значение 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])

Добавлено в: v0.1.21
История
Версия Изменения
v5.11.0, v4.4.5

Теперь учитывается параметр message.
v4.2.0

Теперь параметр error может быть стрелочной функцией.
  • 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])

Добавлено в: v0.1.21
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой форматирования в стиле printf или функцией.
v16.0.0, v14.18.0

В режиме устаревших проверок статус изменён с «Устаревший» на «Наследуемый».
v14.0.0

Теперь NaN считается идентичным самому себе, если обе стороны — NaN.
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

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

Псевдоним 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.ifError(value)

Добавлено в: v0.1.97
История
Версия Изменения
v10.0.0

Вместо выбрасывания исходной ошибки теперь создаётся обёртка [AssertionError][] с полной трассировкой стека.
v10.0.0

Теперь значение может быть только undefined или null. Раньше все ложные значения обрабатывались так же, как null, и ошибка не выбрасывалась.
  • 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])

Добавлено в: v13.6.0, v12.16.0
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой форматирования в стиле printf или функцией.
v16.0.0

Этот API больше не является экспериментальным.
  • string <string>
  • regexp <RegExp>
  • message <string> | <Error> | <Function>

Проверяет, соответствует ли входное значение 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])

Добавлено в: v0.1.21
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой форматирования в стиле printf или функцией.
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.
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

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

Псевдоним 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])

Добавлено в: v1.2.0
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой форматирования в стиле printf или функцией.
v9.0.0

Теперь -0 и +0 больше не считаются равными.
v9.0.0

Теперь NaN сравнивается с помощью алгоритма сравнения SameValueZero.
v9.0.0

Теперь имена и сообщения Error сравниваются корректно.
v8.0.0

Теперь также сравнивается содержимое Set и Map.
v6.4.0, v4.7.1

Теперь срезы типизированных массивов обрабатываются правильно.
v6.1.0

Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v5.10.1, v4.4.3

Правильная обработка типизированных массивов, не являющихся Uint8Array.
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

Проверяет наличие глубокого строгого неравенства. Противоположность 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])

Добавлено в: v0.1.21
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой форматирования в стиле printf или функцией.
v16.0.0, v14.18.0

В режиме устаревших проверок статус изменён с «Устаревший» на «Наследуемый».
v14.0.0

Теперь NaN считается идентичным самому себе, если обе стороны — NaN.
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

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

Псевдоним 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])

Добавлено в: v0.1.21
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой форматирования в стиле printf или функцией.
v10.0.0

Используемый способ сравнения изменён со строгого равенства на Object.is().
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

Проверяет строгое неравенство параметров 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])

Добавлено в: v0.1.21
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой форматирования в стиле printf или функцией.
v10.0.0

Теперь для assert.ok() (без аргументов) используется предопределённое сообщение об ошибке.
  • value <any>
  • message <string> | <Error> | <Function>

Проверяет, является ли 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(2 + 2 > 5);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(2 + 2 > 5)
CommonJS
const assert = require('node:assert');

// Using `assert()` works the same:
assert(2 + 2 > 5);
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(2 + 2 > 5)

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

Добавлено в: v0.1.21
История
Версия Изменения
v26.0.0

Теперь сообщение может быть строкой формата, подобной printf, или функцией.
v10.0.0

Используемое сравнение изменено с «строгого равенства» на Object.is().
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function> Аргументы в стиле printf после основного аргумента используются в случае, если он применяется как строка формата. Если сообщение является функцией, она вызывается при ошибке сравнения. Функция получает аргументы actual и expected и должна вернуть строку, которая будет использоваться в качестве сообщения об ошибке. Строки формата и функции в стиле printf повышают производительность, если аргументы передаются дальше. Кроме того, они позволяют легко форматировать сообщение.

Проверяет строгое равенство параметров 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(apples, oranges, 'apples %s !== oranges %s', apples, oranges);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical

assert.strictEqual(apples, oranges, (actual, expected) => {
  // Do 'heavy' computations
  return `I expected ${expected} but I got ${actual}`;
});
// AssertionError [ERR_ASSERTION]: I expected oranges but I got apples
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(apples, oranges, 'apples %s !== oranges %s', apples, oranges);
// AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
// TypeError: Inputs are not identical

assert.strictEqual(apples, oranges, (actual, expected) => {
  // Do 'heavy' computations
  return `I expected ${expected} but I got ${actual}`;
});
// AssertionError [ERR_ASSERTION]: I expected oranges but I got apples

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

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

Добавлено в: v0.1.21
История
Версия Изменения
v10.2.0

Теперь параметр error может быть объектом, содержащим регулярные выражения.
v9.9.0

Теперь параметр error также может быть объектом.
v4.2.0

Теперь параметр error может быть стрелочной функцией.
  • 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])

Добавлено в: v23.4.0, v22.13.0
История
Версия Изменения
v25.0.0

Промисы больше не считаются равными, если они не являются экземплярами одного и того же объекта.
v25.0.0

Недопустимые даты теперь считаются равными.
v24.0.0, v22.17.0

partialDeepStrictEqual теперь имеет статус стабильного API. Ранее он был экспериментальным.
  • actual <any>
  • expected <any>
  • message <string> | <Error> | <Function>

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

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

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

  • Примитивные значения сравниваются с помощью Object.is().
  • Теги типов объектов должны совпадать.
  • [[Prototype]] объектов не сравниваются.
  • Учитываются только перечисляемые «собственные» свойства.
  • Имена, сообщения, причины и ошибки <Error> всегда сравниваются, даже если они не являются перечисляемыми свойствами. Также сравнивается errors.
  • Также сравниваются перечисляемые собственные свойства <Symbol>.
  • Обёртки объектов сравниваются и как объекты, и как распакованные значения.
  • Свойства Object сравниваются без учёта порядка.
  • Ключи <Map> и элементы <Set> сравниваются без учёта порядка.
  • Рекурсия прекращается, если обе стороны различаются или обе стороны встречают циклическую ссылку.
  • Экземпляры <WeakMap>, <WeakSet> и <Promise> не сравниваются структурно. Они считаются равными, только если ссылаются на один и тот же объект. Любое сравнение разных экземпляров WeakMap, WeakSet или Promise даст результат «не равны», даже если они содержат одинаковые данные.
  • lastIndex, флаги и исходный текст <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/api/assert.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API