Assert

[Стабильно: 2 - Стабильно]

Стабильно: 2 Стабильность: 2 - Стабильно

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

Модуль node:assert предоставляет набор функций утверждения для проверки инвариантов.

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

[История]

Версия	Изменения
v15.0.0	Представлено как require('node:assert/strict').
v13.9.0, v12.16.2	Изменено "строгий режим" на "строгий режим утверждения", а "устаревший режим" на "устаревший режим утверждения", чтобы избежать путаницы с более обычным значением "строгого режима".
v9.9.0	Добавлены различия ошибок в строгий режим утверждения.
v9.9.0	Добавлен строгий режим утверждения в модуль assert.
v9.9.0	Добавлено в: v9.9.0

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

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

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

ESM

import { strict as assert } from 'node:assert'

CJS

const assert = require('node:assert').strict

ESM

import assert from 'node:assert/strict'

CJS

const assert = require('node:assert/strict')

Пример разницы ошибок:

ESM

import { strict as assert } from 'node:assert'

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Ожидается, что входы будут строго глубоко равны:
// + фактический - ожидаемый ... Пропущено строк
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

CJS

const assert = require('node:assert/strict')

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Ожидается, что входы будут строго глубоко равны:
// + фактический - ожидаемый ... Пропущено строк
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

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

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

В устаревшем режиме утверждений используется оператор == в:

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

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

ESM

import assert from 'node:assert'

CJS

const assert = require('node:assert')

Устаревший режим утверждений может давать неожиданные результаты, особенно при использовании assert.deepEqual():

// ВНИМАНИЕ: В устаревшем режиме утверждений это не вызовет ошибку AssertionError!
assert.deepEqual(/a/gi, new Date())

Класс: assert.AssertionError

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

Указывает на неудачное утверждение. Все ошибки, сгенерированные модулем node:assert, будут экземплярами класса AssertionError.

new assert.AssertionError(options)

Добавлено в: v0.1.21

• options <Object>
  • message <string> Если предоставлено, то сообщение об ошибке устанавливается в это значение.
  • actual <any> Свойство actual в экземпляре ошибки.
  • expected <any> Свойство expected в экземпляре ошибки.
  • operator <string> Свойство operator в экземпляре ошибки.
  • stackStartFn <Function> Если предоставлено, то сгенерированный стек вызова пропускает кадры до этой функции.

Подкласс Error, который указывает на неудачное утверждение.

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

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

ESM

import assert from 'node:assert'

// Сгенерировать AssertionError для последующего сравнения сообщения об ошибке:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Проверить вывод ошибки:
try {
  assert.strictEqual(1, 2)
} catch (err) {
  assert(err instanceof assert.AssertionError)
  assert.strictEqual(err.message, message)
  assert.strictEqual(err.name, 'AssertionError')
  assert.strictEqual(err.actual, 1)
  assert.strictEqual(err.expected, 2)
  assert.strictEqual(err.code, 'ERR_ASSERTION')
  assert.strictEqual(err.operator, 'strictEqual')
  assert.strictEqual(err.generatedMessage, true)
}

CJS

const assert = require('node:assert')

// Сгенерировать AssertionError для последующего сравнения сообщения об ошибке:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Проверить вывод ошибки:
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

[История]

Версия	Изменения
v20.1.0	Класс assert.CallTracker устарел и будет удален в будущей версии.
v14.2.0, v12.19.0	Добавлено в: v14.2.0, v12.19.0

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело

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

new assert.CallTracker()

Добавлено в: v14.2.0, v12.19.0

Создает новый объект CallTracker, который можно использовать для отслеживания того, было ли конкретные функции вызваны определенное количество раз. Для проверки необходимо вызвать tracker.verify(). Обычно его вызывают в обработчике process.on('exit').

ESM

import assert from 'node:assert'
import process from 'node:process'

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() должна быть вызвана ровно 1 раз до tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Вызывает tracker.verify() и проверяет, были ли все функции tracker.calls()
// вызваны ровно столько раз, сколько нужно.
process.on('exit', () => {
  tracker.verify()
})

CJS

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() должна быть вызвана ровно 1 раз до tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Вызывает tracker.verify() и проверяет, были ли все функции tracker.calls()
// вызваны ровно столько раз, сколько нужно.
process.on('exit', () => {
  tracker.verify()
})

tracker.calls([fn][, exact])

Добавлено в: v14.2.0, v12.19.0

• fn <Function> По умолчанию: Функция-пустышка.
• exact <number> По умолчанию: 1.
• Возвращает: <Function> Функция, которая обертывает fn.

