Assertion

[Stable : 2 - Stable]

Stable : 2 Stability : 2 - Stable

Code source : lib/assert.js

Le module node:assert fournit un ensemble de fonctions d'assertion pour vérifier les invariants.

Mode d'assertion strict

[Historique]

Version	Modifications
v15.0.0	Exposé comme require('node:assert/strict').
v13.9.0, v12.16.2	« mode strict » renommé en « mode d'assertion strict » et « mode hérité » en « mode d'assertion hérité » pour éviter toute confusion avec le sens habituel de « mode strict ».
v9.9.0	Ajout de différences d'erreurs au mode d'assertion strict.
v9.9.0	Ajout du mode d'assertion strict au module assert.
v9.9.0	Ajouté dans : v9.9.0

En mode d'assertion strict, les méthodes non strictes se comportent comme leurs méthodes strictes correspondantes. Par exemple, assert.deepEqual() se comportera comme assert.deepStrictEqual().

En mode d'assertion strict, les messages d'erreur pour les objets affichent une différence. En mode d'assertion hérité, les messages d'erreur pour les objets affichent les objets, souvent tronqués.

Pour utiliser le mode d'assertion strict :

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

Exemple de différence d'erreur :

ESM

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

CJS

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected ... Lines skipped
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

Pour désactiver les couleurs, utilisez les variables d'environnement NO_COLOR ou NODE_DISABLE_COLORS. Cela désactivera également les couleurs dans le REPL. Pour plus d'informations sur la prise en charge des couleurs dans les environnements de terminal, consultez la documentation tty getColorDepth().

Mode d'assertion hérité

Le mode d'assertion hérité utilise l'opérateur == dans :

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

Pour utiliser le mode d'assertion hérité :

ESM

import assert from 'node:assert'

CJS

const assert = require('node:assert')

Le mode d'assertion hérité peut produire des résultats surprenants, notamment lors de l'utilisation de assert.deepEqual() :

// ATTENTION : Cela ne lève pas d'AssertionError en mode d'assertion hérité !
assert.deepEqual(/a/gi, new Date())

Classe : assert.AssertionError

• Étend : <errors.Error>

Indique l'échec d'une assertion. Toutes les erreurs levées par le module node:assert seront des instances de la classe AssertionError.

new assert.AssertionError(options)

Ajouté dans : v0.1.21

• options <Object>
  • message <string> Si fourni, le message d'erreur est défini sur cette valeur.
  • actual <any> La propriété actual de l'instance d'erreur.
  • expected <any> La propriété expected de l'instance d'erreur.
  • operator <string> La propriété operator de l'instance d'erreur.
  • stackStartFn <Function> Si fourni, la trace de pile générée omet les frames avant cette fonction.

Une sous-classe de Error qui indique l'échec d'une assertion.

Toutes les instances contiennent les propriétés Error intégrées (message et name) et :

• actual <any> Défini sur l'argument actual pour les méthodes telles que assert.strictEqual().
• expected <any> Défini sur la valeur expected pour les méthodes telles que assert.strictEqual().
• generatedMessage <boolean> Indique si le message a été généré automatiquement (true) ou non.
• code <string> La valeur est toujours ERR_ASSERTION pour indiquer que l'erreur est une erreur d'assertion.
• operator <string> Défini sur la valeur de l'opérateur passée.

ESM

import assert from 'node:assert'

// Générer une AssertionError pour comparer le message d'erreur plus tard :
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Vérifier la sortie d'erreur :
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')

// Générer une AssertionError pour comparer le message d'erreur plus tard :
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Vérifier la sortie d'erreur :
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)
}

Classe : assert.CallTracker

[Historique]

Version	Modifications
v20.1.0	La classe assert.CallTracker est obsolète et sera supprimée dans une future version.
v14.2.0, v12.19.0	Ajoutée dans : v14.2.0, v12.19.0

[Stable : 0 - Obsolete]

Stable : 0 Stabilité : 0 - Obsolete

Cette fonctionnalité est obsolète et sera supprimée dans une future version. Veuillez envisager d’utiliser des alternatives telles que la fonction d’assistance mock.

new assert.CallTracker()

Ajouté dans : v14.2.0, v12.19.0

Crée un nouvel objet CallTracker qui peut être utilisé pour suivre si des fonctions ont été appelées un nombre spécifique de fois. La méthode tracker.verify() doit être appelée pour que la vérification ait lieu. Le modèle habituel serait de l’appeler dans un gestionnaire process.on('exit').

ESM

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() doit être appelée exactement 1 fois avant tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Appelle tracker.verify() et vérifie si toutes les fonctions tracker.calls() ont été appelées le nombre exact de fois.
process.on('exit', () => {
  tracker.verify()
})

CJS

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() doit être appelée exactement 1 fois avant tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Appelle tracker.verify() et vérifie si toutes les fonctions tracker.calls() ont été appelées le nombre exact de fois.
process.on('exit', () => {
  tracker.verify()
})

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

Ajouté dans : v14.2.0, v12.19.0

• fn <Function> Par défaut : Une fonction sans opération.
• exact <number> Par défaut : 1.
• Retourne : <Function> Une fonction qui encapsule fn.

