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

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

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

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

• 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 <Объект>
  • 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 <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, так как примитивы считаются равными в соответствии с Абстрактным сравнением на равенство ( == ).

// 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 <any>
• expected <any>
• message <string> | <Error>

Проверка глубокого равенства между параметрами 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 <Функция> | <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().

(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 <RegExp> | <Функция>
• 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 с помощью абстрактного сравнения на равенство (==). Значение NaN обрабатывается особым образом и считается равным, если обе стороны являются NaN.

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.

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

• 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 <любой>
• expected <любой>
• message <строка> | <ошибка>

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

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

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

Проверяет поверхностное, когерентное неравенство с помощью абстрактного сравнения на равенство (!= ). NaN обрабатывается особым образом и считается идентичным, если обе стороны — NaN.

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.

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 сообщение об ошибке будет отличаться от сообщения в файле! Смотрите подробности ниже.

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 <Функция> | <Обещание>
• 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 не отклоняется.

(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 <любой>
• expected <любой>
• message <строка> | <ошибка>

Проверяет строгое равенство между параметрами 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 <Функция>
• error <RegExp> | <Функция> | <Объект> | <Ошибка>
• 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'
    }
    // 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
);

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

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]

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