Asserzione

[Stabile: 2 - Stabile]

Stabile: 2 Stabilità: 2 - Stabile

Codice sorgente: lib/assert.js

Il modulo node:assert fornisce un insieme di funzioni di asserzione per verificare le invarianti.

Modalità di asserzione rigorosa

[Cronologia]

Versione	Modifiche
v15.0.0	Esposto come require('node:assert/strict').
v13.9.0, v12.16.2	Modificato "modalità rigorosa" in "modalità di asserzione rigorosa" e "modalità legacy" in "modalità di asserzione legacy" per evitare confusione con il significato più comune di "modalità rigorosa".
v9.9.0	Aggiunti diff di errore alla modalità di asserzione rigorosa.
v9.9.0	Aggiunta la modalità di asserzione rigorosa al modulo assert.
v9.9.0	Aggiunto in: v9.9.0

Nella modalità di asserzione rigorosa, i metodi non rigorosi si comportano come i loro metodi rigorosi corrispondenti. Ad esempio, assert.deepEqual() si comporterà come assert.deepStrictEqual().

Nella modalità di asserzione rigorosa, i messaggi di errore per gli oggetti mostrano una differenza. Nella modalità di asserzione legacy, i messaggi di errore per gli oggetti mostrano gli oggetti, spesso troncati.

Per utilizzare la modalità di asserzione rigorosa:

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

Esempio di differenza di errore:

ESM

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: È previsto che gli input siano rigorosamente deep-equal:
// + effettivo - previsto ... Righe saltate
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

CJS

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

assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5])
// AssertionError: È previsto che gli input siano rigorosamente deep-equal:
// + effettivo - previsto ... Righe saltate
//
//   [
//     [
// ...
//       2,
// +     3
// -     '3'
//     ],
// ...
//     5
//   ]

Per disattivare i colori, utilizzare le variabili d'ambiente NO_COLOR o NODE_DISABLE_COLORS. Ciò disattiverà anche i colori nella REPL. Per ulteriori informazioni sul supporto dei colori negli ambienti terminale, leggere la documentazione di tty getColorDepth().

Modalità di asserzione legacy

La modalità di asserzione legacy utilizza l'operatore == in:

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

Per utilizzare la modalità di asserzione legacy:

ESM

import assert from 'node:assert'

CJS

const assert = require('node:assert')

La modalità di asserzione legacy potrebbe avere risultati sorprendenti, soprattutto quando si utilizza assert.deepEqual():

// ATTENZIONE: Questo non genera un'AssertionError nella modalità di asserzione legacy!
assert.deepEqual(/a/gi, new Date())

Classe: assert.AssertionError

• Estende: <errors.Error>

Indica il fallimento di un'asserzione. Tutti gli errori generati dal modulo node:assert saranno istanze della classe AssertionError.

new assert.AssertionError(options)

Aggiunto in: v0.1.21

• options <Object>
  • message <string> Se fornito, il messaggio di errore viene impostato su questo valore.
  • actual <any> La proprietà actual sull'istanza dell'errore.
  • expected <any> La proprietà expected sull'istanza dell'errore.
  • operator <string> La proprietà operator sull'istanza dell'errore.
  • stackStartFn <Function> Se fornita, la traccia dello stack generata omette i frame precedenti a questa funzione.

Una sottoclasse di Error che indica il fallimento di un'asserzione.

Tutte le istanze contengono le proprietà Error integrate (message e name) e:

• actual <any> Impostato sull'argomento actual per metodi come assert.strictEqual().
• expected <any> Impostato sul valore expected per metodi come assert.strictEqual().
• generatedMessage <boolean> Indica se il messaggio è stato generato automaticamente (true) o meno.
• code <string> Il valore è sempre ERR_ASSERTION per mostrare che l'errore è un errore di asserzione.
• operator <string> Impostato sul valore dell'operatore passato.

ESM

import assert from 'node:assert'

// Genera un'AssertionError per confrontare il messaggio di errore in seguito:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Verifica l'output dell'errore:
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')

// Genera un'AssertionError per confrontare il messaggio di errore in seguito:
const { message } = new assert.AssertionError({
  actual: 1,
  expected: 2,
  operator: 'strictEqual',
})

// Verifica l'output dell'errore:
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

[Cronologia]

Versione	Modifiche
v20.1.0	la classe assert.CallTracker è stata deprecata e verrà rimossa in una versione futura.
v14.2.0, v12.19.0	Aggiunto in: v14.2.0, v12.19.0

[Stabile: 0 - Deprecato]

Stabile: 0 Stabilità: 0 - Deprecato

Questa funzionalità è deprecata e verrà rimossa in una versione futura. Si prega di considerare l'uso di alternative come la funzione helper mock.

new assert.CallTracker()

Aggiunto in: v14.2.0, v12.19.0

Crea un nuovo oggetto CallTracker che può essere utilizzato per tenere traccia se le funzioni sono state chiamate un numero specifico di volte. Il metodo tracker.verify() deve essere chiamato affinché la verifica abbia luogo. Il modello consueto sarebbe quello di chiamarlo in un gestore process.on('exit').

ESM

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() deve essere chiamata esattamente 1 volta prima di tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Chiama tracker.verify() e verifica se tutte le funzioni tracker.calls() sono state
// chiamate esattamente il numero di volte previsto.
process.on('exit', () => {
  tracker.verify()
})

CJS

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

const tracker = new assert.CallTracker()

function func() {}

// callsfunc() deve essere chiamata esattamente 1 volta prima di tracker.verify().
const callsfunc = tracker.calls(func, 1)

callsfunc()

// Chiama tracker.verify() e verifica se tutte le funzioni tracker.calls() sono state
// chiamate esattamente il numero di volte previsto.
process.on('exit', () => {
  tracker.verify()
})

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