La fonction d’encapsulation doit être appelée exactement exact fois. Si la fonction n’a pas été appelée exactement exact fois lorsque tracker.verify() est appelée, alors tracker.verify() lèvera une erreur.

ESM

import assert from 'node:assert'

// Crée un tracker d’appels.
const tracker = new assert.CallTracker()

function func() {}

// Retourne une fonction qui encapsule func() qui doit être appelée un nombre exact de fois avant tracker.verify().
const callsfunc = tracker.calls(func)

CJS

const assert = require('node:assert')

// Crée un tracker d’appels.
const tracker = new assert.CallTracker()

function func() {}

// Retourne une fonction qui encapsule func() qui doit être appelée un nombre exact de fois avant tracker.verify().
const callsfunc = tracker.calls(func)

tracker.getCalls(fn)

Ajouté dans : v18.8.0, v16.18.0

• fn <Function>
• Retourne : <Array> Un tableau contenant tous les appels à une fonction suivie.
• Objet <Object>
  • thisArg <Object>
  • arguments <Array> les arguments passés à la fonction suivie

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

// Crée un outil de suivi des appels.
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()

Ajouté dans : v14.2.0, v12.19.0

• Retourne : <Array> Un tableau d'objets contenant des informations sur les fonctions wrapper retournées par tracker.calls().
• Objet <Object>
  • message <string>
  • actual <number> Le nombre réel de fois où la fonction a été appelée.
  • expected <number> Le nombre de fois où la fonction devait être appelée.
  • operator <string> Le nom de la fonction encapsulée.
  • stack <Object> Une trace de pile de la fonction.

Les tableaux contiennent des informations sur le nombre attendu et le nombre réel d'appels des fonctions qui n'ont pas été appelées le nombre de fois attendu.

ESM

import assert from 'node:assert'

// Crée un outil de suivi des appels.
const tracker = new assert.CallTracker()

function func() {}

// Retourne une fonction qui encapsule func() qui doit être appelée un nombre exact de fois
// avant tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Retourne un tableau contenant des informations sur callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]

CJS

const assert = require('node:assert')

// Crée un outil de suivi des appels.
const tracker = new assert.CallTracker()

function func() {}

// Retourne une fonction qui encapsule func() qui doit être appelée un nombre exact de fois
// avant tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Retourne un tableau contenant des informations sur callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'Expected the func function to be executed 2 time(s) but was
//    executed 0 time(s).',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: stack trace
//  }
// ]

tracker.reset([fn])

Ajouté dans : v18.8.0, v16.18.0

• fn <Function> une fonction suivie à réinitialiser.

Réinitialise les appels du suivi des appels. Si une fonction suivie est passée en argument, les appels seront réinitialisés pour celle-ci. Si aucun argument n'est passé, toutes les fonctions suivies seront réinitialisées.

ESM

import assert from 'node:assert'

const tracker = new assert.CallTracker()

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

callsfunc()
// Le tracker a été appelé une fois
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()
// Le tracker a été appelé une fois
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

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

tracker.verify()

Ajouté dans : v14.2.0, v12.19.0

Itère sur la liste des fonctions passées à tracker.calls() et lèvera une erreur pour les fonctions qui n'ont pas été appelées le nombre de fois attendu.

ESM

import assert from 'node:assert'

// Crée un tracker d'appels.
const tracker = new assert.CallTracker()

function func() {}

// Retourne une fonction qui encapsule func() qui doit être appelée un nombre exact de fois
// avant tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Lèvera une erreur car callsfunc() n'a été appelée qu'une seule fois.
tracker.verify()

CJS

const assert = require('node:assert')

// Crée un tracker d'appels.
const tracker = new assert.CallTracker()

function func() {}

// Retourne une fonction qui encapsule func() qui doit être appelée un nombre exact de fois
// avant tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Lèvera une erreur car callsfunc() n'a été appelée qu'une seule fois.
tracker.verify()

assert(value[, message])

Ajouté dans : v0.5.9

• value <any> La donnée en entrée qui est vérifiée pour être truthy.
• message <string> | <Error>

Un alias de assert.ok().

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

[Historique]

Version	Modifications
v22.2.0, v20.15.0	La cause de l'erreur et les propriétés d'erreur sont maintenant également comparées.
v18.0.0	La propriété lastIndex des expressions régulières est maintenant également comparée.
v16.0.0, v14.18.0	En mode d'assertion hérité, statut changé de Déprécié à Hérité.
v14.0.0	NaN est maintenant traité comme étant identique si les deux côtés sont NaN.
v12.0.0	Les balises de type sont maintenant correctement comparées et il y a quelques ajustements mineurs de comparaison pour rendre la vérification moins surprenante.
v9.0.0	Les noms et les messages d'erreur sont maintenant correctement comparés.
v8.0.0	Le contenu de Set et Map est également comparé.
v6.4.0, v4.7.1	Les tranches de tableaux typés sont maintenant correctement gérées.
v6.1.0, v4.5.0	Les objets avec des références circulaires peuvent maintenant être utilisés comme entrées.
v5.10.1, v4.4.3	Gérer correctement les tableaux typés non Uint8Array.
v0.1.21	Ajouté dans : v0.1.21

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

