Afirmaciones

[Estable: 2 - Estable]

Estable: 2 Estabilidad: 2 - Estable

Código fuente: lib/assert.js

El módulo node:assert proporciona un conjunto de funciones de afirmación para verificar invariantes.

Modo de afirmación estricto

[Historial]

Versión	Cambios
v15.0.0	Expuesto como require('node:assert/strict').
v13.9.0, v12.16.2	Se cambió "modo estricto" a "modo de afirmación estricto" y "modo heredado" a "modo de afirmación heredado" para evitar confusiones con el significado más usual de "modo estricto".
v9.9.0	Se añadieron diferencias de errores al modo de afirmación estricto.
v9.9.0	Se añadió el modo de afirmación estricto al módulo assert.
v9.9.0	Añadido en: v9.9.0

En el modo de afirmación estricto, los métodos no estrictos se comportan como sus correspondientes métodos estrictos. Por ejemplo, assert.deepEqual() se comportará como assert.deepStrictEqual().

En el modo de afirmación estricto, los mensajes de error para los objetos muestran una diferencia. En el modo de afirmación heredado, los mensajes de error para los objetos muestran los objetos, a menudo truncados.

Para usar el modo de afirmación estricto:

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

Ejemplo de diferencia de error:

ESM

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado ... Líneas omitidas
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

CJS

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado ... Líneas omitidas
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

Para desactivar los colores, utilice las variables de entorno NO_COLOR o NODE_DISABLE_COLORS. Esto también desactivará los colores en el REPL. Para obtener más información sobre la compatibilidad con el color en entornos de terminal, lea la documentación de tty getColorDepth().

Modo de afirmación heredado

El modo de afirmación heredado usa el operador == en:

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

Para usar el modo de afirmación heredado:

ESM

import assert from 'node:assert'

CJS

const assert = require('node:assert')

El modo de afirmación heredado puede tener resultados sorprendentes, especialmente cuando se usa assert.deepEqual():

// ¡ADVERTENCIA: Esto no lanza un AssertionError en el modo de afirmación heredado!
assert.deepEqual(/a/gi, new Date())

Clase: assert.AssertionError

• Extiende: <errors.Error>

Indica el fallo de una afirmación. Todos los errores lanzados por el módulo node:assert serán instancias de la clase AssertionError.

new assert.AssertionError(options)

Añadido en: v0.1.21

• options <Object>
  • message <string> Si se proporciona, el mensaje de error se establece en este valor.
  • actual <any> La propiedad actual en la instancia de error.
  • expected <any> La propiedad expected en la instancia de error.
  • operator <string> La propiedad operator en la instancia de error.
  • stackStartFn <Function> Si se proporciona, el rastreo de pila generado omite los frames anteriores a esta función.

Una subclase de Error que indica el fallo de una afirmación.

Todas las instancias contienen las propiedades Error integradas (message y name) y:

• actual <any> Se establece en el argumento actual para métodos como assert.strictEqual().
• expected <any> Se establece en el valor expected para métodos como assert.strictEqual().
• generatedMessage <boolean> Indica si el mensaje fue generado automáticamente (true) o no.
• code <string> El valor siempre es ERR_ASSERTION para mostrar que el error es un error de afirmación.
• operator <string> Se establece en el valor del operador pasado.

ESM

import assert from 'node:assert'

// Generar un AssertionError para comparar el mensaje de error más tarde:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Verificar la salida del error:
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')

// Generar un AssertionError para comparar el mensaje de error más tarde:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Verificar la salida del error:
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)
}

Clase: assert.CallTracker

[Historial]

Versión	Cambios
v20.1.0	La clase assert.CallTracker ha quedado obsoleta y se eliminará en una versión futura.
v14.2.0, v12.19.0	Añadido en: v14.2.0, v12.19.0

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto

Esta característica está obsoleta y se eliminará en una versión futura. Considere usar alternativas como la función auxiliar mock.

new assert.CallTracker()

Añadido en: v14.2.0, v12.19.0

Crea un nuevo objeto CallTracker que se puede usar para rastrear si las funciones se llamaron un número específico de veces. Se debe llamar a tracker.verify() para que se realice la verificación. El patrón habitual sería llamarlo en un manejador process.on('exit').

ESM

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() debe llamarse exactamente 1 vez antes de tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Llama a tracker.verify() y verifica si todas las funciones tracker.calls() han
// sido llamadas el número exacto de veces.
process.on('exit', () => {
  tracker.verify()
})

CJS

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() debe llamarse exactamente 1 vez antes de tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Llama a tracker.verify() y verifica si todas las funciones tracker.calls() han
// sido llamadas el número exacto de veces.
process.on('exit', () => {
  tracker.verify()
})

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

Añadido en: v14.2.0, v12.19.0

• fn <Function> Predeterminado: Una función que no hace nada.
• exact <number> Predeterminado: 1.
• Devuelve: <Function> Una función que envuelve fn.

Se espera que la función envolvente se llame exactamente exact veces. Si la función no se ha llamado exactamente exact veces cuando se llama a tracker.verify(), entonces tracker.verify() lanzará un error.