Aggiunto in: v14.2.0, v12.19.0

• fn <Function> Predefinito: Una funzione no-op.
• exact <number> Predefinito: 1.
• Restituisce: <Function> Una funzione che wrappa fn.

La funzione wrapper deve essere chiamata esattamente exact volte. Se la funzione non è stata chiamata esattamente exact volte quando viene chiamato tracker.verify(), allora tracker.verify() lancerà un errore.

ESM

import assert from 'node:assert'

// Crea un call tracker.
const tracker = new assert.CallTracker()

function func() {}

// Restituisce una funzione che wrappa func() che deve essere chiamata un numero
// esatto di volte prima di tracker.verify().
const callsfunc = tracker.calls(func)

CJS

const assert = require('node:assert')

// Crea un call tracker.
const tracker = new assert.CallTracker()

function func() {}

// Restituisce una funzione che wrappa func() che deve essere chiamata un numero
// esatto di volte prima di tracker.verify().
const callsfunc = tracker.calls(func)

tracker.getCalls(fn)

Aggiunto in: v18.8.0, v16.18.0

• fn <Function>
• Restituisce: <Array> Un array con tutte le chiamate a una funzione tracciata.
• Oggetto <Object>
  • thisArg <Object>
  • arguments <Array> gli argomenti passati alla funzione tracciata

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 il tracciatore di chiamate.
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()

Aggiunto in: v14.2.0, v12.19.0

• Restituisce: <Array> Un array di oggetti contenenti informazioni sulle funzioni wrapper restituite da tracker.calls().
• Oggetto <Object>
  • message <string>
  • actual <number> Il numero effettivo di volte in cui è stata chiamata la funzione.
  • expected <number> Il numero di volte in cui si prevedeva che la funzione venisse chiamata.
  • operator <string> Il nome della funzione sottoposta a wrapping.
  • stack <Object> Una traccia dello stack della funzione.

Gli array contengono informazioni sul numero previsto ed effettivo di chiamate delle funzioni che non sono state chiamate il numero di volte previsto.

ESM

import assert from 'node:assert'

// Crea il tracciatore di chiamate.
const tracker = new assert.CallTracker()

function func() {}

// Restituisce una funzione che wrappa func() che deve essere chiamata un numero esatto di volte
// prima di tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Restituisce un array contenente informazioni su callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'È previsto che la funzione func venga eseguita 2 volte, ma è
//    stata eseguita 0 volte.',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: traccia dello stack
//  }
// ]

CJS

const assert = require('node:assert')

// Crea il tracciatore di chiamate.
const tracker = new assert.CallTracker()

function func() {}

// Restituisce una funzione che wrappa func() che deve essere chiamata un numero esatto di volte
// prima di tracker.verify().
const callsfunc = tracker.calls(func, 2)

// Restituisce un array contenente informazioni su callsfunc()
console.log(tracker.report())
// [
//  {
//    message: 'È previsto che la funzione func venga eseguita 2 volte, ma è
//    stata eseguita 0 volte.',
//    actual: 0,
//    expected: 2,
//    operator: 'func',
//    stack: traccia dello stack
//  }
// ]

tracker.reset([fn])

Aggiunto in: v18.8.0, v16.18.0

• fn <Function> una funzione tracciata da reimpostare.

Reimposta le chiamate del tracker di chiamate. Se una funzione tracciata viene passata come argomento, le chiamate verranno reimpostate per essa. Se non vengono passati argomenti, tutte le funzioni tracciate verranno reimpostate.

ESM

import assert from 'node:assert'

const tracker = new assert.CallTracker()

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

callsfunc()
// Il tracker è stato chiamato una volta
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()
// Il tracker è stato chiamato una volta
assert.strictEqual(tracker.getCalls(callsfunc).length, 1)

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

tracker.verify()

Aggiunto in: v14.2.0, v12.19.0

Itera attraverso l'elenco delle funzioni passate a tracker.calls() e genererà un errore per le funzioni che non sono state chiamate il numero previsto di volte.

ESM

import assert from 'node:assert'

// Crea il tracker di chiamate.
const tracker = new assert.CallTracker()

function func() {}

// Restituisce una funzione che avvolge func() che deve essere chiamata
// il numero esatto di volte prima di tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Genererà un errore poiché callsfunc() è stata chiamata una sola volta.
tracker.verify()

CJS

const assert = require('node:assert')

// Crea il tracker di chiamate.
const tracker = new assert.CallTracker()

function func() {}

// Restituisce una funzione che avvolge func() che deve essere chiamata
// il numero esatto di volte prima di tracker.verify().
const callsfunc = tracker.calls(func, 2)

callsfunc()

// Genererà un errore poiché callsfunc() è stata chiamata una sola volta.
tracker.verify()

assert(value[, message])

Aggiunto in: v0.5.9

• value <any> L'input che viene verificato per essere truthy.
• message <string> | <Error>

Un alias di assert.ok().

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

[Cronologia]

Versione	Modifiche
v22.2.0, v20.15.0	Ora vengono confrontate anche la causa dell'errore e le proprietà degli errori.
v18.0.0	Ora viene confrontata anche la proprietà lastIndex delle espressioni regolari.
v16.0.0, v14.18.0	Nella modalità di asserzione Legacy, lo stato è cambiato da Obsoleto a Legacy.
v14.0.0	Ora NaN viene trattato come identico se entrambi i lati sono NaN.
v12.0.0	Ora i tag di tipo vengono confrontati correttamente e ci sono alcune piccole modifiche al confronto per rendere il controllo meno sorprendente.
v9.0.0	Ora i nomi e i messaggi di Error vengono confrontati correttamente.
v8.0.0	Viene confrontato anche il contenuto di Set e Map.
v6.4.0, v4.7.1	Le porzioni di array tipizzati vengono gestite correttamente ora.
v6.1.0, v4.5.0	Ora è possibile utilizzare come input oggetti con riferimenti circolari.
v5.10.1, v4.4.3	Gestisci correttamente array tipizzati non Uint8Array.
v0.1.21	Aggiunto in: v0.1.21

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