Ожидается, что функция-обертка будет вызвана ровно exact раз. Если функция не была вызвана ровно exact раз при вызове tracker.verify(), тогда tracker.verify() выдаст ошибку.

ESM

import assert from 'node:assert'

// Создает отслеживатель вызовов.
const tracker = new assert.CallTracker()

function func() {}

// Возвращает функцию, которая обертывает func(), которая должна быть вызвана
// ровно столько раз, сколько нужно до tracker.verify().
const callsfunc = tracker.calls(func)

CJS

const assert = require('node:assert')

// Создает отслеживатель вызовов.
const tracker = new assert.CallTracker()

function func() {}

// Возвращает функцию, которая обертывает func(), которая должна быть вызвана
// ровно столько раз, сколько нужно до tracker.verify().
const callsfunc = tracker.calls(func)

tracker.getCalls(fn)

Добавлено в: v18.8.0, v16.18.0

• fn <Function>
• Возвращает: <Array> Массив со всеми вызовами отслеживаемой функции.
• Объект <Object>
  • thisArg <Object>
  • arguments <Array> аргументы, переданные отслеживаемой функции.

ESM

import assert from 'node:assert'

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)
callsfunc(1, 2, 3)

assert.deepStrictEqual(tracker.getCalls(callsfunc), [{ thisArg: undefined, arguments: [1, 2, 3] }])

CJS

const assert = require('node:assert')

// Создает отслеживатель вызовов.
const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)
callsfunc(1, 2, 3)

assert.deepStrictEqual(tracker.getCalls(callsfunc), [{ thisArg: undefined, arguments: [1, 2, 3] }])

tracker.report()

Добавлено в: v14.2.0, v12.19.0

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

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

ESM

import assert from 'node:assert'

// Создает отслеживатель вызовов.
const tracker = new assert.CallTracker()

function func() {}

// Возвращает функцию, которая оборачивает func(), которую необходимо вызвать
// точное количество раз перед tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Возвращает массив, содержащий информацию о callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'Ожидалось, что функция func будет выполнена 2 раз(а), но была
//    выполнена 0 раз(а).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: трассировка стека
//  }
// ]

CJS

const assert = require('node:assert')

// Создает отслеживатель вызовов.
const tracker = new assert.CallTracker()

function func() {}

// Возвращает функцию, которая оборачивает func(), которую необходимо вызвать
// точное количество раз перед tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Возвращает массив, содержащий информацию о callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'Ожидалось, что функция func будет выполнена 2 раз(а), но была
//    выполнена 0 раз(а).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: трассировка стека
//  }
// ]

tracker.reset([fn])

Добавлено в: v18.8.0, v16.18.0

• fn <Function> отслеживаемая функция для сброса.

Сбрасывает вызовы трекера вызовов. Если в качестве аргумента передана отслеживаемая функция, ее вызовы будут сброшены. Если аргументы не переданы, будут сброшены все отслеживаемые функции.

ESM

import assert from 'node:assert'

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// Трекер был вызван один раз
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)

CJS

const assert = require('node:assert')

const tracker = new assert.CallTracker()

function func() {}
const callsfunc = tracker.calls(func)

callsfunc()
// Трекер был вызван один раз
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

tracker.reset(callsfunc)
assert.strictEqual(tracker.getCalls(callsfunc).length, 0)

tracker.verify()

Добавлено в: v14.2.0, v12.19.0

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

ESM

import assert from 'node:assert'

// Создает трекер вызовов.
const tracker = new assert.CallTracker()

function func() {}

// Возвращает функцию, которая оборачивает func(), которая должна быть вызвана точное количество раз
// перед tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Выдаст ошибку, так как callsfunc() был вызван только один раз.
tracker.verify()

CJS

const assert = require('node:assert')

// Создает трекер вызовов.
const tracker = new assert.CallTracker()

function func() {}

// Возвращает функцию, которая оборачивает func(), которая должна быть вызвана точное количество раз
// перед tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Выдаст ошибку, так как callsfunc() был вызван только один раз.
tracker.verify()

assert(value[, message])

Добавлено в: v0.5.9

• value <any> Входное значение, которое проверяется на истинность.
• message <string> | <Error>

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

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

[История]