ESM

import assert from 'node:assert'

// Crea un rastreador de llamadas.
const tracker = new assert.CallTracker()

function func() {}

// Devuelve una función que envuelve func() que debe llamarse un número exacto de veces
// antes de tracker.verify().
const callsfunc = tracker.calls(func)

CJS

const assert = require('node:assert')

// Crea un rastreador de llamadas.
const tracker = new assert.CallTracker()

function func() {}

// Devuelve una función que envuelve func() que debe llamarse un número exacto de veces
// antes de tracker.verify().
const callsfunc = tracker.calls(func)

tracker.getCalls(fn)

Añadido en: v18.8.0, v16.18.0

• fn <Function>
• Devuelve: <Array> Un array con todas las llamadas a una función rastreada.
• Objeto <Object>
  • thisArg <Object>
  • arguments <Array> los argumentos pasados a la función rastreada

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

// Crea un rastreador de llamadas.
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()

Añadido en: v14.2.0, v12.19.0

• Devuelve: <Array> Un array de objetos que contienen información sobre las funciones wrapper devueltas por tracker.calls().
• Objeto <Object>
  • message <string>
  • actual <number> El número real de veces que se llamó a la función.
  • expected <number> El número de veces que se esperaba que se llamara a la función.
  • operator <string> El nombre de la función que se está envolviendo.
  • stack <Object> Un rastreo de pila de la función.

Los arrays contienen información sobre el número esperado y el número real de llamadas de las funciones que no se han llamado el número esperado de veces.

ESM

import assert from 'node:assert'

// Crea un rastreador de llamadas.
const tracker = new assert.CallTracker()

function func() {}

// Devuelve una función que envuelve func() que debe llamarse un número exacto de veces
// antes de tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Devuelve un array que contiene información sobre callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'Se esperaba que la función func se ejecutara 2 vez(ces) pero se ejecutó 0 vez(ces).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: rastreo de pila
//  }
// ]

CJS

const assert = require('node:assert')

// Crea un rastreador de llamadas.
const tracker = new assert.CallTracker()

function func() {}

// Devuelve una función que envuelve func() que debe llamarse un número exacto de veces
// antes de tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Devuelve un array que contiene información sobre callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'Se esperaba que la función func se ejecutara 2 vez(ces) pero se ejecutó 0 vez(ces).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: rastreo de pila
//  }
// ]

tracker.reset([fn])

Añadido en: v18.8.0, v16.18.0

• fn <Function> una función rastreada que se va a restablecer.

Restablece las llamadas del rastreador de llamadas. Si se pasa una función rastreada como argumento, las llamadas se restablecerán para ella. Si no se pasan argumentos, se restablecerán todas las funciones rastreadas.

ESM

import assert from 'node:assert'

const tracker = new assert.CallTracker()

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

callsfunc()
// El rastreador fue llamado una vez
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()
// El rastreador fue llamado una vez
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

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

tracker.verify()

Añadido en: v14.2.0, v12.19.0

Itera a través de la lista de funciones pasadas a tracker.calls() y lanzará un error para las funciones que no hayan sido llamadas el número de veces esperado.

ESM

import assert from 'node:assert'

// Crea un rastreador de llamadas.
const tracker = new assert.CallTracker()

function func() {}

// Devuelve una función que envuelve func() que debe llamarse exactamente tantas veces
// antes de tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Lanzará un error ya que callsfunc() solo se llamó una vez.
tracker.verify()

CJS

const assert = require('node:assert')

// Crea un rastreador de llamadas.
const tracker = new assert.CallTracker()

function func() {}

// Devuelve una función que envuelve func() que debe llamarse exactamente tantas veces
// antes de tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Lanzará un error ya que callsfunc() solo se llamó una vez.
tracker.verify()

assert(value[, message])

Añadido en: v0.5.9

• value <any> La entrada que se comprueba si es verdadera.
• message <string> | <Error>

Un alias de assert.ok().

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

[Historial]

Versión	Cambios
v22.2.0, v20.15.0	La causa del error y las propiedades de los errores ahora también se comparan.
v18.0.0	La propiedad lastIndex de las expresiones regulares ahora también se compara.
v16.0.0, v14.18.0	En el modo de afirmación heredado, el estado cambió de Obsoleto a Heredado.
v14.0.0	NaN ahora se trata como idéntico si ambos lados son NaN.
v12.0.0	Las etiquetas de tipo ahora se comparan correctamente y hay un par de ajustes de comparación menores para que la comprobación sea menos sorprendente.
v9.0.0	Los nombres y mensajes de Error ahora se comparan correctamente.
v8.0.0	El contenido de Set y Map también se compara.
v6.4.0, v4.7.1	Las rebanadas de matrices tipadas ahora se manejan correctamente.
v6.1.0, v4.5.0	Los objetos con referencias circulares ahora se pueden usar como entradas.
v5.10.1, v4.4.3	Manejar matrices tipadas que no sean Uint8Array correctamente.
v0.1.21	Añadido en: v0.1.21

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

Modo de afirmación estricto

Un alias de assert.deepStrictEqual().

