Assert

Модуль assert предоставляет простой набор тестов утверждений, которые можно использовать для проверки инвариантов.

Существуют режимы strict и legacy, но рекомендуется использовать только strict mode.

Дополнительную информацию о используемых сравнениях равенства см. в руководстве MDN по сравнениям равенства.

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

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

new assert.AssertionError(options)

• options <Объект>

  • message <строка> Если указано, сообщение об ошибке будет установлено в это значение.
  • actual <любое> Свойство actual экземпляра ошибки будет содержать это значение. Внутренне используется для входных данных ошибки actual, в случае использования, например, assert.strictEqual().
  • expected <любое> Свойство expected экземпляра ошибки будет содержать это значение. Внутренне используется для входных данных ошибки expected, в случае использования, например, assert.strictEqual().
  • operator <строка> Свойство operator экземпляра ошибки будет содержать это значение. Внутренне используется для обозначения операции сравнения (или функции утверждения, вызвавшей ошибку).
  • stackStartFn <Функция> Если указано, сгенерированный стек вызовов удалит все фреймы до указанной функции.

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

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

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

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

Жесткий режим

При использовании strict mode, любая функция assert будет использовать сравнение равенства, используемое в режиме жесткой функции. Например, assert.deepEqual() будет работать так же, как и assert.deepStrictEqual().

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

Доступно через:

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

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

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

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

Чтобы отключить цвета, используйте переменную среды NODE_DISABLE_COLORS. Обратите внимание, что это также отключит цвета в REPL.

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

При прямом доступе к assert вместо использования свойства strict, для любой функции без «strict» в своем имени, например, для assert.deepEqual(), будет использовано абстрактное сравнение равенства.

Доступно через:

const assert = require('assert');

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

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

assert(value[, message])[src]

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

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

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

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

Жесткий режим

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

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

Проверяет глубокое равенство между параметрами actual и expected. Примитивные значения сравниваются с помощью абстрактного сравнения равенства (==).

Рассматриваются только перечисляемые собственные свойства. Реализация assert.deepEqual() не проверяет [[Prototype]] объектов или перечисляемые собственные свойства Symbol. Для таких проверок используйте assert.deepStrictEqual(). assert.deepEqual() может давать неожиданные результаты. Следующий пример не выбросит AssertionError, потому что свойства объекта RegExp не перечисляемы:

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

Исключение делается для Map и Set. Элементы Map и Set сравниваются, как ожидалось.

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

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

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

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

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

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

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

// This fails because 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Input A expected to strictly deep-equal input B:
// + expected - actual
//   {
// -   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: Input A expected to strictly deep-equal input B:
// + expected - actual
// - {}
// + Date {}

// Different type tags:
assert.deepStrictEqual(date, fakeDate);
// AssertionError: Input A expected to strictly deep-equal input B:
// + expected - actual
// - 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: Input A expected to strictly deep-equal input B:
// + expected - actual
// - [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: Input A expected to strictly deep-equal input B:
// + expected - actual
// - 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]: Input objects not identical:
// {
//   [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: Input A expected to strictly deep-equal input B:
// + expected - actual
//   WeakMap {
// -   [items unknown]
// +   [items unknown],
// +   unequal: true
//   }

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

assert.doesNotReject(asyncFn[, error][, message])[src]

• asyncFn <Функция> | <Promise>
• error <Регулярное выражение> | <Функция>
• message <строка>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

assert.equal(actual, expected[, message])[src]

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

Режим строгости

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

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

Проверяет поверхностное, коэрцированное равенство между параметрами actual и expected с помощью сравнения абстрактного равенства (==).

const assert = require('assert');

assert.equal(1, 1);
// OK, 1 == 1
assert.equal(1, '1');
// OK, 1 == '1'

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

• message <string> | <Error> По умолчанию: 'Failed'

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

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

• actual <any>
• expected <any>
• message <string> | <Error>
• operator <string> По умолчанию: '!='
• stackStartFn <Function> По умолчанию: assert.fail

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

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

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

• value <any>

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

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.notDeepEqual(actual, expected[, message])[src]

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

Режим строгости

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

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

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

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

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

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

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

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

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

assert.notEqual(actual, expected[, message])[src]

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

Режим строгости

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

Режим устаревшего режима

Проверка неглубокого когерентного неравенства с помощью Абстрактного сравнения равенства ( != ).

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

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

Проверяет строгое неравенство между параметрами actual и expected в соответствии с Сравнением SameValue.

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

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

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Identical input passed to notStrictEqual: 1

assert.notStrictEqual(1, '1');
// OK

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

assert.ok(value[, message])[src]

• value <any>
• message <string> | <Error>

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

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

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

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)

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

assert.rejects(asyncFn[, error][, message])[src]

• asyncFn <Функция> | <Promise>
• error <RegExp> | <Функция> | <Объект> | <Ошибка>
• message <string>

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

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

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

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

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

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

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

Обратите внимание, что error не может быть строкой. Если в качестве второго аргумента передана строка, то предполагается, что error опущен, и строка будет использоваться для message вместо этого. Это может привести к легко пропущенным ошибкам. Пожалуйста, внимательно изучите пример в assert.throws(), если используется строка в качестве второго аргумента.

assert.strictEqual(actual, expected[, message])[src]

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

Проверяет строгое равенство параметров actual и expected, определяемое сравнением SameValue.

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

assert.strictEqual(1, 2);
// AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:
// + expected - actual
// - 1
// + 2

assert.strictEqual(1, 1);
// OK

assert.strictEqual(1, '1');
// AssertionError [ERR_ASSERTION]: Input A expected to strictly equal input B:
// + expected - actual
// - 1
// + '1'

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

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

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

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

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

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

Пользовательский объект валидации/экземпляр ошибки:

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'
    }
    // Note that 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');
    otherErr.code = 404;
    throw otherErr;
  },
  err // This tests for `message`, `name` and `code`.
);

Валидация instanceof с использованием конструктора:

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

Валидация сообщения об ошибке с использованием RegExp:

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

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

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

assert.throws(
  () => {
    throw new Error('Wrong value');
  },
  function(err) {
    if ((err instanceof Error) && /value/.test(err)) {
      return true;
    }
  },
  'unexpected error'
);

Обратите внимание, что error не может быть строкой. Если в качестве второго аргумента передана строка, то error считается опушенным, и строка будет использована для message вместо. Это может привести к легко пропустимым ошибкам. Использование того же сообщения, что и в сообщении о выброшенной ошибке, приведёт к ошибке ERR_AMBIGUOUS_ARGUMENT. Пожалуйста, внимательно прочтите пример ниже, если рассматривается использование строки в качестве второго аргумента:

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 thrown an `ERR_AMBIGUOUS_ARGUMENT` error.
assert.throws(throwingSecond, 'Second');
// Throws an error:
// 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:
assert.throws(throwingSecond, /Second$/);
// Does not throw because the error messages match.
assert.throws(throwingFirst, /Second$/);
// Throws an error:
// Error: First
//     at throwingFirst (repl:2:9)

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