Версия	Изменения
v22.2.0, v20.15.0	Теперь также сравниваются cause ошибки и свойства errors.
v18.0.0	Теперь также сравнивается свойство lastIndex регулярных выражений.
v16.0.0, v14.18.0	В режиме Legacy assertion статус из Deprecated изменен на Legacy.
v14.0.0	NaN теперь считается идентичным, если обе стороны NaN.
v12.0.0	Теперь теги типов сравниваются корректно, и есть пара незначительных корректировок сравнения, чтобы сделать проверку менее неожиданной.
v9.0.0	Теперь корректно сравниваются имена и сообщения Error.
v8.0.0	Также сравнивается содержимое Set и Map.
v6.4.0, v4.7.1	Теперь корректно обрабатываются срезы типизированных массивов.
v6.1.0, v4.5.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v5.10.1, v4.4.3	Корректно обрабатываются типизированные массивы, отличные от Uint8Array.
v0.1.21	Добавлено в: v0.1.21

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

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

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

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

[Стабильно: 3 - Legacy]

Стабильно: 3 Стабильность: 3 - Legacy: Вместо этого используйте assert.deepStrictEqual().

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

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

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

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

Следующий пример не выбрасывает AssertionError, потому что примитивы сравниваются с использованием == operator.

ESM

import assert from 'node:assert'
// WARNING: Это не вызовет AssertionError!

assert.deepEqual('+00000000', false)

CJS

const assert = require('node:assert')
// WARNING: Это не вызовет AssertionError!

assert.deepEqual('+00000000', false)

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

ESM

import assert from 'node:assert'

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

assert.deepEqual(obj1, obj1)
// OK

// Значения b отличаются:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Прототипы игнорируются:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

CJS

const assert = require('node:assert')

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

assert.deepEqual(obj1, obj1)
// OK

// Значения b отличаются:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Прототипы игнорируются:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

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

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

[История]

Версия	Изменения
v22.2.0, v20.15.0	Свойства причины ошибки и ошибок теперь также сравниваются.
v18.0.0	Свойство lastIndex регулярных выражений теперь также сравнивается.
v9.0.0	Теперь сравниваются перечислимые свойства символов.
v9.0.0	Теперь NaN сравнивается с использованием сравнения SameValueZero.
v8.5.0	Теперь имена и сообщения Error корректно сравниваются.
v8.0.0	Теперь также сравнивается содержимое Set и Map.
v6.1.0	Теперь в качестве входных данных можно использовать объекты с циклическими ссылками.
v6.4.0, v4.7.1	Теперь срезы типизированных массивов обрабатываются корректно.
v5.10.1, v4.4.3	Корректная обработка типизированных массивов, отличных от Uint8Array.
v1.2.0	Добавлено в: v1.2.0

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

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

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

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

ESM

import assert from 'node:assert/strict'

// Это не проходит, потому что 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Следующие объекты не имеют собственных свойств
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// Различные [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + {}
// - Date {}

// Разные теги типов:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK, потому что Object.is(NaN, NaN) истинно.

// Разные распакованные числа:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK, потому что объект и строка идентичны при распаковке.

assert.deepStrictEqual(-0, -0)
// OK

// Разные нули:
assert.deepStrictEqual(0, -0)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, потому что это один и тот же символ в обоих объектах.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Входные данные идентичны, но не равны по ссылке:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, потому что невозможно сравнить записи

// Не проходит, потому что weakMap3 содержит свойство, которого нет в weakMap1:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

CJS

const assert = require('node:assert/strict')

// Это не проходит, потому что 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Следующие объекты не имеют собственных свойств
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// Различные [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + {}
// - Date {}

// Разные теги типов:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK, потому что Object.is(NaN, NaN) истинно.

// Разные распакованные числа:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK, потому что объект и строка идентичны при распаковке.

assert.deepStrictEqual(-0, -0)
// OK

// Разные нули:
assert.deepStrictEqual(0, -0)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, потому что это один и тот же символ в обоих объектах.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Входные данные идентичны, но не равны по ссылке:
//
// {
//   [Symbol()]: 1
// }

const weakMap1 = new WeakMap()
const weakMap2 = new WeakMap([[{}, {}]])
const weakMap3 = new WeakMap()
weakMap3.unequal = true

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, потому что невозможно сравнить записи

// Не проходит, потому что weakMap3 содержит свойство, которого нет в weakMap1:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Ожидалось, что входные данные будут строго глубоко равны:
// + фактическое - ожидаемое
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

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

assert.doesNotMatch(string, regexp[, message])

[История]

Версия	Изменения
v16.0.0	Этот API больше не является экспериментальным.
v13.6.0, v12.16.0	Добавлено в: v13.6.0, v12.16.0

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

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

ESM

import assert from 'node:assert/strict'