Modo de afirmación heredado

[Estable: 3 - Heredado]

Estable: 3 Estabilidad: 3 - Heredado: Use assert.deepStrictEqual() en su lugar.

Prueba la igualdad profunda entre los parámetros actual y expected. Considere usar assert.deepStrictEqual() en su lugar. assert.deepEqual() puede tener resultados sorprendentes.

Igualdad profunda significa que las propiedades propias "enumerables" de los objetos secundarios también se evalúan recursivamente según las siguientes reglas.

Detalles de la comparación

• Los valores primitivos se comparan con el operador ==, con la excepción de NaN. Se considera idéntico en caso de que ambos lados sean NaN.
• Las etiquetas de tipo de los objetos deben ser las mismas.
• Solo se consideran las propiedades propias "enumerables".
• Los nombres, mensajes, causas y errores de Error siempre se comparan, incluso si estas no son propiedades enumerables.
• Los envoltorios de objetos se comparan como objetos y como valores desempaquetados.
• Las propiedades de Object se comparan sin orden.
• Las claves de Map y los elementos de Set se comparan sin orden.
• La recursión se detiene cuando ambos lados difieren o ambos lados encuentran una referencia circular.
• La implementación no prueba el [[Prototype]] de los objetos.
• Las propiedades Symbol no se comparan.
• La comparación de WeakMap y WeakSet no se basa en sus valores, sino solo en sus instancias.
• RegExp lastIndex, flags y source siempre se comparan, incluso si estas no son propiedades enumerables.

El siguiente ejemplo no lanza un AssertionError porque los primitivos se comparan usando el operador ==.

ESM

import assert from 'node:assert'
// WARNING: ¡Esto no lanza un AssertionError!

assert.deepEqual('+00000000', false)

CJS

const assert = require('node:assert')
// WARNING: ¡Esto no lanza un AssertionError!

assert.deepEqual('+00000000', false)

La igualdad "profunda" significa que las propiedades propias "enumerables" de los objetos secundarios también se evalúan:

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

// Los valores de b son diferentes:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Se ignoran los prototipos:
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

// Los valores de b son diferentes:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Se ignoran los prototipos:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

Si los valores no son iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message está indefinido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar del AssertionError.

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

[Historial]

Versión	Cambios
v22.2.0, v20.15.0	La causa del error y las propiedades de error ahora también se comparan.
v18.0.0	La propiedad lastIndex de las expresiones regulares ahora también se compara.
v9.0.0	Ahora se comparan las propiedades de símbolo enumerables.
v9.0.0	El NaN ahora se compara usando la comparación SameValueZero.
v8.5.0	Los nombres y mensajes de Error ahora se comparan correctamente.
v8.0.0	El contenido de Set y Map también se compara.
v6.1.0	Ahora se pueden usar como entradas objetos con referencias circulares.
v6.4.0, v4.7.1	Las rebanadas de matrices tipadas ahora se manejan correctamente.
v5.10.1, v4.4.3	Manejar correctamente las matrices tipadas que no son Uint8Array.
v1.2.0	Añadido en: v1.2.0

• actual <cualquiera>
• expected <cualquiera>
• message <cadena> | <Error>

Prueba la igualdad profunda entre los parámetros actual y expected. La igualdad "profunda" significa que las propiedades "propias" enumerables de los objetos secundarios también se evalúan recursivamente según las siguientes reglas.

Detalles de la comparación

• Los valores primitivos se comparan usando Object.is().
• Las etiquetas de tipo de los objetos deben ser las mismas.
• [[Prototype]] de los objetos se comparan usando el operador ===.
• Solo se consideran las propiedades propias enumerables.
• Los nombres, mensajes, causas y errores de Error siempre se comparan, incluso si no son propiedades enumerables. También se comparan los errors.
• Las propiedades propias enumerables Symbol también se comparan.
• Los envoltorios de objetos se comparan como objetos y como valores desempaquetados.
• Las propiedades de Object se comparan sin orden.
• Las claves de Map y los elementos de Set se comparan sin orden.
• La recursión se detiene cuando ambos lados difieren o ambos lados encuentran una referencia circular.
• La comparación de WeakMap y WeakSet no depende de sus valores. Ver más abajo para más detalles.
• RegExp lastIndex, flags y source siempre se comparan, incluso si no son propiedades enumerables.

ESM

import assert from 'node:assert/strict'

// Esto falla porque 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Los siguientes objetos no tienen propiedades propias
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// Diferente [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + {}
// - Date {}

// Diferentes etiquetas de tipo:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK porque Object.is(NaN, NaN) es true.

// Diferentes números desempaquetados:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK porque el objeto y la cadena son idénticos cuando se desempaquetan.

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

// Diferentes ceros:
assert.deepStrictEqual(0, -0)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, porque es el mismo símbolo en ambos objetos.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Entradas idénticas pero no iguales por referencia:
//
// {
//   [Symbol()]: 1
// }

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

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, porque es imposible comparar las entradas

// Falla porque weakMap3 tiene una propiedad que weakMap1 no contiene:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

CJS

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