Mode d'assertion strict

Un alias de assert.deepStrictEqual().

Mode d'assertion hérité

[Stable : 3 - Hérité]

Stable : 3 Stabilité : 3 - Hérité : Utilisez assert.deepStrictEqual() à la place.

Teste l'égalité profonde entre les paramètres actual et expected. Envisagez d'utiliser assert.deepStrictEqual() à la place. assert.deepEqual() peut donner des résultats surprenants.

Égalité profonde signifie que les propriétés propres « énumérables » des objets enfants sont également évaluées récursivement selon les règles suivantes.

Détails de la comparaison

• Les valeurs primitives sont comparées avec l'opérateur ==, à l'exception de NaN. NaN est considéré comme identique si les deux côtés sont NaN.
• Les étiquettes de type des objets doivent être les mêmes.
• Seules les propriétés propres énumérables sont prises en compte.
• Les noms, les messages, les causes et les erreurs de Error sont toujours comparés, même s'ils ne sont pas des propriétés énumérables.
• Les objets enveloppes sont comparés à la fois comme des objets et comme des valeurs déballées.
• Les propriétés des objets sont comparées sans ordre.
• Les clés de Map et les éléments de Set sont comparés sans ordre.
• La récursion s'arrête lorsque les deux côtés diffèrent ou lorsqu'un des deux côtés rencontre une référence circulaire.
• L'implémentation ne teste pas le [[Prototype]] des objets.
• Les propriétés Symbol ne sont pas comparées.
• La comparaison de WeakMap et WeakSet ne repose pas sur leurs valeurs mais uniquement sur leurs instances.
• lastIndex, flags et source de RegExp sont toujours comparés, même s'ils ne sont pas des propriétés énumérables.

L'exemple suivant ne lève pas d'exception AssertionError car les primitives sont comparées à l'aide de l'opérateur ==.

ESM

import assert from 'node:assert'
// ATTENTION : Cela ne lève pas d'AssertionError !

assert.deepEqual('+00000000', false)

CJS

const assert = require('node:assert')
// ATTENTION : Cela ne lève pas d'AssertionError !

assert.deepEqual('+00000000', false)

L'égalité "profonde" signifie que les propriétés propres énumérables des objets enfants sont également évaluées :

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

// Les valeurs de b sont différentes :
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Les prototypes sont ignorés :
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

// Les valeurs de b sont différentes :
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// Les prototypes sont ignorés :
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

Si les valeurs ne sont pas égales, une exception AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est attribué. Si le paramètre message est une instance d'un Error, il sera alors levé à la place de l'exception AssertionError.

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

[Historique]

Version	Modifications
v22.2.0, v20.15.0	La cause de l'erreur et les propriétés d'erreur sont désormais également comparées.
v18.0.0	La propriété lastIndex des expressions régulières est désormais également comparée.
v9.0.0	Les propriétés de symbole énumérables sont désormais comparées.
v9.0.0	NaN est désormais comparé en utilisant la comparaison SameValueZero.
v8.5.0	Les noms et les messages d'erreur sont désormais correctement comparés.
v8.0.0	Le contenu de Set et Map est également comparé.
v6.1.0	Les objets avec des références circulaires peuvent désormais être utilisés comme entrées.
v6.4.0, v4.7.1	Les tranches de tableaux typés sont désormais correctement gérées.
v5.10.1, v4.4.3	Gère correctement les tableaux typés autres que Uint8Array.
v1.2.0	Ajouté dans : v1.2.0

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

Teste l'égalité stricte entre les paramètres actual et expected. L'égalité « stricte » signifie que les propriétés propres énumérables des objets enfants sont également évaluées récursivement selon les règles suivantes.

Détails de la comparaison

• Les valeurs primitives sont comparées à l'aide de Object.is().
• Les étiquettes de type des objets doivent être les mêmes.
• [[Prototype]] des objets sont comparés à l'aide de l'opérateur ===.
• Seules les propriétés propres énumérables sont prises en compte.
• Les noms, les messages, les causes et les erreurs de Error sont toujours comparés, même s'il ne s'agit pas de propriétés énumérables. errors est également comparé.
• Les propriétés propres énumérables Symbol sont également comparées.
• Les objets wrappers sont comparés à la fois comme objets et comme valeurs déballées.
• Les propriétés Object sont comparées non ordonnées.
• Les clés Map et les éléments Set sont comparés non ordonnés.
• La récursion s'arrête lorsque les deux côtés diffèrent ou lorsque les deux côtés rencontrent une référence circulaire.
• La comparaison WeakMap et WeakSet ne repose pas sur leurs valeurs. Voir ci-dessous pour plus de détails.
• RegExp lastIndex, flags et source sont toujours comparés, même s'il ne s'agit pas de propriétés énumérables.

ESM

import assert from 'node:assert/strict'

// Ceci échoue car 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Les objets suivants n'ont pas de propriétés propres
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// [[Prototype]] différent :
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Étiquettes de type différentes :
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK car Object.is(NaN, NaN) est vrai.

// Nombres déballés différents :
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK car l'objet et la chaîne sont identiques lorsqu'ils sont déballés.

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