Modalità di asserzione Strict

Un alias di assert.deepStrictEqual().

Modalità di asserzione Legacy

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Utilizzare invece assert.deepStrictEqual().

Verifica l'uguaglianza profonda tra i parametri actual e expected. Si consiglia di utilizzare assert.deepStrictEqual() al suo posto. assert.deepEqual() può dare risultati sorprendenti.

Uguaglianza profonda significa che le proprietà "own" enumerabili degli oggetti figlio vengono valutate anche ricorsivamente seguendo le seguenti regole.

Dettagli del confronto

• I valori primitivi vengono confrontati con l'operatore ==, con l'eccezione di NaN. Viene trattato come identico nel caso in cui entrambi i lati siano NaN.
• I tag di tipo degli oggetti devono essere gli stessi.
• Vengono considerate solo le proprietà "own" enumerabili.
• I nomi, i messaggi, le cause e gli errori di Error vengono sempre confrontati, anche se non sono proprietà enumerabili.
• I wrapper degli oggetti vengono confrontati sia come oggetti che come valori non incapsulati.
• Le proprietà di Object vengono confrontate senza ordine.
• Le chiavi di Map e gli elementi di Set vengono confrontati senza ordine.
• La ricorsione si interrompe quando entrambi i lati differiscono o quando entrambi i lati incontrano un riferimento circolare.
• L'implementazione non testa il [[Prototype]] degli oggetti.
• Le proprietà Symbol non vengono confrontate.
• Il confronto di WeakMap e WeakSet non si basa sui loro valori, ma solo sulle loro istanze.
• lastIndex, flag e source di RegExp vengono sempre confrontati, anche se non sono proprietà enumerabili.

Il seguente esempio non genera un AssertionError perché i valori primitivi vengono confrontati utilizzando l'operatore ==.

ESM

import assert from 'node:assert'
// ATTENZIONE: Questo non genera un AssertionError!

assert.deepEqual('+00000000', false)

CJS

const assert = require('node:assert')
// ATTENZIONE: Questo non genera un AssertionError!

assert.deepEqual('+00000000', false)

L'uguaglianza "profonda" significa che vengono valutate anche le proprietà "own" enumerabili degli oggetti figlio:

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

// I valori di b sono diversi:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// I prototipi vengono ignorati:
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

// I valori di b sono diversi:
assert.deepEqual(obj1, obj2)
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3)
// OK

// I prototipi vengono ignorati:
assert.deepEqual(obj1, obj4)
// AssertionError: { a: { b: 1 } } deepEqual {}

Se i valori non sono uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece dell'AssertionError.

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

[Cronologia]

Versione	Modifiche
v22.2.0, v20.15.0	Vengono ora confrontati anche la causa dell'errore e le proprietà degli errori.
v18.0.0	Viene ora confrontata anche la proprietà lastIndex delle espressioni regolari.
v9.0.0	Vengono ora confrontate le proprietà del simbolo enumerabili.
v9.0.0	Il NaN viene ora confrontato utilizzando il confronto SameValueZero.
v8.5.0	I nomi e i messaggi di Error vengono ora confrontati correttamente.
v8.0.0	Viene confrontato anche il contenuto di Set e Map.
v6.1.0	Gli oggetti con riferimenti circolari possono ora essere utilizzati come input.
v6.4.0, v4.7.1	Le sezioni degli array tipizzati vengono ora gestite correttamente.
v5.10.1, v4.4.3	Gestisci correttamente gli array tipizzati non-Uint8Array.
v1.2.0	Aggiunto in: v1.2.0

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

Verifica l'uguaglianza profonda tra i parametri actual e expected. L'uguaglianza "profonda" significa che le proprietà "proprie" enumerabili degli oggetti figlio vengono valutate ricorsivamente anche secondo le seguenti regole.

Dettagli del confronto

• I valori primitivi vengono confrontati utilizzando Object.is().
• I tag del tipo degli oggetti devono essere uguali.
• [[Prototype]] degli oggetti vengono confrontati utilizzando l'operatore ===.
• Vengono considerate solo le proprietà "proprie" enumerabili.
• I nomi, i messaggi, le cause e gli errori di Error vengono sempre confrontati, anche se queste non sono proprietà enumerabili. Viene confrontato anche errors.
• Vengono confrontate anche le proprietà Symbol proprie enumerabili.
• I wrapper degli oggetti vengono confrontati sia come oggetti che come valori dewrappati.
• Le proprietà Object vengono confrontate in modo non ordinato.
• Le chiavi di Map e gli elementi di Set vengono confrontati in modo non ordinato.
• La ricorsione si interrompe quando entrambi i lati differiscono o entrambi i lati incontrano un riferimento circolare.
• Il confronto di WeakMap e WeakSet non si basa sui loro valori. Vedi sotto per ulteriori dettagli.
• lastIndex, i flag e la sorgente di RegExp vengono sempre confrontati, anche se queste non sono proprietà enumerabili.

ESM

import assert from 'node:assert/strict'

// Questo fallisce perché 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// I seguenti oggetti non hanno proprietà proprie
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// [[Prototype]] diversi:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + {}
// - Date {}

// Tag del tipo diversi:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK perché Object.is(NaN, NaN) è vero.

// Numeri dewrappati diversi:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK perché l'oggetto e la stringa sono identici quando dewrappati.

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