// Esto falla porque 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Los siguientes objetos no tienen propiedades propias
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// Diferente [[Prototype]]:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + {}
// - Date {}

// Diferentes etiquetas de tipo:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK porque Object.is(NaN, NaN) es true.

// Diferentes números desempaquetados:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK porque el objeto y la cadena son idénticos cuando se desempaquetan.

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

// Diferentes ceros:
assert.deepStrictEqual(0, -0)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, porque es el mismo símbolo en ambos objetos.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Entradas idénticas pero no iguales por referencia:
//
// {
//   [Symbol()]: 1
// }

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

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, porque es imposible comparar las entradas

// Falla porque weakMap3 tiene una propiedad que weakMap1 no contiene:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Se esperaba que las entradas fueran estrictamente iguales en profundidad:
// + actual - esperado
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

Si los valores no son iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message está indefinido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar de AssertionError.

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

[Historial]

Versión	Cambios
v16.0.0	Esta API ya no es experimental.
v13.6.0, v12.16.0	Añadido en: v13.6.0, v12.16.0

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

Se espera que la entrada string no coincida con la expresión regular.

ESM

import assert from 'node:assert/strict'

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: Se esperaba que la entrada no coincidiera con la ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: El argumento "string" debe ser de tipo string.

assert.doesNotMatch('I will pass', /different/)
// OK

CJS

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

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: Se esperaba que la entrada no coincidiera con la ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: El argumento "string" debe ser de tipo string.

assert.doesNotMatch('I will pass', /different/)
// OK

Si los valores coinciden, o si el argumento string es de un tipo diferente a string, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message no está definido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar del AssertionError.

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

Añadido en: v10.0.0

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

Espera la promesa asyncFn o, si asyncFn es una función, llama inmediatamente a la función y espera a que la promesa devuelta se complete. Luego, comprobará que la promesa no se rechace.

Si asyncFn es una función y lanza un error sincrónicamente, assert.doesNotReject() devolverá una promesa rechazada con ese error. Si la función no devuelve una promesa, assert.doesNotReject() devolverá una promesa rechazada con un error ERR_INVALID_RETURN_VALUE. En ambos casos, se omite el controlador de errores.

El uso de assert.doesNotReject() en realidad no es útil porque hay pocos beneficios en capturar un rechazo y luego rechazarlo nuevamente. En su lugar, considere agregar un comentario junto a la ruta de código específica que no debe rechazar y mantener los mensajes de error lo más expresivos posible.

Si se especifica, error puede ser una Clase, RegExp, o una función de validación. Consulte assert.throws() para obtener más detalles.

Además de la naturaleza asincrónica para esperar la finalización, se comporta de forma idéntica a assert.doesNotThrow().

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

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

[Historial]

Versión	Cambios
v5.11.0, v4.4.5	El parámetro message ahora se respeta.
v4.2.0	El parámetro error ahora puede ser una función de flecha.
v0.1.21	Añadido en: v0.1.21

• fn <Función>
• error <RegExp> | <Función>
• message <cadena>

Asegura que la función fn no arroja un error.

El uso de assert.doesNotThrow() en realidad no es útil porque no hay ningún beneficio en capturar un error y luego volver a lanzarlo. En su lugar, considere agregar un comentario junto a la ruta de código específica que no debería lanzar y mantener los mensajes de error lo más expresivos posible.

Cuando se llama a assert.doesNotThrow(), llamará inmediatamente a la función fn.

Si se lanza un error y es del mismo tipo que el especificado por el parámetro error, se lanza un AssertionError. Si el error es de un tipo diferente, o si el parámetro error está indefinido, el error se propaga al llamador.

Si se especifica, error puede ser una Clase, RegExp, o una función de validación. Consulte assert.throws() para obtener más detalles.

Lo siguiente, por ejemplo, lanzará el TypeError porque no hay ningún tipo de error coincidente en la afirmación:

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Valor incorrecto')
}, SyntaxError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Valor incorrecto')
}, SyntaxError)

Sin embargo, lo siguiente dará como resultado un AssertionError con el mensaje 'Se obtuvo una excepción no deseada...':

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Valor incorrecto')
}, TypeError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Valor incorrecto')
}, TypeError)

Si se lanza un AssertionError y se proporciona un valor para el parámetro message, el valor de message se anexará al mensaje AssertionError:

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(
  () => {
    throw new TypeError('Valor incorrecto')
  },
  /Valor incorrecto/,
  'Ups'
)
// Lanza: AssertionError: Se obtuvo una excepción no deseada: Ups

CJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Valor incorrecto')
  },
  /Valor incorrecto/,
  'Ups'
)
// Lanza: AssertionError: Se obtuvo una excepción no deseada: Ups

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

[Historial]

Versión	Cambios
v16.0.0, v14.18.0	En el modo de afirmación heredado, el estado cambió de Obsoleto a Heredado.
v14.0.0	NaN ahora se trata como idéntico si ambos lados son NaN.
v0.1.21	Añadido en: v0.1.21

• actual <cualquiera>
• expected <cualquiera>
• message <cadena> | <Error>

Modo de afirmación estricto