// Zéros différents :
assert.deepStrictEqual(0, -0)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, car il s'agit du même symbole sur les deux objets.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

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

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, car il est impossible de comparer les entrées

// Échoue car weakMap3 a une propriété que weakMap1 ne contient pas :
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

CJS

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

// Ceci échoue car 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// Les objets suivants n'ont pas de propriétés propres
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// [[Prototype]] différent :
assert.deepStrictEqual(object, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Étiquettes de type différentes :
assert.deepStrictEqual(date, fakeDate)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK car Object.is(NaN, NaN) est vrai.

// Nombres déballés différents :
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK car l'objet et la chaîne sont identiques lorsqu'ils sont déballés.

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

// Zéros différents :
assert.deepStrictEqual(0, -0)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, car il s'agit du même symbole sur les deux objets.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Inputs identical but not reference equal:
//
// {
//   [Symbol()]: 1
// }

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

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, car il est impossible de comparer les entrées

// Échoue car weakMap3 a une propriété que weakMap1 ne contient pas :
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

Si les valeurs ne sont pas égales, une AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est affecté. Si le paramètre message est une instance d'une Error, il sera alors levé au lieu de AssertionError.

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

[Historique]

Version	Modifications
v16.0.0	Cette API n'est plus expérimentale.
v13.6.0, v12.16.0	Ajouté dans : v13.6.0, v12.16.0

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

Attend que l'entrée string ne corresponde pas à l'expression régulière.

ESM

import assert from 'node:assert/strict'

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

CJS

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

assert.doesNotMatch('I will fail', /fail/)
// AssertionError [ERR_ASSERTION]: The input was expected to not match the ...

assert.doesNotMatch(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

Si les valeurs correspondent, ou si l'argument string est d'un autre type que string, une erreur AssertionError est levée avec une propriété message égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est affecté. Si le paramètre message est une instance d'un Error, il sera levé à la place de l'erreur AssertionError.

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

Ajouté dans : v10.0.0

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

Attend la promesse asyncFn ou, si asyncFn est une fonction, appelle immédiatement la fonction et attend que la promesse retournée soit terminée. Il vérifiera ensuite que la promesse n'est pas rejetée.

Si asyncFn est une fonction et qu'elle lève une erreur de manière synchrone, assert.doesNotReject() retournera une promesse rejetée avec cette erreur. Si la fonction ne retourne pas de promesse, assert.doesNotReject() retournera une promesse rejetée avec une erreur ERR_INVALID_RETURN_VALUE. Dans les deux cas, le gestionnaire d'erreur est ignoré.

L'utilisation de assert.doesNotReject() n'est en fait pas utile car il y a peu d'intérêt à intercepter un rejet puis à le rejeter à nouveau. Envisagez plutôt d'ajouter un commentaire à côté du chemin de code spécifique qui ne doit pas rejeter et de maintenir des messages d'erreur aussi expressifs que possible.

Si spécifié, error peut être une Class, une RegExp, ou une fonction de validation. Voir assert.throws() pour plus de détails.

Outre la nature asynchrone pour attendre l'achèvement, le comportement est identique à celui de 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])

[Historique]

Version	Modifications
v5.11.0, v4.4.5	Le paramètre message est maintenant respecté.
v4.2.0	Le paramètre error peut maintenant être une fonction fléchée.
v0.1.21	Ajouté dans : v0.1.21

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

Afirme que la fonction fn ne lève pas d'erreur.

L'utilisation de assert.doesNotThrow() n'est en réalité pas utile car il n'y a aucun avantage à intercepter une erreur puis à la relancer. Envisagez plutôt d'ajouter un commentaire à côté du chemin de code spécifique qui ne doit pas lever d'exception et de maintenir des messages d'erreur aussi explicites que possible.

Lorsque assert.doesNotThrow() est appelé, il appelle immédiatement la fonction fn.

Si une erreur est levée et qu'elle est du même type que celle spécifiée par le paramètre error, une AssertionError est levée. Si l'erreur est d'un type différent, ou si le paramètre error est indéfini, l'erreur est propagée à l'appelant.

Si spécifié, error peut être une Class, une RegExp, ou une fonction de validation. Voir assert.throws() pour plus de détails.

L'exemple suivant, par exemple, lèvera la TypeError car il n'y a pas de type d'erreur correspondant dans l'affirmation :

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Valeur incorrecte')
}, SyntaxError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Valeur incorrecte')
}, SyntaxError)

Cependant, ce qui suit entraînera une AssertionError avec le message 'Exception non désirée obtenue ...' :

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Valeur incorrecte')
}, TypeError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Valeur incorrecte')
}, TypeError)

Si une AssertionError est levée et qu'une valeur est fournie pour le paramètre message, la valeur de message sera ajoutée au message AssertionError :

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(
  () => {
    throw new TypeError('Valeur incorrecte')
  },
  /Valeur incorrecte/,
  'Oups'
)
// Lève : AssertionError: Exception non désirée obtenue : Oups

CJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Valeur incorrecte')
  },
  /Valeur incorrecte/,
  'Oups'
)
// Lève : AssertionError: Exception non désirée obtenue : Oups

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

[Historique]