// Zeri diversi:
assert.deepStrictEqual(0, -0)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, perché è lo stesso simbolo su entrambi gli oggetti.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Input identici ma non uguali per riferimento:
//
// {
//   [Symbol()]: 1
// }

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

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, perché è impossibile confrontare le voci

// Fallisce perché weakMap3 ha una proprietà che weakMap1 non contiene:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

CJS

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

// Questo fallisce perché 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' })
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
//   {
// +   a: 1
// -   a: '1'
//   }

// I seguenti oggetti non hanno proprietà proprie
const date = new Date()
const object = {}
const fakeDate = {}
Object.setPrototypeOf(fakeDate, Date.prototype)

// [[Prototype]] diversi:
assert.deepStrictEqual(object, fakeDate)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + {}
// - Date {}

// Tag del tipo diversi:
assert.deepStrictEqual(date, fakeDate)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + 2018-04-26T00:49:08.604Z
// - Date {}

assert.deepStrictEqual(NaN, NaN)
// OK perché Object.is(NaN, NaN) è vero.

// Numeri dewrappati diversi:
assert.deepStrictEqual(new Number(1), new Number(2))
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + [Number: 1]
// - [Number: 2]

assert.deepStrictEqual(new String('foo'), Object('foo'))
// OK perché l'oggetto e la stringa sono identici quando dewrappati.

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

// Zeri diversi:
assert.deepStrictEqual(0, -0)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
// + 0
// - -0

const symbol1 = Symbol()
const symbol2 = Symbol()
assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol1]: 1 })
// OK, perché è lo stesso simbolo su entrambi gli oggetti.

assert.deepStrictEqual({ [symbol1]: 1 }, { [symbol2]: 1 })
// AssertionError [ERR_ASSERTION]: Input identici ma non uguali per riferimento:
//
// {
//   [Symbol()]: 1
// }

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

assert.deepStrictEqual(weakMap1, weakMap2)
// OK, perché è impossibile confrontare le voci

// Fallisce perché weakMap3 ha una proprietà che weakMap1 non contiene:
assert.deepStrictEqual(weakMap1, weakMap3)
// AssertionError: È previsto che gli input siano strettamente profondi-uguali:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

Se i valori non sono uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error allora verrà generato invece dell'AssertionError.

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

[Cronologia]

Versione	Modifiche
v16.0.0	Questa API non è più sperimentale.
v13.6.0, v12.16.0	Aggiunto in: v13.6.0, v12.16.0

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

Si aspetta che l'input string non corrisponda all'espressione regolare.

ESM

import assert from 'node:assert/strict'

assert.doesNotMatch('Fallirò', /fallirò/)
// AssertionError [ERR_ASSERTION]: Si prevedeva che l'input non corrispondesse a ...

assert.doesNotMatch(123, /passa/)
// AssertionError [ERR_ASSERTION]: L'argomento "string" deve essere di tipo stringa.

assert.doesNotMatch('Passerò', /diverso/)
// OK

CJS

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

assert.doesNotMatch('Fallirò', /fallirò/)
// AssertionError [ERR_ASSERTION]: Si prevedeva che l'input non corrispondesse a ...

assert.doesNotMatch(123, /passa/)
// AssertionError [ERR_ASSERTION]: L'argomento "string" deve essere di tipo stringa.

assert.doesNotMatch('Passerò', /diverso/)
// OK

Se i valori corrispondono, o se l'argomento string è di un tipo diverso da string, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece di AssertionError.

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

Aggiunto in: v10.0.0

• asyncFn <Funzione> | <Promise>
• error <RegExp> | <Funzione>
• message <stringa>

Attende la promise asyncFn o, se asyncFn è una funzione, chiama immediatamente la funzione e attende il completamento della promise restituita. Quindi controllerà che la promise non venga rifiutata.

Se asyncFn è una funzione e genera un errore in modo sincrono, assert.doesNotReject() restituirà una Promise rifiutata con quell'errore. Se la funzione non restituisce una promise, assert.doesNotReject() restituirà una Promise rifiutata con un errore ERR_INVALID_RETURN_VALUE. In entrambi i casi, il gestore degli errori viene saltato.

L'uso di assert.doesNotReject() non è in realtà utile perché c'è poco vantaggio nel catturare un rifiuto e quindi rifiutarlo di nuovo. Invece, considera di aggiungere un commento accanto al percorso di codice specifico che non dovrebbe rifiutare e mantieni i messaggi di errore il più espressivi possibile.

Se specificato, error può essere una Classe, RegExp, o una funzione di convalida. Vedi assert.throws() per maggiori dettagli.

Oltre alla natura asincrona per attendere il completamento si comporta in modo identico a assert.doesNotThrow().

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

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

[Cronologia]

Versione	Cambiamenti
v5.11.0, v4.4.5	Il parametro message è ora rispettato.
v4.2.0	Il parametro error può ora essere una funzione freccia.
v0.1.21	Aggiunto in: v0.1.21

• fn <Funzione>
• error <RegExp> | <Funzione>
• message <stringa>

Asserisce che la funzione fn non generi un errore.

Usare assert.doesNotThrow() non è in realtà utile perché non c'è alcun vantaggio nel catturare un errore e poi rilanciarlo. Invece, considera di aggiungere un commento accanto allo specifico percorso di codice che non dovrebbe generare e mantieni i messaggi di errore il più espressivi possibile.

Quando viene chiamato assert.doesNotThrow(), chiamerà immediatamente la funzione fn.

Se viene generato un errore ed è dello stesso tipo di quello specificato dal parametro error, allora viene generato un AssertionError. Se l'errore è di un tipo diverso o se il parametro error non è definito, l'errore viene propagato al chiamante.