assert.doesNotMatch('Я провалюсь', /fail/)
// AssertionError [ERR_ASSERTION]: Ожидалось, что ввод не будет соответствовать...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.doesNotMatch('Я пройду', /different/)
// OK

CJS

const assert = require('node:assert/strict')

assert.doesNotMatch('Я провалюсь', /fail/)
// AssertionError [ERR_ASSERTION]: Ожидалось, что ввод не будет соответствовать...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.doesNotMatch('Я пройду', /different/)
// OK

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

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

Добавлено в: v10.0.0

• asyncFn <Function> | <Promise>
• error <RegExp> | <Function>
• message <string>

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

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

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

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

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

ESM

import assert from 'node:assert/strict'

await assert.doesNotReject(async () => {
  throw new TypeError('Неправильное значение')
}, SyntaxError)

CJS

const assert = require('node:assert/strict')

;(async () => {
  await assert.doesNotReject(async () => {
    throw new TypeError('Неправильное значение')
  }, SyntaxError)
})()

ESM

import assert from 'node:assert/strict'

assert.doesNotReject(Promise.reject(new TypeError('Неправильное значение'))).then(() => {
  // ...
})

CJS

const assert = require('node:assert/strict')

assert.doesNotReject(Promise.reject(new TypeError('Неправильное значение'))).then(() => {
  // ...
})

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

[История]

Версия	Изменения
v5.11.0, v4.4.5	Параметр message теперь учитывается.
v4.2.0	Параметр error теперь может быть стрелочной функцией.
v0.1.21	Добавлено в: v0.1.21

• fn <Function>
• error <RegExp> | <Function>
• message <string>

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

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

Когда вызывается assert.doesNotThrow(), она немедленно вызывает функцию fn.

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

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

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

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Неверное значение')
}, SyntaxError)

CJS

const assert = require('node:assert/strict')

assert.doesNotThrow(() => {
  throw new TypeError('Неверное значение')
}, SyntaxError)

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

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Неверное значение')
}, TypeError)

CJS

const assert = require('node:assert/strict')

assert.doesNotThrow(() => {
  throw new TypeError('Неверное значение')
}, TypeError)

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

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(
  () => {
    throw new TypeError('Неверное значение')
  },
  /Неверное значение/,
  'Ой'
)
// Выбрасывает: AssertionError: Получено нежелательное исключение: Ой

CJS

const assert = require('node:assert/strict')

assert.doesNotThrow(
  () => {
    throw new TypeError('Неверное значение')
  },
  /Неверное значение/,
  'Ой'
)
// Выбрасывает: AssertionError: Получено нежелательное исключение: Ой

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

[История]

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревшего утверждения изменен статус с устаревшего на устаревший.
v14.0.0	NaN теперь считается идентичным, если обе стороны являются NaN.
v0.1.21	Добавлено в: v0.1.21

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

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

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

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

[Стабильно: 3 - Устарело]

Стабильно: 3 Стабильность: 3 - Устарело: Вместо этого используйте assert.strictEqual().

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

ESM

import assert from 'node:assert'

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

assert.equal(1, 2)
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } })
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

CJS

const assert = require('node:assert')

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

assert.equal(1, 2)
// AssertionError: 1 == 2
assert.equal({ a: { b: 1 } }, { a: { b: 1 } })
// AssertionError: { a: { b: 1 } } == { a: { b: 1 } }

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

assert.fail([message])

Добавлено в: v0.1.21

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

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

ESM

import assert from 'node:assert/strict'

assert.fail()
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom')
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'))
// TypeError: need array

CJS

const assert = require('node:assert/strict')

assert.fail()
// AssertionError [ERR_ASSERTION]: Failed

assert.fail('boom')
// AssertionError [ERR_ASSERTION]: boom

assert.fail(new TypeError('need array'))
// TypeError: need array

Использование assert.fail() с более чем двумя аргументами возможно, но не рекомендуется. Подробности смотрите ниже.

assert.fail(actual, expected[, message[, operator[, stackStartFn]]])

[История]

Версия	Изменения
v10.0.0	Вызов assert.fail() с более чем одним аргументом является устаревшим и выдает предупреждение.
v0.1.21	Добавлено в: v0.1.21

[Стабильность: 0 - Устарело]

Стабильность: 0 Стабильность: 0 - Устарело: Вместо этого используйте assert.fail([message]) или другие функции assert.

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

ESM

import assert from 'node:assert/strict'

assert.fail('a', 'b')
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>')
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail')
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>')
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'))
// TypeError: need array

CJS

const assert = require('node:assert/strict')