Un alias de assert.strictEqual().

Modo de afirmación heredado

[Estable: 3 - Heredado]

Estable: 3 Estabilidad: 3 - Heredado: Use assert.strictEqual() en su lugar.

Prueba la igualdad coercitiva superficial entre los parámetros actual y expected usando el operador ==. NaN se maneja especialmente y se trata como idéntico si ambos lados son 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 } }

Si los valores no son iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message no está definido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar de AssertionError.

assert.fail([message])

Añadido en: v0.1.21

• message <string> | <Error> Predeterminado: 'Failed'

Lanza un AssertionError con el mensaje de error proporcionado o un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar de 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

El uso de assert.fail() con más de dos argumentos es posible pero está en desuso. Véase más abajo para más detalles.

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

[Historial]

Versión	Cambios
v10.0.0	Llamar a assert.fail() con más de un argumento está en desuso y emite una advertencia.
v0.1.21	Añadido en: v0.1.21

[Estable: 0 - En desuso]

Estable: 0 Estabilidad: 0 - En desuso: Use assert.fail([message]) u otras funciones assert en su lugar.

• actual <cualquier>
• expected <cualquier>
• message <string> | <Error>
• operator <string> Predeterminado: '!='
• stackStartFn <Función> Predeterminado: assert.fail

Si message es falso, el mensaje de error se establece como los valores de actual y expected separados por el operator proporcionado. Si solo se proporcionan los dos argumentos actual y expected, operator se establecerá por defecto en '!='. Si message se proporciona como tercer argumento, se usará como mensaje de error y los demás argumentos se almacenarán como propiedades en el objeto lanzado. Si se proporciona stackStartFn, todos los marcos de pila por encima de esa función se eliminarán del rastreo de pila (ver Error.captureStackTrace). Si no se dan argumentos, se utilizará el mensaje predeterminado 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

En los tres últimos casos, actual, expected y operator no influyen en el mensaje de error.

Ejemplo de uso de stackStartFn para truncar el rastreo de pila de la excepción:

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)

[Historial]

Versión	Cambios
v10.0.0	En lugar de lanzar el error original, ahora se envuelve en un [AssertionError][] que contiene el rastreo de pila completo.
v10.0.0	El valor ahora solo puede ser undefined o null. Antes, todos los valores falsos se manejaban igual que null y no lanzaban una excepción.
v0.1.97	Añadido en: v0.1.97

• value <cualquier>

Lanza value si value no es undefined o null. Esto es útil al probar el argumento error en las funciones de devolución de llamada. El rastreo de pila contiene todos los marcos del error pasado a ifError(), incluidos los posibles nuevos marcos para ifError() en sí mismo.

ESM

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

// Crear algunos marcos de error aleatorios.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
//     at ifErrorFrame
//     at errorFrame

CJS

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

// Crear algunos marcos de error aleatorios.
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])

[Historial]

Versión	Cambios
v16.0.0	Esta API ya no es experimental.
v13.6.0, v12.16.0	Añadido en: v13.6.0, v12.16.0

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

Se espera que la entrada string coincida con la expresión regular.

ESM

import assert from 'node:assert/strict'

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: La entrada no coincide con la expresión regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: El argumento "string" debe ser de tipo string.

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

CJS

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

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: La entrada no coincide con la expresión regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: El argumento "string" debe ser de tipo string.

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

Si los valores no coinciden, o si el argumento string es de otro tipo que no sea string, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message no está definido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar del AssertionError.

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

[Historial]

Versión	Cambios
v16.0.0, v14.18.0	En el modo de afirmación heredado, el estado cambió de Obsoleto a Heredado.
v14.0.0	NaN ahora se trata como idéntico si ambos lados son NaN.
v9.0.0	Los nombres y mensajes de Error ahora se comparan correctamente.
v8.0.0	El contenido de Set y Map también se compara.
v6.4.0, v4.7.1	Las rebanadas de matrices tipadas ahora se manejan correctamente.
v6.1.0, v4.5.0	Los objetos con referencias circulares ahora se pueden usar como entradas.
v5.10.1, v4.4.3	Manejar matrices tipadas que no sean Uint8Array correctamente.
v0.1.21	Añadido en: v0.1.21

• actual <cualquiera>
• expected <cualquiera>
• message <cadena> | <Error>

Modo de afirmación estricto

Un alias de assert.notDeepStrictEqual().

Modo de afirmación heredado

[Estable: 3 - Heredado]

Estable: 3 Estabilidad: 3 - Heredado: Use assert.notDeepStrictEqual() en su lugar.

Prueba cualquier desigualdad profunda. Opuesto a 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

Si los valores son profundamente iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message no está definido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar de AssertionError.

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

[Historial]

Versión	Cambios
v9.0.0	-0 y +0 ya no se consideran iguales.
v9.0.0	NaN ahora se compara usando la comparación SameValueZero.
v9.0.0	Los nombres y mensajes de Error ahora se comparan correctamente.
v8.0.0	El contenido de Set y Map también se compara.
v6.1.0	Los objetos con referencias circulares ahora se pueden usar como entradas.
v6.4.0, v4.7.1	Las rebanadas de matrices tipadas ahora se manejan correctamente.
v5.10.1, v4.4.3	Manejo correcto de matrices tipadas que no son Uint8Array.
v1.2.0	Añadido en: v1.2.0

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

