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

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

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

Для использования режима строгой проверки:

MJS модули

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

CJS модули

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

MJS модули

import assert from 'node:assert/strict';

CJS модули

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

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

MJS модули

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

CJS модули

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

Для использования режима проверки по умолчанию:

MJS модули

import assert from 'node:assert';

CJS модули

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[src]

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

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

new assert.AssertionError(options)

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

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

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

• actual <любое> Установлено в аргумент actual для методов, таких как assert.strictEqual().
• expected <любое> Установлено в значение expected для методов, таких как assert.strictEqual().
• generatedMessage <логическое> Указывает, было ли сообщение автоматически сгенерировано (true) или нет.
• code <строка> Значение всегда ERR_ASSERTION для отображения того, что ошибка — это ошибка утверждения.
• operator <строка> Установлено в переданное значение оператора.

MJS модули

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

CJS модули

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

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

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

Класс: assert.CallTracker

Данная функция в настоящее время находится на стадии разработки, и её поведение может измениться.

new assert.CallTracker()

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

MJS-модули

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

CJS-модули

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

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

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

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

MJS-модули

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

CJS-модули

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)

• fn <Функция>.

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

• Объект <Объект>

  • thisArg <Объект>
  • arguments <Массив> аргументы, переданные отслеживаемой функции

MJS-модули

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

CJS-модули

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

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

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

MJS-модули

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
//  }
// ]

CJS-модули

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

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

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

MJS-модули

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

CJS-модули

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

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

MJS-модули

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

CJS-модули

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

• value <любой> Входные данные, проверяемые на истинность.
• message <строка> | <ошибка>

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

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

• actual <любой>
• expected <любой>
• message <строка> | <ошибка>

Жесткий режим проверки

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

Устаревший режим проверки

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

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

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

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

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

MJS-модули

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

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

CJS-модули

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

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

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

MJS-модули

import assert from 'node:assert';

const obj1 = {
  a: {
    b: 1,
  },
};
const obj2 = {
  a: {
    b: 2,
  },
};
const obj3 = {
  a: {
    b: 1,
  },
};
const obj4 = Object.create(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 {}

CJS-модули

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

const obj1 = {
  a: {
    b: 1,
  },
};
const obj2 = {
  a: {
    b: 2,
  },
};
const obj3 = {
  a: {
    b: 1,
  },
};
const obj4 = Object.create(obj1);

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

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

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

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

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

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

• actual <любой>
• expected <любой>
• message <строка> | <ошибка>

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

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

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

MJS-модули

import assert from 'node:assert/strict';

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

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

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

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

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

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

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

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

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

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

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

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

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

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

CJS-модули

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• string <строка>
• regexp <RegExp>
• message <строка> | <Ошибка>

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

Модули MJS

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

Модули CJS

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

• asyncFn <Функция> | <Promise>
• error <RegExp> | <Функция>
• message <строка>

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

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

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

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

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

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

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

• fn <Функция>
• error <RegExp> | <Функция>
• message <строка>

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

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

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

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

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

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

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

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

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

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

• actual <любой>
• expected <любой>
• message <строка> | <Ошибка>

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

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

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

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

Модули MJS

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

Модули CJS

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

• message <строка> | <Ошибка> По умолчанию: 'Failed'

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

Модули MJS

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

Модули CJS

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

• actual <любой>
• expected <любой>
• message <строка> | <Ошибка>
• operator <строка> По умолчанию: '!='
• stackStartFn <Функция> По умолчанию: assert.fail

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

Модули MJS

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

Модули CJS

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

Модули MJS

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

Модули CJS

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

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

assert.ifError(value)

• value <любой>

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

Модули MJS

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

Модули CJS

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

• string <строка>
• regexp <RegExp>
• message <строка> | <Ошибка>

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

Модули MJS

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

Модули CJS

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

• actual <любой>
• expected <любой>
• message <строка> | <Ошибка>

Жесткий режим проверки

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

Режим проверки по умолчанию

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

Модули MJS

import assert from 'node:assert';

const obj1 = {
  a: {
    b: 1,
  },
};
const obj2 = {
  a: {
    b: 2,
  },
};
const obj3 = {
  a: {
    b: 1,
  },
};
const obj4 = Object.create(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

Модули CJS

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

const obj1 = {
  a: {
    b: 1,
  },
};
const obj2 = {
  a: {
    b: 2,
  },
};
const obj3 = {
  a: {
    b: 1,
  },
};
const obj4 = Object.create(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])

• actual <любой>
• expected <любой>
• message <строка> | <ошибка>

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

• actual <любой>
• expected <любой>
• message <строка> | <ошибка>

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

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

Режим старых утверждений

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

Модули MJS

import assert from 'node:assert';

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

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

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

Модули CJS

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

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

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

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

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

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

• actual <любой>
• expected <любой>
• message <строка> | <ошибка>

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

Модули MJS

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

Модули CJS

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

• value <любой>
• message <строка> | <ошибка>

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

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

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

Модули MJS

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)

Модули CJS

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)

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

• asyncFn <Функция> | <Обещание>
• error <Выражение регулярного типа> | <Функция> | <Объект> | <Ошибка>
• message <строка>

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

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

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

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

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

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

Модули MJS

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

Модули CJS

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

• actual <любой>
• expected <любой>
• message <строка> | <Ошибка>

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

Модули MJS

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

Модули CJS

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

• fn <Функция>
• error <Регулярное выражение> | <Функция> | <Объект> | <Ошибка>
• message <строка>

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

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

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

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

Модули MJS

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

Модули CJS

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

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

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

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

Модули MJS

import assert from 'node:assert/strict';

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

Модули CJS

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

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

Настройка проверки ошибки:

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

Модули MJS

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

Модули CJS

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

Модули MJS

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]

Модули CJS

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]

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