Se specificato, error può essere una Classe, RegExp o una funzione di validazione. Consulta assert.throws() per maggiori dettagli.

Il seguente, ad esempio, genererà il TypeError perché non c'è nessun tipo di errore corrispondente nell'asserzione:

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Valore errato')
}, SyntaxError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Valore errato')
}, SyntaxError)

Tuttavia, il seguente risulterà in un AssertionError con il messaggio 'Ottenuta eccezione indesiderata...':

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(() => {
  throw new TypeError('Valore errato')
}, TypeError)

CJS

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

assert.doesNotThrow(() => {
  throw new TypeError('Valore errato')
}, TypeError)

Se viene generato un AssertionError e viene fornito un valore per il parametro message, il valore di message verrà aggiunto al messaggio AssertionError:

ESM

import assert from 'node:assert/strict'

assert.doesNotThrow(
  () => {
    throw new TypeError('Valore errato')
  },
  /Valore errato/,
  'Ops'
)
// Genera: AssertionError: Ottenuta eccezione indesiderata: Ops

CJS

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Valore errato')
  },
  /Valore errato/,
  'Ops'
)
// Genera: AssertionError: Ottenuta eccezione indesiderata: Ops

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

[Cronologia]

Versione	Modifiche
v16.0.0, v14.18.0	Nella modalità di asserzione Legacy, lo stato è cambiato da Deprecato a Legacy.
v14.0.0	NaN viene ora trattato come identico se entrambi i lati sono NaN.
v0.1.21	Aggiunto in: v0.1.21

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

Modalità di asserzione rigorosa

Un alias di assert.strictEqual().

Modalità di asserzione Legacy

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Utilizzare assert.strictEqual() invece.

Verifica l'uguaglianza superficiale e coercitiva tra i parametri actual ed expected utilizzando l'operatore ==. NaN viene gestito in modo speciale e trattato come identico se entrambi i lati sono 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 } }

Se i valori non sono uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message non è definito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece dell' AssertionError.

assert.fail([message])

Aggiunto in: v0.1.21

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

Lancia un AssertionError con il messaggio di errore fornito o un messaggio di errore predefinito. Se il parametro message è un'istanza di Error, verrà lanciato invece di 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'utilizzo di assert.fail() con più di due argomenti è possibile ma deprecato. Vedere di seguito per maggiori dettagli.

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

[Cronologia]

Versione	Modifiche
v10.0.0	Chiamare assert.fail() con più di un argomento è deprecato ed emette un avviso.
v0.1.21	Aggiunto in: v0.1.21

[Stabile: 0 - Deprecato]

Stabile: 0 Stabilità: 0 - Deprecato: Utilizzare assert.fail([message]) o altre funzioni assert.

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

Se message è falsy, il messaggio di errore viene impostato come i valori di actual e expected separati dall' operator fornito. Se vengono forniti solo i due argomenti actual e expected, operator sarà predefinito a '!='. Se message viene fornito come terzo argomento, verrà utilizzato come messaggio di errore e gli altri argomenti verranno memorizzati come proprietà sull'oggetto lanciato. Se viene fornito stackStartFn, tutti i frame dello stack sopra quella funzione verranno rimossi dallo stacktrace (vedere Error.captureStackTrace). Se non vengono forniti argomenti, verrà utilizzato il messaggio predefinito 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

Negli ultimi tre casi actual, expected e operator non hanno alcuna influenza sul messaggio di errore.

Esempio di utilizzo di stackStartFn per troncare lo stacktrace dell'eccezione:

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)

[Cronologia]

Versione	Modifiche
v10.0.0	Invece di lanciare l'errore originale, ora viene racchiuso in un [AssertionError][] che contiene l'intera traccia dello stack.
v10.0.0	Il valore può ora essere solo undefined o null. Prima, tutti i valori falsy venivano gestiti come null e non generavano errori.
v0.1.97	Aggiunto in: v0.1.97

• value <any>

Lancia value se value non è undefined o null. Questo è utile quando si testa l'argomento error nei callback. La traccia dello stack contiene tutti i frame dell'errore passato a ifError(), inclusi i potenziali nuovi frame per ifError() stesso.

ESM

import assert from 'node:assert/strict'

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: Error

// Crea alcuni frame di errore casuali.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: test error
//     at ifErrorFrame
//     at errorFrame

CJS

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

assert.ifError(null)
// OK
assert.ifError(0)
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: 0
assert.ifError('error')
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: 'error'
assert.ifError(new Error())
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: Error

// Crea alcuni frame di errore casuali.
let err
;(function errorFrame() {
  err = new Error('test error')
})()

;(function ifErrorFrame() {
  assert.ifError(err)
})()
// AssertionError [ERR_ASSERTION]: ifError ha ricevuto un'eccezione indesiderata: test error
//     at ifErrorFrame
//     at errorFrame

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

[Cronologia]

Versione	Modifiche
v16.0.0	Questa API non è più sperimentale.
v13.6.0, v12.16.0	Aggiunto in: v13.6.0, v12.16.0

• string <stringa>
• regexp <RegExp>
• message <stringa> | <Errore>

Si aspetta che l'input string corrisponda all'espressione regolare.

ESM

import assert from 'node:assert/strict'

assert.match('Fallirò', /pass/)
// AssertionError [ERR_ASSERTION]: L'input non corrisponde all'espressione regolare ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: L'argomento "string" deve essere di tipo stringa.

assert.match('Passerò', /pass/)
// OK

CJS

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

assert.match('Fallirò', /pass/)
// AssertionError [ERR_ASSERTION]: L'input non corrisponde all'espressione regolare ...

assert.match(123, /pass/)
// AssertionError [ERR_ASSERTION]: L'argomento "string" deve essere di tipo stringa.

assert.match('Passerò', /pass/)
// OK

