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

В режиме строгих утверждений, нестрогие методы ведут себя как соответствующие строгие методы. Например, 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

Эта функция устарела и будет удалена в будущей версии. Пожалуйста, рассмотрите альтернативы, такие как функция-помощник mock.

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

Модули CJS

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

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

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

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

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

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

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

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

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

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

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

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

Модули 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 promise или, если asyncFn является функцией, немедленно вызывает функцию и ожидает завершения возвращённого promise. Затем проверяется, что promise не отклоняется.

Если asyncFn является функцией и она выбрасывает ошибку синхронно, assert.doesNotReject() вернёт отклонённый Promise с этой ошибкой. Если функция не возвращает 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().

Режим проверки Legacy

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

Модули CJS

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

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

Режим проверки Legacy

Проверяет поверхностное, принудительное неравенство с помощью оператора !=. 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 <any>
• expected <any>
• 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 <any>
• 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 <Функция> | <Promise>
• 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 <any>
• expected <any>
• 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 <RegExp> | <Функция> | <Объект> | <Ошибка>
• 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,
);

Проверка типа с использованием конструктора:

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]

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