Version	Modifications
v16.0.0, v14.18.0	En mode d'assertion hérité, statut changé de Déprécié à Hérité.
v14.0.0	NaN est maintenant traité comme étant identique si les deux côtés sont NaN.
v0.1.21	Ajouté dans : v0.1.21

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

Mode d'assertion strict

Un alias de assert.strictEqual().

Mode d'assertion hérité

[Stable : 3 - Hérité]

Stable : 3 Stabilité : 3 - Hérité : Utilisez assert.strictEqual() à la place.

Teste l'égalité superficielle et coercitive entre les paramètres actual et expected en utilisant l'opérateur ==. NaN est spécialement géré et traité comme étant identique si les deux côtés sont 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 les valeurs ne sont pas égales, une AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est affecté. Si le paramètre message est une instance d'une Error, il sera levé à la place de l'erreur AssertionError.

assert.fail([message])

Ajouté dans : v0.1.21

• message <string> | <Error> Défaut : 'Failed'

Lève une AssertionError avec le message d'erreur fourni ou un message d'erreur par défaut. Si le paramètre message est une instance d'un Error, il sera levé à la place de la 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

L'utilisation de assert.fail() avec plus de deux arguments est possible mais déconseillée. Voir ci-dessous pour plus de détails.

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

[Historique]

Version	Modifications
v10.0.0	L'appel de assert.fail() avec plus d'un argument est déconseillé et émet un avertissement.
v0.1.21	Ajouté dans : v0.1.21

[Stable : 0 - Déprécié]

Stable : 0 Stabilité : 0 - Déprécié : Utilisez assert.fail([message]) ou d'autres fonctions assert à la place.

• actual <any>
• expected <any>
• message <string> | <Error>
• operator <string> Défaut : '!='
• stackStartFn <Function> Défaut : assert.fail

Si message est faux, le message d'erreur est défini comme les valeurs de actual et expected séparées par l'operator fourni. Si seuls les deux arguments actual et expected sont fournis, operator sera par défaut '!='. Si message est fourni comme troisième argument, il sera utilisé comme message d'erreur et les autres arguments seront stockés comme propriétés de l'objet levé. Si stackStartFn est fourni, toutes les frames de pile au-dessus de cette fonction seront supprimées de la trace de pile (voir Error.captureStackTrace). Si aucun argument n'est donné, le message par défaut Failed sera utilisé.

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

Dans les trois derniers cas, actual, expected et operator n'ont aucune influence sur le message d'erreur.

Exemple d'utilisation de stackStartFn pour tronquer la trace de pile de l'exception :

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)

[Historique]

Version	Modifications
v10.0.0	Au lieu de lever l'erreur originale, elle est maintenant encapsulée dans une [AssertionError][] qui contient la trace de pile complète.
v10.0.0	La valeur peut maintenant être uniquement undefined ou null. Auparavant, toutes les valeurs fausses étaient traitées de la même manière que null et ne levaient pas d'exception.
v0.1.97	Ajouté dans : v0.1.97

• value <any>

Lève une exception avec value si value n'est pas undefined ou null. Ceci est utile lors du test de l'argument error dans les callbacks. La trace de pile contient toutes les frames de l'erreur passée à ifError(), y compris les éventuelles nouvelles frames pour ifError() elle-même.

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

// Créer quelques frames d'erreur aléatoires.
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

// Créer quelques frames d'erreur aléatoires.
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])

[Historique]

Version	Modifications
v16.0.0	Cette API n'est plus expérimentale.
v13.6.0, v12.16.0	Ajouté dans : v13.6.0, v12.16.0

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

Attend que la chaîne d'entrée string corresponde à l'expression régulière.

ESM

import assert from 'node:assert/strict'

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

CJS

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

assert.match('I will fail', /pass/)
// AssertionError [ERR_ASSERTION]: The input did not match the regular ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.

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

Si les valeurs ne correspondent pas, ou si l'argument string est d'un type autre que string, une erreur AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est attribué. Si le paramètre message est une instance d'une erreur Error, alors elle sera levée à la place de l'erreur AssertionError.

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

[Historique]

Version	Modifications
v16.0.0, v14.18.0	En mode d'assertion hérité, statut changé de Déprécié à Hérité.
v14.0.0	NaN est maintenant traité comme étant identique si les deux côtés sont NaN.
v9.0.0	Les noms et messages d'erreur sont maintenant correctement comparés.
v8.0.0	Le contenu de Set et Map est également comparé.
v6.4.0, v4.7.1	Les tranches de tableaux typés sont maintenant correctement gérées.
v6.1.0, v4.5.0	Les objets avec des références circulaires peuvent maintenant être utilisés comme entrées.
v5.10.1, v4.4.3	Gérer correctement les tableaux typés non Uint8Array.
v0.1.21	Ajouté dans : v0.1.21

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

Mode d'assertion strict

Un alias de assert.notDeepStrictEqual().

Mode d'assertion hérité

[Stable : 3 - Hérité]

Stable : 3 Stabilité : 3 - Hérité : Utilisez assert.notDeepStrictEqual() à la place.

Teste toute inégalité profonde. Opposé de 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 les valeurs sont profondément égales, une erreur AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est attribué. Si le paramètre message est une instance d'une erreur Error, alors elle sera levée à la place de l'erreur AssertionError.

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