Prueba de desigualdad estricta profunda. Lo opuesto a 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

Si los valores son profunda y estrictamente iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message está indefinido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar del AssertionError.

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

[Historial]

Versión	Cambios
v16.0.0, v14.18.0	En el modo de afirmación heredado, cambió el estado de Obsoleto a Heredado.
v14.0.0	NaN ahora se trata como idéntico si ambos lados son NaN.
v0.1.21	Añadido en: v0.1.21

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

Modo de afirmación estricto

Un alias de assert.notStrictEqual().

Modo de afirmación heredado

[Estable: 3 - Heredado]

Estable: 3 Estabilidad: 3 - Heredado: Use assert.notStrictEqual() en su lugar.

Prueba la desigualdad coercitiva superficial con el operador !=. NaN se maneja especialmente y se trata como idéntico si ambos lados son 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'

Si los valores son iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message no está definido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar de AssertionError.

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

[Historial]

Versión	Cambios
v10.0.0	La comparación utilizada cambió de Igualdad Estricta a Object.is().
v0.1.21	Añadido en: v0.1.21

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

Prueba la desigualdad estricta entre los parámetros actual y expected según lo determina Object.is().

ESM

import assert from 'node:assert/strict'

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Se esperaba que "actual" fuera estrictamente desigual a:
//
// 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]: Se esperaba que "actual" fuera estrictamente desigual a:
//
// 1

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

Si los valores son estrictamente iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message está indefinido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar del AssertionError.

assert.ok(value[, message])

[Historial]

Versión	Cambios
v10.0.0	assert.ok() (sin argumentos) ahora usará un mensaje de error predefinido.
v0.1.21	Añadido en: v0.1.21

• value <cualquiera>
• message <cadena> | <Error>

Comprueba si value es verdadero. Es equivalente a assert.equal(!!value, true, message).

Si value no es verdadero, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message es undefined, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar de AssertionError. Si no se pasan argumentos, message se establecerá en la cadena: 'No value argument passed to assert.ok()'.

Tenga en cuenta que en el repl el mensaje de error será diferente al que se lanza en un archivo. Consulte a continuación para obtener más detalles.

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

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

// En un archivo (ej. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: La expresión se evaluó a un valor falso:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: La expresión se evaluó a un valor falso:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: La expresión se evaluó a un valor falso:
//
//   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

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

// En un archivo (ej. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: La expresión se evaluó a un valor falso:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: La expresión se evaluó a un valor falso:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: La expresión se evaluó a un valor falso:
//
//   assert.ok(0)

ESM

import assert from 'node:assert/strict'

// Usar `assert()` funciona igual:
assert(0)
// AssertionError: La expresión se evaluó a un valor falso:
//
//   assert(0)

CJS

const assert = require('node:assert')

// Usar `assert()` funciona igual:
assert(0)
// AssertionError: La expresión se evaluó a un valor falso:
//
//   assert(0)

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

Añadido en: v10.0.0

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

Espera la promesa asyncFn o, si asyncFn es una función, llama inmediatamente a la función y espera a que la promesa devuelta se complete. Luego comprobará que la promesa sea rechazada.

Si asyncFn es una función y lanza un error sincrónicamente, assert.rejects() devolverá una promesa rechazada con ese error. Si la función no devuelve una promesa, assert.rejects() devolverá una promesa rechazada con un error ERR_INVALID_RETURN_VALUE. En ambos casos, el controlador de errores se omite.

Además de la naturaleza asíncrona para esperar la finalización, se comporta de forma idéntica a assert.throws().

Si se especifica, error puede ser una Class, RegExp, una función de validación, un objeto donde se probará cada propiedad, o una instancia de error donde se probará cada propiedad, incluidas las propiedades no enumerables message y name.

Si se especifica, message será el mensaje proporcionado por AssertionError si asyncFn no rechaza.

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

error no puede ser una cadena. Si se proporciona una cadena como segundo argumento, se asume que error se omite y la cadena se usará para message en su lugar. Esto puede llevar a errores fáciles de pasar por alto. Lea atentamente el ejemplo en assert.throws() si se considera el uso de una cadena como segundo argumento.

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

[Historial]

Versión	Cambios
v10.0.0	La comparación utilizada cambió de Igualdad Estricta a Object.is().
v0.1.21	Añadido en: v0.1.21

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

Prueba la igualdad estricta entre los parámetros actual y expected según lo determinado por Object.is().

ESM

import assert from 'node:assert/strict'

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Se esperaba que las entradas fueran estrictamente iguales:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Se esperaba que las entradas fueran estrictamente iguales:
// + actual - esperado
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1
const oranges = 2
assert.strictEqual(apples, oranges, `manzanas ${apples} !== naranjas ${oranges}`)
// AssertionError [ERR_ASSERTION]: manzanas 1 !== naranjas 2