assert.fail('a', 'b')
// AssertionError [ERR_ASSERTION]: 'a' != 'b'

assert.fail(1, 2, undefined, '>')
// AssertionError [ERR_ASSERTION]: 1 > 2

assert.fail(1, 2, 'fail')
// AssertionError [ERR_ASSERTION]: fail

assert.fail(1, 2, 'whoops', '>')
// AssertionError [ERR_ASSERTION]: whoops

assert.fail(1, 2, new TypeError('need array'))
// TypeError: need array

В последних трех случаях actual, expected и operator не влияют на сообщение об ошибке.

Пример использования stackStartFn для усечения трассировки стека исключения:

ESM

import assert from 'node:assert/strict'

function suppressFrame() {
  assert.fail('a', 'b', undefined, '!==', suppressFrame)
}
suppressFrame()
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
//     at repl:1:1
//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
//     ...

CJS

const assert = require('node:assert/strict')

function suppressFrame() {
  assert.fail('a', 'b', undefined, '!==', suppressFrame)
}
suppressFrame()
// AssertionError [ERR_ASSERTION]: 'a' !== 'b'
//     at repl:1:1
//     at ContextifyScript.Script.runInThisContext (vm.js:44:33)
//     ...

assert.ifError(value)

[История]

Версия	Изменения
v10.0.0	Вместо выбрасывания исходной ошибки теперь она оборачивается в [AssertionError][], который содержит полную трассировку стека.
v10.0.0	Значение теперь может быть только undefined или null. Раньше все ложные значения обрабатывались так же, как null, и не вызывали ошибку.
v0.1.97	Добавлено в: v0.1.97

• value <any>

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

ESM

import assert from 'node:assert/strict'

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: Error

// Создайте несколько случайных кадров ошибок.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: test error
//     at ifErrorFrame
//     at errorFrame

CJS

const assert = require('node:assert/strict')

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: Error

// Создайте несколько случайных кадров ошибок.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError получил нежелательное исключение: test error
//     at ifErrorFrame
//     at errorFrame

assert.match(string, regexp[, message])

[История]

Версия	Изменения
v16.0.0	Этот API больше не является экспериментальным.
v13.6.0, v12.16.0	Добавлено в: v13.6.0, v12.16.0

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

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

ESM

import assert from 'node:assert/strict'

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: Входные данные не соответствуют регулярному ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.match('I will pass', /pass/)
// OK

CJS

const assert = require('node:assert/strict')

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: Входные данные не соответствуют регулярному ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: Аргумент "string" должен быть типа string.

assert.match('I will pass', /pass/)
// OK

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

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

[История]

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревшего утверждения изменен статус с Устаревший на Устаревший.
v14.0.0	NaN теперь считается идентичным, если обе стороны являются NaN.
v9.0.0	Имена и сообщения Error теперь сравниваются правильно.
v8.0.0	Также сравнивается содержимое Set и Map.
v6.4.0, v4.7.1	Срезы типизированных массивов теперь обрабатываются правильно.
v6.1.0, v4.5.0	Объекты с циклическими ссылками теперь могут использоваться в качестве входных данных.
v5.10.1, v4.4.3	Правильная обработка типизированных массивов, отличных от Uint8Array.
v0.1.21	Добавлено в: v0.1.21

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

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

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

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

[Стабильный: 3 - Устаревший]

Стабильный: 3 Стабильность: 3 - Устаревший: Используйте assert.notDeepStrictEqual() вместо этого.

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

ESM

import assert from 'node:assert'

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

assert.notDeepEqual(obj1, obj1)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2)
// OK

assert.notDeepEqual(obj1, obj3)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4)
// OK

CJS

const assert = require('node:assert')

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

assert.notDeepEqual(obj1, obj1)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj2)
// OK

assert.notDeepEqual(obj1, obj3)
// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }

assert.notDeepEqual(obj1, obj4)
// OK

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

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

[История]

Версия	Изменения
v9.0.0	-0 и +0 больше не считаются равными.
v9.0.0	NaN теперь сравнивается с использованием сравнения SameValueZero.
v9.0.0	Имена и сообщения Error теперь сравниваются правильно.
v8.0.0	Также сравнивается содержимое Set и Map.
v6.1.0	Объекты с циклическими ссылками теперь могут использоваться в качестве входных данных.
v6.4.0, v4.7.1	Срезы типизированных массивов теперь обрабатываются правильно.
v5.10.1, v4.4.3	Правильно обрабатываются типизированные массивы, отличные от Uint8Array.
v1.2.0	Добавлено в: v1.2.0

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