[Historique]

Version	Modifications
v9.0.0	-0 et +0 ne sont plus considérés comme égaux.
v9.0.0	NaN est maintenant comparé en utilisant la comparaison SameValueZero.
v9.0.0	Les noms et les messages des Error sont maintenant correctement comparés.
v8.0.0	Le contenu des Set et Map est également comparé.
v6.1.0	Les objets avec des références circulaires peuvent maintenant être utilisés comme entrées.
v6.4.0, v4.7.1	Les tranches de tableaux typés sont maintenant correctement gérées.
v5.10.1, v4.4.3	Gère correctement les tableaux typés autres que Uint8Array.
v1.2.0	Ajouté dans : v1.2.0

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

Teste l'inégalité stricte profonde. Opposé de 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 les valeurs sont profondément et strictement égales, une AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est attribué. Si le paramètre message est une instance d'un Error, il sera alors levé à la place de la AssertionError.

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

[Historique]

Version	Modifications
v16.0.0, v14.18.0	En mode d'assertion hérité, statut changé de Déprécié à Hérité.
v14.0.0	NaN est maintenant traité comme étant identique si les deux côtés sont NaN.
v0.1.21	Ajouté dans : v0.1.21

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

Mode d'assertion strict

Un alias de assert.notStrictEqual().

Mode d'assertion hérité

[Stable : 3 - Hérité]

Stable : 3 Stabilité : 3 - Hérité : Utilisez assert.notStrictEqual() à la place.

Teste l'inégalité superficielle et coercitive avec l'opérateur !=. NaN est spécialement géré et traité comme étant identique si les deux côtés sont 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 les valeurs sont égales, une AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est attribué. Si le paramètre message est une instance d'un Error, il sera alors levé à la place de la AssertionError.

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

[Historique]

Version	Modifications
v10.0.0	La comparaison utilisée est passée de l'égalité stricte à Object.is().
v0.1.21	Ajouté dans la version : v0.1.21

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

Teste l'inégalité stricte entre les paramètres actual et expected tels que déterminés par Object.is().

ESM

import assert from 'node:assert/strict'

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

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

CJS

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

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
//
// 1

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

Si les valeurs sont strictement égales, une erreur AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est affecté. Si le paramètre message est une instance d'une Error, il sera alors levé à la place de l'erreur AssertionError.

assert.ok(value[, message])

[Historique]

Version	Modifications
v10.0.0	assert.ok() (sans arguments) utilisera désormais un message d'erreur prédéfini.
v0.1.21	Ajouté dans la version : v0.1.21

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

Teste si value est truthy. Cela équivaut à assert.equal(!!value, true, message).

Si value n'est pas truthy, une erreur AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est undefined, un message d'erreur par défaut est affecté. Si le paramètre message est une instance d'une Error, il sera alors levé à la place de l'erreur AssertionError. Si aucun argument n'est passé du tout, message sera défini sur la chaîne : 'No value argument passed to assert.ok()'.

Notez que dans le repl, le message d'erreur sera différent de celui levé dans un fichier ! Voir ci-dessous pour plus de détails.

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

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

// Dans un fichier (par exemple, test.js) :
assert.ok(typeof 123 === 'string')
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)

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

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

// Dans un fichier (par exemple, test.js) :
assert.ok(typeof 123 === 'string')
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert.ok(0)

ESM

import assert from 'node:assert/strict'

// L'utilisation de `assert()` fonctionne de la même manière :
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

CJS

const assert = require('node:assert')

// L'utilisation de `assert()` fonctionne de la même manière :
assert(0)
// AssertionError: The expression evaluated to a falsy value:
//
//   assert(0)

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

Ajouté dans : v10.0.0

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

Attend la promesse asyncFn ou, si asyncFn est une fonction, appelle immédiatement la fonction et attend que la promesse retournée soit terminée. Il vérifiera ensuite que la promesse est rejetée.

Si asyncFn est une fonction et qu'elle lève une erreur de manière synchrone, assert.rejects() retournera une promesse rejetée avec cette erreur. Si la fonction ne retourne pas de promesse, assert.rejects() retournera une promesse rejetée avec une erreur ERR_INVALID_RETURN_VALUE. Dans les deux cas, le gestionnaire d'erreur est ignoré.

Outre la nature asynchrone pour attendre l'achèvement, le comportement est identique à celui de assert.throws().

Si spécifié, error peut être une Class, une RegExp, une fonction de validation, un objet où chaque propriété sera testée, ou une instance d'erreur où chaque propriété sera testée, y compris les propriétés non énumérables message et name.

Si spécifié, message sera le message fourni par AssertionError si asyncFn échoue à se rejeter.

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 ne peut pas être une chaîne de caractères. Si une chaîne de caractères est fournie comme deuxième argument, alors error est considéré comme omis et la chaîne de caractères sera utilisée pour message à la place. Cela peut conduire à des erreurs faciles à passer inaperçues. Veuillez lire attentivement l'exemple dans assert.throws() si l'utilisation d'une chaîne de caractères comme deuxième argument est envisagée.

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