assert.strictEqual(1, '1', new TypeError('Las entradas no son idénticas'))
// TypeError: Las entradas no son idénticas

CJS

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

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Se esperaba que las entradas fueran estrictamente iguales:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Se esperaba que las entradas fueran estrictamente iguales:
// + actual - esperado
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

const apples = 1
const oranges = 2
assert.strictEqual(apples, oranges, `manzanas ${apples} !== naranjas ${oranges}`)
// AssertionError [ERR_ASSERTION]: manzanas 1 !== naranjas 2

assert.strictEqual(1, '1', new TypeError('Las entradas no son idénticas'))
// TypeError: Las entradas no son idénticas

Si los valores no son estrictamente iguales, se lanza un AssertionError con una propiedad message establecida en el valor del parámetro message. Si el parámetro message no está definido, se asigna un mensaje de error predeterminado. Si el parámetro message es una instancia de un Error, se lanzará en lugar del AssertionError.

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

[Historial]

Versión	Cambios
v10.2.0	El parámetro error ahora puede ser un objeto que contenga expresiones regulares.
v9.9.0	El parámetro error ahora puede ser también un objeto.
v4.2.0	El parámetro error ahora puede ser una función de flecha.
v0.1.21	Añadido en: v0.1.21

• fn <Función>
• error <RegExp> | <Función> | <Objeto> | <Error>
• message <cadena>

Espera que la función fn lance un error.

Si se especifica, error puede ser una Clase, RegExp, una función de validación, un objeto de validación donde cada propiedad será probada para una igualdad profunda estricta, o una instancia de error donde cada propiedad será probada para una igualdad profunda estricta incluyendo las propiedades no enumerables message y name. Al usar un objeto, también es posible usar una expresión regular al validar contra una propiedad de cadena. Vea los ejemplos a continuación.

Si se especifica, message se anexará al mensaje proporcionado por AssertionError si la llamada a fn falla al lanzar o en caso de que falle la validación del error.

Objeto/instancia de error de validación personalizada:

ESM

import assert from 'node:assert/strict'

const err = new TypeError('Valor incorrecto')
err.code = 404
err.foo = 'bar'
err.info = {
  anidado: true,
  baz: 'texto',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Valor incorrecto',
    info: {
      anidado: true,
      baz: 'texto',
    },
    // Solo se probarán las propiedades del objeto de validación.
    // El uso de objetos anidados requiere que todas las propiedades estén presentes. De lo contrario,
    // la validación fallará.
  }
)

// Usando expresiones regulares para validar las propiedades del error:
assert.throws(
  () => {
    throw err
  },
  {
    // Las propiedades `name` y `message` son cadenas y el uso de expresiones regulares en ellas coincidirá con la cadena. Si fallan, se lanza un
    // error.
    name: /^TypeError$/,
    message: /Incorrecto/,
    foo: 'bar',
    info: {
      anidado: true,
      // ¡No es posible usar expresiones regulares para propiedades anidadas!
      baz: 'texto',
    },
    // La propiedad `reg` contiene una expresión regular y solo si el
    // objeto de validación contiene una expresión regular idéntica, va a
    // pasar.
    reg: /abc/i,
  }
)

// Falla debido a las diferentes propiedades `message` y `name`:
assert.throws(
  () => {
    const otherErr = new Error('No encontrado')
    // Copia todas las propiedades enumerables de `err` a `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Las propiedades `message` y `name` del error también se comprobarán cuando se utilice
  // un error como objeto de validación.
  err
)

CJS

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

const err = new TypeError('Valor incorrecto')
err.code = 404
err.foo = 'bar'
err.info = {
  anidado: true,
  baz: 'texto',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Valor incorrecto',
    info: {
      anidado: true,
      baz: 'texto',
    },
    // Solo se probarán las propiedades del objeto de validación.
    // El uso de objetos anidados requiere que todas las propiedades estén presentes. De lo contrario,
    // la validación fallará.
  }
)

// Usando expresiones regulares para validar las propiedades del error:
assert.throws(
  () => {
    throw err
  },
  {
    // Las propiedades `name` y `message` son cadenas y el uso de expresiones regulares en ellas coincidirá con la cadena. Si fallan, se lanza un
    // error.
    name: /^TypeError$/,
    message: /Incorrecto/,
    foo: 'bar',
    info: {
      anidado: true,
      // ¡No es posible usar expresiones regulares para propiedades anidadas!
      baz: 'texto',
    },
    // La propiedad `reg` contiene una expresión regular y solo si el
    // objeto de validación contiene una expresión regular idéntica, va a
    // pasar.
    reg: /abc/i,
  }
)

// Falla debido a las diferentes propiedades `message` y `name`:
assert.throws(
  () => {
    const otherErr = new Error('No encontrado')
    // Copia todas las propiedades enumerables de `err` a `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Las propiedades `message` y `name` del error también se comprobarán cuando se utilice
  // un error como objeto de validación.
  err
)

Validar instanceof usando constructor:

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Valor incorrecto')
}, Error)

CJS

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

assert.throws(() => {
  throw new Error('Valor incorrecto')
}, Error)