const assert = require('node:assert/strict')

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

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

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

[История]

Версия	Изменения
v16.0.0, v14.18.0	В режиме устаревшего утверждения, статус из устаревшего был изменен на устаревший.
v14.0.0	NaN теперь считается идентичным, если обе стороны являются NaN.
v0.1.21	Добавлено в: v0.1.21

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

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

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

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

[Стабильный: 3 - Устаревший]

Стабильный: 3 Стабильность: 3 - Устаревший: Вместо этого используйте assert.notStrictEqual().

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

ESM

import assert from 'node:assert'

assert.notEqual(1, 2)
// OK

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

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

CJS

const assert = require('node:assert')

assert.notEqual(1, 2)
// OK

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

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

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

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

[История]

Версия	Изменения
v10.0.0	Используемое сравнение изменено с строгого равенства на Object.is().
v0.1.21	Добавлено в: v0.1.21

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

Проверяет строгое неравенство между параметрами actual и expected, как это определяется Object.is().

ESM

import assert from 'node:assert/strict'

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Ожидалось, что "actual" будет строго не равен:
//
// 1

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

CJS

const assert = require('node:assert/strict')

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Ожидалось, что "actual" будет строго не равен:
//
// 1

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

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

assert.ok(value[, message])

[История]

Версия	Изменения
v10.0.0	assert.ok() (без аргументов) теперь будет использовать предопределенное сообщение об ошибке.
v0.1.21	Добавлено в: v0.1.21

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

ESM

import assert from 'node:assert/strict'

assert.ok(true)
// OK
assert.ok(1)
// OK

assert.ok()
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, "it's false")
// AssertionError: it's false

// В repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// В файле (например, test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert.ok(0)

CJS

const assert = require('node:assert/strict')

assert.ok(true)
// OK
assert.ok(1)
// OK

assert.ok()
// AssertionError: No value argument passed to `assert.ok()`

assert.ok(false, "it's false")
// AssertionError: it's false

// В repl:
assert.ok(typeof 123 === 'string')
// AssertionError: false == true

// В файле (например, test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert.ok(0)

ESM

import assert from 'node:assert/strict'

// Использование `assert()` работает так же:
assert(0)
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert(0)

CJS

const assert = require('node:assert')

// Использование `assert()` работает так же:
assert(0)
// AssertionError: Выражение оценилось как ложное значение:
//
//   assert(0)

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

Добавлено в: v10.0.0

• 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 не удастся отклонить.

ESM

import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Неверное значение')
  },
  {
    name: 'TypeError',
    message: 'Неверное значение',
  }
)

CJS

const assert = require('node:assert/strict')

;(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Неверное значение')
    },
    {
      name: 'TypeError',
      message: 'Неверное значение',
    }
  )
})()

ESM

import assert from 'node:assert/strict'

await assert.rejects(
  async () => {
    throw new TypeError('Неверное значение')
  },
  err => {
    assert.strictEqual(err.name, 'TypeError')
    assert.strictEqual(err.message, 'Неверное значение')
    return true
  }
)

CJS

const assert = require('node:assert/strict')

;(async () => {
  await assert.rejects(
    async () => {
      throw new TypeError('Неверное значение')
    },
    err => {
      assert.strictEqual(err.name, 'TypeError')
      assert.strictEqual(err.message, 'Неверное значение')
      return true
    }
  )
})()

ESM

import assert from 'node:assert/strict'

assert.rejects(Promise.reject(new Error('Неверное значение')), Error).then(() => {
  // ...
})

CJS

const assert = require('node:assert/strict')

assert.rejects(Promise.reject(new Error('Неверное значение')), Error).then(() => {
  // ...
})

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

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

[История]

Версия	Изменения
v10.0.0	Использованное сравнение изменено со строгого равенства на Object.is().
v0.1.21	Добавлено в: v0.1.21

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

Проверяет строгое равенство между параметрами actual и expected, как определено с помощью Object.is().

ESM

import assert from 'node:assert/strict'

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Ожидалось, что входные данные будут строго равны:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Ожидалось, что входные данные будут строго равны:
// + 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('Входные данные не идентичны'))
// TypeError: Входные данные не идентичны

CJS

const assert = require('node:assert/strict')

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Ожидалось, что входные данные будут строго равны:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Ожидалось, что входные данные будут строго равны:
// + 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('Входные данные не идентичны'))
// TypeError: Входные данные не идентичны

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

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

[История]

