Assert

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

Модуль 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: 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()

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

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 <Object>
  • 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 <строка> Установлено в значение переданного оператора.

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

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() выбросит ошибку.

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 <Объект> Стек вызовов функции.

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

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(), и выбросит ошибку для функций, которые не были вызваны ожидаемое количество раз.

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

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

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

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

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

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

Режим утверждения по умолчанию

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

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

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

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

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

// WARNING: This does not throw an AssertionError!
assert.deepEqual('+00000000', false);

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

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 <любой>
• 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: 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 не будет соответствовать регулярному выражению.

Эта функция в настоящее время находится на стадии эксперимента, и ее имя может быть изменено или она может быть полностью удалена.

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 <Функция> | <Обещание>
• 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])

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

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

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

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

• message <строка> | <Ошибка> По умолчанию: '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]]])

• actual <любое>
• expected <любое>
• message <строка> | <Ошибка>
• operator <строка> По умолчанию: '!='
• stackStartFn <Функция> По умолчанию: 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)

• 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.match(string, regexp[, message])

• string <string>
• regexp <RegExp>
• message <string> | <Error>

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

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

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

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

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

• 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]: 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 <string> | <Error>

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

Если value не является истинным значением, выбрасывается AssertionError с свойством message , установленным равным значению параметра message. Если параметр message имеет значение undefined, задаётся сообщение об ошибке по умолчанию. Если параметр 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])

• asyncFn <Function> | <Promise>
• error <RegExp> | <Function> | <Object> | <Error>
• 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'
    }
  );
})();

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

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 <string> | <Error>

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

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 <Function>
• error <RegExp> | <Function> | <Object> | <Error>
• message <string>

Ожидает, что функция 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'
    }
    // Only properties on the validation object will be tested for.
    // Using nested objects requires all properties to be present. Otherwise
    // the validation is going to fail.
  }
);

// Using regular expressions to validate error properties:
assert.throws(
  () => {
    throw err;
  },
  {
    // The `name` and `message` properties are strings and using regular
    // expressions on those will match against the string. If they fail, an
    // error is thrown.
    name: /^TypeError$/,
    message: /Wrong/,
    foo: 'bar',
    info: {
      nested: true,
      // It is not possible to use regular expressions for nested properties!
      baz: 'text'
    },
    // The `reg` property contains a regular expression and only if the
    // validation object contains an identical regular expression, it is going
    // to pass.
    reg: /abc/i
  }
);

// Fails due to the different `message` and `name` properties:
assert.throws(
  () => {
    const otherErr = new Error('Not found');
    // Copy all enumerable properties from `err` to `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value;
    }
    throw otherErr;
  },
  // The error's `message` and `name` properties will also be checked when using
  // an error as validation object.
  err
);

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

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

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

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

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

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

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

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

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]

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