[Historique]

Version	Modifications
v10.0.0	Comparaison modifiée : Égalité stricte remplacée par Object.is().
v0.1.21	Ajouté dans : v0.1.21

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

Teste l'égalité stricte entre les paramètres actual et expected comme déterminé par Object.is().

ESM

import assert from 'node:assert/strict'

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

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

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'))
// TypeError: Inputs are not identical

CJS

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

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
// + actual - expected
//
// + 'Hello foobar'
// - 'Hello World!'
//          ^

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

assert.strictEqual(1, '1', new TypeError('Inputs are not identical'))
// TypeError: Inputs are not identical

Si les valeurs ne sont pas strictement égales, une erreur AssertionError est levée avec une propriété message définie égale à la valeur du paramètre message. Si le paramètre message est indéfini, un message d'erreur par défaut est attribué. Si le paramètre message est une instance d'une erreur Error, alors elle sera levée à la place de l'erreur AssertionError.

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

[Historique]

Version	Modifications
v10.2.0	Le paramètre error peut désormais être un objet contenant des expressions régulières.
v9.9.0	Le paramètre error peut désormais être un objet.
v4.2.0	Le paramètre error peut désormais être une fonction fléchée.
v0.1.21	Ajouté dans la version : v0.1.21

• fn <Fonction>
• error <RegExp> | <Fonction> | <Objet> | <Erreur>
• message <chaîne de caractères>

Attend que la fonction fn lève une erreur.

Si spécifié, error peut être une Classe, une RegExp, une fonction de validation, un objet de validation où chaque propriété sera testée pour une égalité profonde stricte, ou une instance d'erreur où chaque propriété sera testée pour une égalité profonde stricte, y compris les propriétés non énumérables message et name. Lors de l'utilisation d'un objet, il est également possible d'utiliser une expression régulière lors de la validation par rapport à une propriété de chaîne de caractères. Voir ci-dessous pour des exemples.

Si spécifié, message sera ajouté au message fourni par AssertionError si l'appel fn ne lève pas d'erreur ou si la validation d'erreur échoue.

Objet/instance d'erreur de validation personnalisée :

ESM

import assert from 'node:assert/strict'

const err = new TypeError('Valeur incorrecte')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Valeur incorrecte',
    info: {
      nested: true,
      baz: 'text',
    },
    // Seules les propriétés de l'objet de validation seront testées.
    // L'utilisation d'objets imbriqués nécessite la présence de toutes les propriétés. Sinon,
    // la validation va échouer.
  }
)

// Utilisation d'expressions régulières pour valider les propriétés d'erreur :
assert.throws(
  () => {
    throw err
  },
  {
    // Les propriétés `name` et `message` sont des chaînes de caractères et l'utilisation d'expressions régulières sur celles-ci correspondra à la chaîne de caractères. En cas d'échec, une
    // erreur est levée.
    name: /^TypeError$/,
    message: /Valeur/,
    foo: 'bar',
    info: {
      nested: true,
      // Il n'est pas possible d'utiliser des expressions régulières pour les propriétés imbriquées !
      baz: 'text',
    },
    // La propriété `reg` contient une expression régulière et seulement si
    // l'objet de validation contient une expression régulière identique, elle va
    // passer.
    reg: /abc/i,
  }
)

// Échec en raison des propriétés `message` et `name` différentes :
assert.throws(
  () => {
    const otherErr = new Error('Non trouvé')
    // Copie de toutes les propriétés énumérables de `err` vers `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Les propriétés `message` et `name` de l'erreur seront également vérifiées lors de l'utilisation
  // d'une erreur comme objet de validation.
  err
)

CJS

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

const err = new TypeError('Valeur incorrecte')
err.code = 404
err.foo = 'bar'
err.info = {
  nested: true,
  baz: 'text',
}
err.reg = /abc/i

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Valeur incorrecte',
    info: {
      nested: true,
      baz: 'text',
    },
    // Seules les propriétés de l'objet de validation seront testées.
    // L'utilisation d'objets imbriqués nécessite la présence de toutes les propriétés. Sinon,
    // la validation va échouer.
  }
)

// Utilisation d'expressions régulières pour valider les propriétés d'erreur :
assert.throws(
  () => {
    throw err
  },
  {
    // Les propriétés `name` et `message` sont des chaînes de caractères et l'utilisation d'expressions régulières sur celles-ci correspondra à la chaîne de caractères. En cas d'échec, une
    // erreur est levée.
    name: /^TypeError$/,
    message: /Valeur/,
    foo: 'bar',
    info: {
      nested: true,
      // Il n'est pas possible d'utiliser des expressions régulières pour les propriétés imbriquées !
      baz: 'text',
    },
    // La propriété `reg` contient une expression régulière et seulement si
    // l'objet de validation contient une expression régulière identique, elle va
    // passer.
    reg: /abc/i,
  }
)

// Échec en raison des propriétés `message` et `name` différentes :
assert.throws(
  () => {
    const otherErr = new Error('Non trouvé')
    // Copie de toutes les propriétés énumérables de `err` vers `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Les propriétés `message` et `name` de l'erreur seront également vérifiées lors de l'utilisation
  // d'une erreur comme objet de validation.
  err
)

Validation instanceof utilisant le constructeur :

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Valeur incorrecte')
}, Error)