Версия	Изменения
v10.2.0	Параметр error теперь может быть объектом, содержащим регулярные выражения.
v9.9.0	Параметр error теперь также может быть объектом.
v4.2.0	Параметр error теперь может быть стрелочной функцией.
v0.1.21	Добавлено в: v0.1.21

• fn <Function>
• error <RegExp> | <Function> | <Object> | <Error>
• message <string>

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

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

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

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

ESM

import assert from 'node:assert/strict'

const err = new TypeError('Неправильное значение')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Неправильное значение',
    info: {
      nested: true,
      baz: 'text',
    },
    // Будут проверены только свойства в объекте проверки.
    // Использование вложенных объектов требует наличия всех свойств. В противном случае
    // проверка не пройдет.
  }
)

// Использование регулярных выражений для проверки свойств ошибки:
assert.throws(
  () => {
    throw err
  },
  {
    // Свойства `name` и `message` являются строками, и использование регулярных
    // выражений для них будет сопоставляться со строкой. Если они не совпадают,
    // будет выдана ошибка.
    name: /^TypeError$/,
    message: /Неправильное/,
    foo: 'bar',
    info: {
      nested: true,
      // Невозможно использовать регулярные выражения для вложенных свойств!
      baz: 'text',
    },
    // Свойство `reg` содержит регулярное выражение, и только если
    // объект проверки содержит идентичное регулярное выражение, проверка
    // пройдёт.
    reg: /abc/i,
  }
)

// Не пройдёт из-за различий в свойствах `message` и `name`:
assert.throws(
  () => {
    const otherErr = new Error('Не найдено')
    // Копирование всех перечисляемых свойств из `err` в `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Свойства `message` и `name` ошибки также будут проверены при использовании
  // ошибки в качестве объекта проверки.
  err
)

CJS

const assert = require('node:assert/strict')

const err = new TypeError('Неправильное значение')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Неправильное значение',
    info: {
      nested: true,
      baz: 'text',
    },
    // Будут проверены только свойства в объекте проверки.
    // Использование вложенных объектов требует наличия всех свойств. В противном случае
    // проверка не пройдет.
  }
)

// Использование регулярных выражений для проверки свойств ошибки:
assert.throws(
  () => {
    throw err
  },
  {
    // Свойства `name` и `message` являются строками, и использование регулярных
    // выражений для них будет сопоставляться со строкой. Если они не совпадают,
    // будет выдана ошибка.
    name: /^TypeError$/,
    message: /Неправильное/,
    foo: 'bar',
    info: {
      nested: true,
      // Невозможно использовать регулярные выражения для вложенных свойств!
      baz: 'text',
    },
    // Свойство `reg` содержит регулярное выражение, и только если
    // объект проверки содержит идентичное регулярное выражение, проверка
    // пройдёт.
    reg: /abc/i,
  }
)

// Не пройдёт из-за различий в свойствах `message` и `name`:
assert.throws(
  () => {
    const otherErr = new Error('Не найдено')
    // Копирование всех перечисляемых свойств из `err` в `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Свойства `message` и `name` ошибки также будут проверены при использовании
  // ошибки в качестве объекта проверки.
  err
)

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

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Неправильное значение')
}, Error)

CJS

const assert = require('node:assert/strict')

assert.throws(() => {
  throw new Error('Неправильное значение')
}, Error)

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

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

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Неправильное значение')
}, /^Error: Неправильное значение$/)

CJS

const assert = require('node:assert/strict')

assert.throws(() => {
  throw new Error('Неправильное значение')
}, /^Error: Неправильное значение$/)

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

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

ESM

import assert from 'node:assert/strict'

assert.throws(
  () => {
    throw new Error('Неправильное значение')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Избегайте возвращения чего-либо из функций проверки, кроме `true`.
    // В противном случае неясно, какая часть проверки не удалась. Вместо этого,
    // сгенерируйте ошибку о конкретной проверке, которая не удалась (как сделано в этом
    // примере) и добавьте как можно больше полезной отладочной информации к этой ошибке.
    return true
  },
  'неожиданная ошибка'
)

CJS

const assert = require('node:assert/strict')

assert.throws(
  () => {
    throw new Error('Неправильное значение')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Избегайте возвращения чего-либо из функций проверки, кроме `true`.
    // В противном случае неясно, какая часть проверки не удалась. Вместо этого,
    // сгенерируйте ошибку о конкретной проверке, которая не удалась (как сделано в этом
    // примере) и добавьте как можно больше полезной отладочной информации к этой ошибке.
    return true
  },
  'неожиданная ошибка'
)

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

ESM

import assert from 'node:assert/strict'

function throwingFirst() {
  throw new Error('Первая')
}