Se i valori non corrispondono, o se l'argomento string è di un tipo diverso da string, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece di AssertionError.

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

[Cronologia]

Versione	Modifiche
v16.0.0, v14.18.0	Nella modalità di asserzione Legacy, lo stato è cambiato da Deprecato a Legacy.
v14.0.0	NaN viene ora trattato come identico se entrambi i lati sono NaN.
v9.0.0	I nomi e i messaggi di Error vengono ora confrontati correttamente.
v8.0.0	Viene confrontato anche il contenuto di Set e Map.
v6.4.0, v4.7.1	Le fette di array tipizzato vengono ora gestite correttamente.
v6.1.0, v4.5.0	Gli oggetti con riferimenti circolari possono ora essere usati come input.
v5.10.1, v4.4.3	Gestisce correttamente gli array tipizzati non-Uint8Array.
v0.1.21	Aggiunto in: v0.1.21

• actual <qualsiasi>
• expected <qualsiasi>
• message <stringa> | <Errore>

Modalità di asserzione rigorosa

Un alias di assert.notDeepStrictEqual().

Modalità di asserzione legacy

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Invece, usa assert.notDeepStrictEqual().

Verifica qualsiasi disuguaglianza profonda. Opposto di 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

Se i valori sono profondamente uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece di AssertionError.

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

[Cronologia]

Versione	Modifiche
v9.0.0	-0 e +0 non sono più considerati uguali.
v9.0.0	NaN viene ora confrontato utilizzando il confronto SameValueZero.
v9.0.0	I nomi e i messaggi di Error vengono ora confrontati correttamente.
v8.0.0	Viene confrontato anche il contenuto di Set e Map.
v6.1.0	Ora è possibile utilizzare come input oggetti con riferimenti circolari.
v6.4.0, v4.7.1	Le fette di array tipizzati vengono ora gestite correttamente.
v5.10.1, v4.4.3	Gestisci correttamente array tipizzati non Uint8Array.
v1.2.0	Aggiunto in: v1.2.0

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

Verifica la disuguaglianza stretta profonda. Opposto di 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

Se i valori sono profondamente e strettamente uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error allora verrà generato al posto di AssertionError.

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

[Cronologia]

Versione	Modifiche
v16.0.0, v14.18.0	Nella modalità di asserzione legacy, lo stato è cambiato da Deprecato a Legacy.
v14.0.0	NaN viene ora trattato come identico se entrambi i lati sono NaN.
v0.1.21	Aggiunto in: v0.1.21

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

Modalità di asserzione stretta

Un alias di assert.notStrictEqual().

Modalità di asserzione legacy

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Utilizzare invece assert.notStrictEqual().

Verifica la disuguaglianza superficiale, coercitiva con l'operatore !=. NaN viene gestito in modo speciale e trattato come identico se entrambi i lati sono 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'

Se i valori sono uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error allora verrà generato al posto di AssertionError.

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

[Cronologia]

Versione	Modifiche
v10.0.0	Il confronto utilizzato è cambiato da Uguaglianza Stretta a Object.is().
v0.1.21	Aggiunto in: v0.1.21

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

Verifica la disuguaglianza stretta tra i parametri actual e expected come determinato da Object.is().

ESM

import assert from 'node:assert/strict'

assert.notStrictEqual(1, 2)
// OK

assert.notStrictEqual(1, 1)
// AssertionError [ERR_ASSERTION]: Ci si aspetta che "actual" sia strettamente diverso da:
//
// 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]: Ci si aspetta che "actual" sia strettamente diverso da:
//
// 1

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

Se i valori sono strettamente uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece dell'AssertionError.

assert.ok(value[, message])

[Cronologia]

Versione	Modifiche
v10.0.0	assert.ok() (senza argomenti) ora userà un messaggio di errore predefinito.
v0.1.21	Aggiunto in: v0.1.21

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

Verifica se value è truthy. È equivalente a assert.equal(!!value, true, message).

Se value non è truthy, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message è undefined, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece dell'AssertionError. Se non viene passato alcun argomento, message sarà impostato sulla stringa: 'Nessun argomento di valore passato a assert.ok()'.

Tieni presente che nella repl il messaggio di errore sarà diverso da quello generato in un file! Vedi sotto per maggiori dettagli.

ESM

import assert from 'node:assert/strict'

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

assert.ok()
// AssertionError: Nessun argomento di valore passato a `assert.ok()`

assert.ok(false, 'è falso')
// AssertionError: è falso

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

// In un file (es. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert.ok(0)

CJS

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

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

assert.ok()
// AssertionError: Nessun argomento di valore passato a `assert.ok()`

assert.ok(false, 'è falso')
// AssertionError: è falso

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

// In un file (es. test.js):
assert.ok(typeof 123 === 'string')
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false)
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert.ok(false)

assert.ok(0)
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert.ok(0)

ESM

import assert from 'node:assert/strict'

// Usare `assert()` funziona allo stesso modo:
assert(0)
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert(0)

CJS

const assert = require('node:assert')

// Usare `assert()` funziona allo stesso modo:
assert(0)
// AssertionError: L'espressione è stata valutata con un valore falsy:
//
//   assert(0)

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

Aggiunto in: v10.0.0

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

Attende che la promise asyncFn venga risolta o, se asyncFn è una funzione, chiama immediatamente la funzione e attende che la promise restituita venga completata. Quindi verificherà che la promise sia stata rifiutata.

Se asyncFn è una funzione e genera un errore in modo sincrono, assert.rejects() restituirà una Promise rifiutata con quell'errore. Se la funzione non restituisce una promise, assert.rejects() restituirà una Promise rifiutata con un errore ERR_INVALID_RETURN_VALUE. In entrambi i casi, il gestore degli errori viene saltato.