Validar el mensaje de error usando RegExp:

Usar una expresión regular ejecuta .toString en el objeto de error, y por lo tanto también incluirá el nombre del error.

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Valor incorrecto')
}, /^Error: Valor incorrecto$/)

CJS

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

assert.throws(() => {
  throw new Error('Valor incorrecto')
}, /^Error: Valor incorrecto$/)

Validación de error personalizada:

La función debe devolver true para indicar que todas las validaciones internas han pasado. De lo contrario, fallará con un AssertionError.

ESM

import assert from 'node:assert/strict'

assert.throws(
  () => {
    throw new Error('Valor incorrecto')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Evite devolver cualquier cosa de las funciones de validación además de `true`.
    // De lo contrario, no está claro qué parte de la validación falló. En su lugar,
    // lance un error sobre la validación específica que falló (como se hace en este
    // ejemplo) y agregue tanta información de depuración útil a ese error como
    // sea posible.
    return true
  },
  'error inesperado'
)

CJS

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

assert.throws(
  () => {
    throw new Error('Valor incorrecto')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Evite devolver cualquier cosa de las funciones de validación además de `true`.
    // De lo contrario, no está claro qué parte de la validación falló. En su lugar,
    // lance un error sobre la validación específica que falló (como se hace en este
    // ejemplo) y agregue tanta información de depuración útil a ese error como
    // sea posible.
    return true
  },
  'error inesperado'
)

error no puede ser una cadena. Si se proporciona una cadena como segundo argumento, entonces se asume que error se omite y la cadena se usará para message en su lugar. Esto puede llevar a errores fáciles de pasar por alto. Usar el mismo mensaje que el mensaje de error lanzado resultará en un error ERR_AMBIGUOUS_ARGUMENT. Por favor, lea el ejemplo a continuación cuidadosamente si se considera el uso de una cadena como segundo argumento:

ESM

import assert from 'node:assert/strict'

function lanzarPrimero() {
  throw new Error('Primero')
}

function lanzarSegundo() {
  throw new Error('Segundo')
}

function noLanzar() {}

// El segundo argumento es una cadena y la función de entrada lanzó un Error.
// El primer caso no lanzará ya que no coincide con el mensaje de error
// lanzado por la función de entrada!
assert.throws(lanzarPrimero, 'Segundo')
// En el siguiente ejemplo, el mensaje no tiene ningún beneficio sobre el mensaje del
// error y como no está claro si el usuario pretendía realmente coincidir
// contra el mensaje de error, Node.js lanza un error `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(lanzarSegundo, 'Segundo')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// La cadena solo se usa (como mensaje) en caso de que la función no lance:
assert.throws(noLanzar, 'Segundo')
// AssertionError [ERR_ASSERTION]: Falta la excepción esperada: Segundo

// Si se pretendía que coincidiera con el mensaje de error, haz esto en su lugar:
// No lanza porque los mensajes de error coinciden.
assert.throws(lanzarSegundo, /Segundo$/)

// Si el mensaje de error no coincide, se lanza un AssertionError.
assert.throws(lanzarPrimero, /Segundo$/)
// AssertionError [ERR_ASSERTION]

CJS

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

function lanzarPrimero() {
  throw new Error('Primero')
}

function lanzarSegundo() {
  throw new Error('Segundo')
}

function noLanzar() {}

// El segundo argumento es una cadena y la función de entrada lanzó un Error.
// El primer caso no lanzará ya que no coincide con el mensaje de error
// lanzado por la función de entrada!
assert.throws(lanzarPrimero, 'Segundo')
// En el siguiente ejemplo, el mensaje no tiene ningún beneficio sobre el mensaje del
// error y como no está claro si el usuario pretendía realmente coincidir
// contra el mensaje de error, Node.js lanza un error `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(lanzarSegundo, 'Segundo')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// La cadena solo se usa (como mensaje) en caso de que la función no lance:
assert.throws(noLanzar, 'Segundo')
// AssertionError [ERR_ASSERTION]: Falta la excepción esperada: Segundo

// Si se pretendía que coincidiera con el mensaje de error, haz esto en su lugar:
// No lanza porque los mensajes de error coinciden.
assert.throws(lanzarSegundo, /Segundo$/)

// Si el mensaje de error no coincide, se lanza un AssertionError.
assert.throws(lanzarPrimero, /Segundo$/)
// AssertionError [ERR_ASSERTION]

Debido a la confusa notación propensa a errores, evite una cadena como segundo argumento.

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

Añadido en: v23.4.0

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1.0 - Desarrollo temprano

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

assert.partialDeepStrictEqual() Afirma la equivalencia entre los parámetros actual y expected a través de una comparación profunda, asegurando que todas las propiedades en el parámetro expected estén presentes en el parámetro actual con valores equivalentes, sin permitir la coerción de tipos. La principal diferencia con assert.deepStrictEqual() es que assert.partialDeepStrictEqual() no requiere que todas las propiedades del parámetro actual estén presentes en el parámetro expected. Este método siempre debe pasar los mismos casos de prueba que assert.deepStrictEqual(), comportándose como un superconjunto de este.

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