function throwingSecond() {
  throw new Error('Вторая')
}

function notThrowing() {}

// Второй аргумент - строка, и входная функция выдала ошибку Error.
// Первый случай не вызовет ошибку, поскольку он не соответствует сообщению об ошибке,
// вызванному входной функцией!
assert.throws(throwingFirst, 'Вторая')
// В следующем примере сообщение не имеет преимущества перед сообщением из
// ошибки, и поскольку неясно, намеревался ли пользователь фактически сопоставить
// сообщение об ошибке, Node.js выдает ошибку `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Вторая')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// Строка используется только (как сообщение) в случае, если функция не выдает ошибку:
assert.throws(notThrowing, 'Вторая')
// AssertionError [ERR_ASSERTION]: Отсутствует ожидаемое исключение: Вторая

// Если предполагалось сопоставить сообщение об ошибке, сделайте это вместо этого:
// Он не выдает ошибку, потому что сообщения об ошибках совпадают.
assert.throws(throwingSecond, /Вторая$/)

// Если сообщение об ошибке не совпадает, выдается AssertionError.
assert.throws(throwingFirst, /Вторая$/)
// AssertionError [ERR_ASSERTION]

CJS

const assert = require('node:assert/strict')

function throwingFirst() {
  throw new Error('Первая')
}

function throwingSecond() {
  throw new Error('Вторая')
}

function notThrowing() {}

// Второй аргумент - строка, и входная функция выдала ошибку Error.
// Первый случай не вызовет ошибку, поскольку он не соответствует сообщению об ошибке,
// вызванному входной функцией!
assert.throws(throwingFirst, 'Вторая')
// В следующем примере сообщение не имеет преимущества перед сообщением из
// ошибки, и поскольку неясно, намеревался ли пользователь фактически сопоставить
// сообщение об ошибке, Node.js выдает ошибку `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Вторая')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// Строка используется только (как сообщение) в случае, если функция не выдает ошибку:
assert.throws(notThrowing, 'Вторая')
// AssertionError [ERR_ASSERTION]: Отсутствует ожидаемое исключение: Вторая

// Если предполагалось сопоставить сообщение об ошибке, сделайте это вместо этого:
// Он не выдает ошибку, потому что сообщения об ошибках совпадают.
assert.throws(throwingSecond, /Вторая$/)

// Если сообщение об ошибке не совпадает, выдается AssertionError.
assert.throws(throwingFirst, /Вторая$/)
// AssertionError [ERR_ASSERTION]

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

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

Добавлено в: v23.4.0

[Стабильность: 1 - Экспериментальная]

Стабильность: 1 Стабильность: 1.0 - Ранняя разработка

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

assert.partialDeepStrictEqual() Утверждает эквивалентность между параметрами actual и expected посредством глубокого сравнения, гарантируя, что все свойства в параметре expected присутствуют в параметре actual с эквивалентными значениями, не допуская приведения типов. Основное отличие от assert.deepStrictEqual() заключается в том, что assert.partialDeepStrictEqual() не требует, чтобы все свойства в параметре actual присутствовали в параметре expected. Этот метод всегда должен проходить те же тесты, что и assert.deepStrictEqual(), ведя себя как его супермножество.

ESM

import assert from 'node:assert'

assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })
// OK

assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual(new Set(['value1', 'value2']), new Set(['value1', 'value2']))
// OK

assert.partialDeepStrictEqual(new Map([['key1', 'value1']]), new Map([['key1', 'value1']]))
// OK

assert.partialDeepStrictEqual(new Uint8Array([1, 2, 3]), new Uint8Array([1, 2, 3]))
// OK

assert.partialDeepStrictEqual(/abc/, /abc/)
// OK

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]))
// OK

assert.partialDeepStrictEqual(new Date(0), new Date(0))
// OK

assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } })
// AssertionError

CJS

const assert = require('node:assert')

assert.partialDeepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual({ a: { b: { c: 1 } } }, { a: { b: { c: 1 } } })
// OK

assert.partialDeepStrictEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })
// OK

assert.partialDeepStrictEqual([{ a: 5 }, { b: 5 }], [{ a: 5 }])
// OK

assert.partialDeepStrictEqual(new Set([{ a: 1 }, { b: 1 }]), new Set([{ a: 1 }]))
// OK

assert.partialDeepStrictEqual({ a: 1 }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: 1, b: '2' }, { a: 1, b: 2 })
// AssertionError

assert.partialDeepStrictEqual({ a: { b: 2 } }, { a: { b: '2' } })
// AssertionError