Oltre alla natura asincrona di attesa del completamento, si comporta in modo identico a assert.throws().

Se specificato, error può essere una Class, RegExp, una funzione di convalida, un oggetto in cui ogni proprietà sarà verificata o un'istanza di errore in cui ogni proprietà sarà verificata, incluse le proprietà non enumerabili message e name.

Se specificato, message sarà il messaggio fornito da AssertionError se asyncFn non riesce a rifiutare.

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

error non può essere una stringa. Se una stringa viene fornita come secondo argomento, si presume che error venga omesso e la stringa verrà utilizzata invece per message. Ciò può portare a errori facili da perdere. Si prega di leggere attentamente l'esempio in assert.throws() se si prende in considerazione l'utilizzo di una stringa come secondo argomento.

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

[Cronologia]

Versione	Modifiche
v10.0.0	Il confronto utilizzato è cambiato da Strict Equality a Object.is().
v0.1.21	Aggiunto in: v0.1.21

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

Verifica la stretta uguaglianza tra i parametri actual e expected come determinato da Object.is().

ESM

import assert from 'node:assert/strict'

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Previsto che gli input fossero strettamente uguali:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Previsto che gli input fossero strettamente uguali:
// + 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('Gli input non sono identici'))
// TypeError: Gli input non sono identici

CJS

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

assert.strictEqual(1, 2)
// AssertionError [ERR_ASSERTION]: Previsto che gli input fossero strettamente uguali:
//
// 1 !== 2

assert.strictEqual(1, 1)
// OK

assert.strictEqual('Hello foobar', 'Hello World!')
// AssertionError [ERR_ASSERTION]: Previsto che gli input fossero strettamente uguali:
// + 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('Gli input non sono identici'))
// TypeError: Gli input non sono identici

Se i valori non sono strettamente uguali, viene generato un AssertionError con una proprietà message impostata uguale al valore del parametro message. Se il parametro message non è definito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error allora verrà generato al posto di AssertionError.

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

[Cronologia]

Versione	Modifiche
v10.2.0	Il parametro error ora può essere un oggetto contenente espressioni regolari.
v9.9.0	Il parametro error ora può essere anche un oggetto.
v4.2.0	Il parametro error ora può essere una funzione freccia.
v0.1.21	Aggiunto in: v0.1.21

• fn <Funzione>
• error <RegExp> | <Funzione> | <Oggetto> | <Errore>
• message <stringa>

Si aspetta che la funzione fn generi un errore.

Se specificato, error può essere una Classe, una RegExp, una funzione di validazione, un oggetto di validazione in cui ogni proprietà verrà testata per l'uguaglianza stretta profonda, o un'istanza di errore in cui ogni proprietà verrà testata per l'uguaglianza stretta profonda incluse le proprietà non enumerabili message e name. Quando si utilizza un oggetto, è anche possibile utilizzare un'espressione regolare, quando si esegue la validazione rispetto a una proprietà stringa. Vedere sotto per esempi.

Se specificato, message verrà aggiunto al messaggio fornito da AssertionError se la chiamata fn non riesce a generare un'eccezione o nel caso in cui la validazione dell'errore fallisca.

Oggetto di validazione personalizzato/istanza di errore:

ESM

import assert from 'node:assert/strict'

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

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Valore errato',
    info: {
      nested: true,
      baz: 'text',
    },
    // Verranno testate solo le proprietà dell'oggetto di validazione.
    // L'uso di oggetti nidificati richiede che tutte le proprietà siano presenti. Altrimenti
    // la validazione fallirà.
  }
)

// Utilizzo di espressioni regolari per validare le proprietà di errore:
assert.throws(
  () => {
    throw err
  },
  {
    // Le proprietà `name` e `message` sono stringhe e l'utilizzo di espressioni regolari
    // su di esse corrisponderà alla stringa. Se falliscono, viene generato un
    // errore.
    name: /^TypeError$/,
    message: /Errato/,
    foo: 'bar',
    info: {
      nested: true,
      // Non è possibile utilizzare espressioni regolari per le proprietà nidificate!
      baz: 'text',
    },
    // La proprietà `reg` contiene un'espressione regolare e solo se
    // l'oggetto di validazione contiene un'espressione regolare identica,
    // verrà superata.
    reg: /abc/i,
  }
)

