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

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

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

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

Модули MJS

import { strict as assert } from 'assert';

Модули CJS

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

Модули MJS

import assert from 'assert/strict';

Модули CJS

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

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

Модули MJS

import { strict as assert } from '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('assert/strict');

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

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

Режим проверки обратной совместимости

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

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

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

Модули MJS

import assert from 'assert';

Модули CJS

const assert = require('assert');

Всюду, где это возможно, используйте режим строгой проверки вместо этого. В противном случае, абстрактное сравнение на равенство может привести к неожиданным результатам. Это особенно справедливо для assert.deepEqual(), где правила сравнения нестрогие:

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

Класс: assert.AssertionError[src]

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

Указывает на ошибку утверждения. Все ошибки, выброшенные модулем 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 '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('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 'assert';
import process from '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('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 '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('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.report()

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

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

Модули MJS

import assert from 'assert';

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

function func() {}

function foo() {}

// 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()
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('assert');

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

function func() {}

function foo() {}

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

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

Модули MJS

import assert from '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('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 <any> Входные данные, проверяемые на истинность.
• message <string> | <Error>

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

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

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

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

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

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

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

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

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

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

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

Модули MJS

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

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

Модули CJS

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

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

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

Модули MJS

import assert from '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('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 <any>
• expected <any>
• message <string> | <Error>

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

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

• Примитивные значения сравниваются с помощью SameValue Comparison, используемого Object.is().
• Теги типов объектов должны быть одинаковыми.
• [[Prototype]] объектов сравниваются с помощью Сравнения на строгое равенство.
• Рассматриваются только перечисляемые "собственные" свойства.
• Имена и сообщения Error всегда сравниваются, даже если они не являются перечисляемыми свойствами.
• Сравниваются и перечисляемые собственные свойства Symbol.
• Свойства Object сравниваются в произвольном порядке.
• Ключи Map и элементы Set сравниваются в произвольном порядке.
• Сравнение WeakMap и WeakSet не зависит от их значений. Смотрите подробности ниже.

Модули MJS

import assert from '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 of the SameValue comparison

// 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 using the SameValue Comparison:
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('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 of the SameValue comparison

// 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 using the SameValue Comparison:
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 '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('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 'assert/strict';

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

Модули CJS

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

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

Модули MJS

import assert from 'assert/strict';

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

Модули CJS

const assert = require('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 'assert/strict';

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

Модули CJS

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

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

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

Модули MJS

import assert from 'assert/strict';

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

Модули CJS

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

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

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

Модули MJS

import assert from 'assert/strict';

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

Модули CJS

const assert = require('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().

Режим утверждения Legacy

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

Модули MJS

import assert from '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 '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('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 'assert/strict';

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

CJS модули

const assert = require('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 'assert';

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

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

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

Модули CJS

const assert = require('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, как определено Сравнением SameValue.

Модули MJS

import assert from '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('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 '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('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 'assert/strict';

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

Модули CJS

const assert = require('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 'assert/strict';

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

Модули CJS

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

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

Модули MJS

import assert from '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('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 'assert/strict';

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

Модули CJS

const assert = require('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, как определено Сравнением SameValue.

Модули MJS

import assert from '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('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 '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:
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:
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('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:
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:
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 'assert/strict';

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

Модули CJS

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

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

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

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

Модули MJS

import assert from 'assert/strict';

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

Модули CJS

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

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

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

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

Модули MJS

import assert from '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('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 '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:
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:
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('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]

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