CJS

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

assert.throws(() => {
  throw new Error('Valeur incorrecte')
}, Error)

Validation du message d'erreur à l'aide de RegExp :

L'utilisation d'une expression régulière exécute .toString sur l'objet d'erreur et inclura donc également le nom de l'erreur.

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

Validation d'erreur personnalisée :

La fonction doit retourner true pour indiquer que toutes les validations internes ont réussi. Elle échouera autrement avec une AssertionError.

ESM

import assert from 'node:assert/strict'

assert.throws(
  () => {
    throw new Error('Valeur incorrecte')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Évitez de retourner quoi que ce soit des fonctions de validation en dehors de `true`.
    // Sinon, il n'est pas clair quelle partie de la validation a échoué. Au lieu de cela,
    // levez une erreur concernant la validation spécifique qui a échoué (comme dans cet
    // exemple) et ajoutez autant d'informations de débogage utiles que possible à cette erreur.
    return true
  },
  'erreur inattendue'
)

CJS

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

assert.throws(
  () => {
    throw new Error('Valeur incorrecte')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Évitez de retourner quoi que ce soit des fonctions de validation en dehors de `true`.
    // Sinon, il n'est pas clair quelle partie de la validation a échoué. Au lieu de cela,
    // levez une erreur concernant la validation spécifique qui a échoué (comme dans cet
    // exemple) et ajoutez autant d'informations de débogage utiles que possible à cette erreur.
    return true
  },
  'erreur inattendue'
)

error ne peut pas être une chaîne de caractères. Si une chaîne de caractères est fournie comme deuxième argument, alors error est considéré comme omis et la chaîne de caractères sera utilisée pour message à la place. Cela peut conduire à des erreurs faciles à manquer. L'utilisation du même message que le message d'erreur levé entraînera une erreur ERR_AMBIGUOUS_ARGUMENT. Veuillez lire attentivement l'exemple ci-dessous si l'utilisation d'une chaîne de caractères comme deuxième argument est envisagée :

ESM

import assert from 'node:assert/strict'

function throwingFirst() {
  throw new Error('Premier')
}

function throwingSecond() {
  throw new Error('Second')
}

function notThrowing() {}

// Le deuxième argument est une chaîne de caractères et la fonction d'entrée a levé une erreur.
// Le premier cas ne lèvera pas d'erreur car il ne correspond pas au message d'erreur
// levé par la fonction d'entrée !
assert.throws(throwingFirst, 'Second')
// Dans l'exemple suivant, le message n'a aucun avantage par rapport au message de l'
// erreur et comme il n'est pas clair si l'utilisateur avait l'intention de correspondre réellement
// au message d'erreur, Node.js lève une erreur `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// La chaîne de caractères est uniquement utilisée (comme message) si la fonction ne lève pas d'erreur :
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Exception attendue manquante : Second

// S'il était prévu de correspondre au message d'erreur, faites ceci à la place :
// Il ne lève pas d'erreur car les messages d'erreur correspondent.
assert.throws(throwingSecond, /Second$/)

// Si le message d'erreur ne correspond pas, une AssertionError est levée.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]

CJS

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

function throwingFirst() {
  throw new Error('Premier')
}

function throwingSecond() {
  throw new Error('Second')
}

function notThrowing() {}

// Le deuxième argument est une chaîne de caractères et la fonction d'entrée a levé une erreur.
// Le premier cas ne lèvera pas d'erreur car il ne correspond pas au message d'erreur
// levé par la fonction d'entrée !
assert.throws(throwingFirst, 'Second')
// Dans l'exemple suivant, le message n'a aucun avantage par rapport au message de l'
// erreur et comme il n'est pas clair si l'utilisateur avait l'intention de correspondre réellement
// au message d'erreur, Node.js lève une erreur `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// La chaîne de caractères est uniquement utilisée (comme message) si la fonction ne lève pas d'erreur :
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Exception attendue manquante : Second

// S'il était prévu de correspondre au message d'erreur, faites ceci à la place :
// Il ne lève pas d'erreur car les messages d'erreur correspondent.
assert.throws(throwingSecond, /Second$/)

// Si le message d'erreur ne correspond pas, une AssertionError est levée.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]

En raison de la notation confuse et sujette aux erreurs, évitez une chaîne de caractères comme deuxième argument.

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

Ajouté dans : v23.4.0

[Stable : 1 - Expérimental]

Stable : 1 Stabilité : 1.0 - Développement précoce

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

assert.partialDeepStrictEqual() Affirme l’équivalence entre les paramètres actual et expected par le biais d’une comparaison approfondie, en garantissant que toutes les propriétés du paramètre expected sont présentes dans le paramètre actual avec des valeurs équivalentes, sans permettre de coercition de type. La principale différence avec assert.deepStrictEqual() est que assert.partialDeepStrictEqual() n’exige pas que toutes les propriétés du paramètre actual soient présentes dans le paramètre expected. Cette méthode doit toujours réussir les mêmes cas de test que assert.deepStrictEqual(), se comportant comme un sur-ensemble de celle-ci.

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