// Fallisce a causa delle diverse proprietà `message` e `name`:
assert.throws(
  () => {
    const otherErr = new Error('Non trovato')
    // Copia tutte le proprietà enumerabili da `err` a `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Le proprietà `message` e `name` dell'errore verranno verificate anche quando si utilizza
  // un errore come oggetto di validazione.
  err
)

CJS

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

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

assert.throws(
  () => {
    throw err
  },
  {
    name: 'TypeError',
    message: 'Valore errato',
    info: {
      nested: true,
      baz: 'text',
    },
    // Verranno testate solo le proprietà dell'oggetto di validazione.
    // L'uso di oggetti nidificati richiede che tutte le proprietà siano presenti. Altrimenti
    // la validazione fallirà.
  }
)

// Utilizzo di espressioni regolari per validare le proprietà di errore:
assert.throws(
  () => {
    throw err
  },
  {
    // Le proprietà `name` e `message` sono stringhe e l'utilizzo di espressioni regolari
    // su di esse corrisponderà alla stringa. Se falliscono, viene generato un
    // errore.
    name: /^TypeError$/,
    message: /Errato/,
    foo: 'bar',
    info: {
      nested: true,
      // Non è possibile utilizzare espressioni regolari per le proprietà nidificate!
      baz: 'text',
    },
    // La proprietà `reg` contiene un'espressione regolare e solo se
    // l'oggetto di validazione contiene un'espressione regolare identica,
    // verrà superata.
    reg: /abc/i,
  }
)

// Fallisce a causa delle diverse proprietà `message` e `name`:
assert.throws(
  () => {
    const otherErr = new Error('Non trovato')
    // Copia tutte le proprietà enumerabili da `err` a `otherErr`.
    for (const [key, value] of Object.entries(err)) {
      otherErr[key] = value
    }
    throw otherErr
  },
  // Le proprietà `message` e `name` dell'errore verranno verificate anche quando si utilizza
  // un errore come oggetto di validazione.
  err
)

Convalida instanceof utilizzando il costruttore:

ESM

import assert from 'node:assert/strict'

assert.throws(() => {
  throw new Error('Valore errato')
}, Error)

CJS

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

assert.throws(() => {
  throw new Error('Valore errato')
}, Error)

Convalida del messaggio di errore utilizzando RegExp:

L'utilizzo di un'espressione regolare esegue .toString sull'oggetto errore, e quindi includerà anche il nome dell'errore.

ESM

import assert from 'node:assert/strict'

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

CJS

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

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

Convalida dell'errore personalizzata:

La funzione deve restituire true per indicare che tutte le validazioni interne sono state superate. Altrimenti fallirà con un AssertionError.

ESM

import assert from 'node:assert/strict'

assert.throws(
  () => {
    throw new Error('Valore errato')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Evitare di restituire qualsiasi cosa dalle funzioni di validazione oltre a `true`.
    // Altrimenti, non è chiaro quale parte della validazione non è riuscita. Invece,
    // genera un errore sulla specifica validazione non riuscita (come fatto in questo
    // esempio) e aggiungi quante più informazioni di debug utili a quell'errore
    // possibile.
    return true
  },
  'errore imprevisto'
)

CJS

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

assert.throws(
  () => {
    throw new Error('Valore errato')
  },
  err => {
    assert(err instanceof Error)
    assert(/value/.test(err))
    // Evitare di restituire qualsiasi cosa dalle funzioni di validazione oltre a `true`.
    // Altrimenti, non è chiaro quale parte della validazione non è riuscita. Invece,
    // genera un errore sulla specifica validazione non riuscita (come fatto in questo
    // esempio) e aggiungi quante più informazioni di debug utili a quell'errore
    // possibile.
    return true
  },
  'errore imprevisto'
)

error non può essere una stringa. Se viene fornita una stringa come secondo argomento, si presume che error venga omesso e la stringa verrà utilizzata per message. Ciò può portare a errori facili da perdere. L'utilizzo dello stesso messaggio del messaggio di errore generato comporterà un errore ERR_AMBIGUOUS_ARGUMENT. Si prega di leggere attentamente l'esempio seguente se si considera l'utilizzo di una stringa come secondo argomento:

ESM

import assert from 'node:assert/strict'

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

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

function notThrowing() {}

// Il secondo argomento è una stringa e la funzione di input ha generato un errore.
// Il primo caso non genererà un errore in quanto non corrisponde al messaggio di errore
// generato dalla funzione di input!
assert.throws(throwingFirst, 'Second')
// Nell'esempio successivo, il messaggio non ha alcun vantaggio rispetto al messaggio dell'errore e
// poiché non è chiaro se l'utente intendesse effettivamente fare una corrispondenza
// con il messaggio di errore, Node.js genera un errore `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// La stringa viene utilizzata (come messaggio) solo nel caso in cui la funzione non generi un errore:
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Eccezione prevista mancante: Second

// Se si intendeva fare una corrispondenza per il messaggio di errore, fare invece questo:
// Non genera un'eccezione perché i messaggi di errore corrispondono.
assert.throws(throwingSecond, /Second$/)

// Se il messaggio di errore non corrisponde, viene generato un AssertionError.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]

CJS

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

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

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

function notThrowing() {}

// Il secondo argomento è una stringa e la funzione di input ha generato un errore.
// Il primo caso non genererà un errore in quanto non corrisponde al messaggio di errore
// generato dalla funzione di input!
assert.throws(throwingFirst, 'Second')
// Nell'esempio successivo, il messaggio non ha alcun vantaggio rispetto al messaggio dell'errore e
// poiché non è chiaro se l'utente intendesse effettivamente fare una corrispondenza
// con il messaggio di errore, Node.js genera un errore `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Second')
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

// La stringa viene utilizzata (come messaggio) solo nel caso in cui la funzione non generi un errore:
assert.throws(notThrowing, 'Second')
// AssertionError [ERR_ASSERTION]: Eccezione prevista mancante: Second

// Se si intendeva fare una corrispondenza per il messaggio di errore, fare invece questo:
// Non genera un'eccezione perché i messaggi di errore corrispondono.
assert.throws(throwingSecond, /Second$/)

// Se il messaggio di errore non corrisponde, viene generato un AssertionError.
assert.throws(throwingFirst, /Second$/)
// AssertionError [ERR_ASSERTION]

A causa della notazione confusa e soggetta a errori, evitare una stringa come secondo argomento.

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

Aggiunto in: v23.4.0

[Stabile: 1 - Sperimentale]

Stabile: 1 Stabilità: 1.0 - Sviluppo iniziale

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

assert.partialDeepStrictEqual() Asserisce l'equivalenza tra i parametri actual e expected attraverso un confronto approfondito, assicurando che tutte le proprietà nel parametro expected siano presenti nel parametro actual con valori equivalenti, senza consentire la coercizione di tipo. La principale differenza con assert.deepStrictEqual() è che assert.partialDeepStrictEqual() non richiede che tutte le proprietà nel parametro actual siano presenti nel parametro expected. Questo metodo dovrebbe sempre superare gli stessi casi di test di assert.deepStrictEqual(), comportandosi come un suo super set.

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