Assert

[Stabile: 2 - Stabile]

Codice sorgente: lib/assert.js

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

Modalità di asserzione strict

[Cronologia]

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

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

In modalità di asserzione strict, i messaggi di errore per gli oggetti visualizzano una diff. In modalità di asserzione legacy, i messaggi di errore per gli oggetti visualizzano gli oggetti, spesso troncati.

Per utilizzare la modalità di asserzione strict:

ESMCJS

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

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

ESMCJS

import assert from 'node:assert/strict';

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

Esempio di diff di errore:

ESMCJS

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
//   ]

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
//   ]

Per disattivare i colori, utilizzare le variabili d'ambiente NO_COLOR o NODE_DISABLE_COLORS. Questo disattiverà anche i colori nella REPL. Per maggiori informazioni sul supporto dei colori negli ambienti terminali, leggi la documentazione di tty getColorDepth().

Modalità di asserzione legacy

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

Per utilizzare la modalità di asserzione legacy:

ESMCJS

import assert from 'node:assert';

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

La modalità di asserzione legacy può avere risultati sorprendenti, specialmente quando si utilizza assert.deepEqual():

// ATTENZIONE: Questo non solleva un AssertionError in 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 sollevati 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 è 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 fornito, 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.

ESMCJS

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

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	Aggiunta 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'utilizzo di alternative come la funzione helper mock.

`new assert.CallTracker()`

Aggiunta in: v14.2.0, v12.19.0

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

ESMCJS

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

const tracker = new assert.CallTracker();

function func() {}

// callsfunc() deve essere chiamato 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 il numero esatto di volte.
process.on('exit', () => {
  tracker.verify();
});

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

const tracker = new assert.CallTracker();

function func() {}

// callsfunc() deve essere chiamato 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 il numero esatto di volte.
process.on('exit', () => {
  tracker.verify();
});

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

Aggiunta in: v14.2.0, v12.19.0

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

Si prevede che la funzione wrapper venga chiamata esattamente exact volte. Se la funzione non è stata chiamata esattamente exact volte quando viene chiamato tracker.verify(), allora tracker.verify() genererà un errore.

ESMCJS

import assert from 'node:assert';

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

function func() {}

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

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

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

function func() {}

// Restituisce una funzione che avvolge 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

ESMCJS

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] }]);

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

// Creates call tracker.
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 contenente informazioni sulle funzioni wrapper restituite da tracker.calls().
Oggetto <Object>
- message <string>
- actual <number> Il numero effettivo di volte in cui la funzione è stata chiamata.
- expected <number> Il numero di volte in cui ci si aspettava che la funzione fosse chiamata.
- operator <string> Il nome della funzione di cui è stato eseguito il 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.

ESMCJS

import assert from 'node:assert';

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Returns an array containing information on 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
//  }
// ]

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

// Creates call tracker.
const tracker = new assert.CallTracker();

function func() {}

// Returns a function that wraps func() that must be called exact times
// before tracker.verify().
const callsfunc = tracker.calls(func, 2);

// Returns an array containing information on 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])`

Aggiunto in: v18.8.0, v16.18.0

fn <Function> una funzione tracciata da resettare.

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

ESMCJS

import assert from 'node:assert';

const tracker = new assert.CallTracker();

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

callsfunc();
// Tracker è stato chiamato una volta
assert.strictEqual(tracker.getCalls(callsfunc).length, 1);

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

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

const tracker = new assert.CallTracker();

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

callsfunc();
// 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 di funzioni passate a tracker.calls() e lancerà un errore per le funzioni che non sono state chiamate il numero di volte previsto.

ESMCJS

import assert from 'node:assert';

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

function func() {}

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

callsfunc();

// Lancerà un errore poiché callsfunc() è stato chiamato solo una volta.
tracker.verify();

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

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

function func() {}

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

callsfunc();

// Lancerà un errore poiché callsfunc() è stato chiamato solo una volta.
tracker.verify();

`assert(value[, message])`

Aggiunto in: v0.5.9

value <any> L'input che viene controllato 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	Anche la causa dell'errore e le proprietà errors vengono ora confrontate.
v18.0.0	Anche la proprietà lastIndex delle espressioni regolari viene ora confrontata.
v16.0.0, v14.18.0	Nella modalità di asserzione Legacy, lo stato è cambiato da Obsoleto a Legacy.
v14.0.0	NaN viene ora trattato come identico se entrambi i lati sono NaN.
v12.0.0	I tag di tipo vengono ora confrontati correttamente e ci sono alcune piccole modifiche al confronto per rendere il controllo meno sorprendente.
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 slice di array tipizzati 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	Gestire correttamente gli array tipizzati non-`Uint8Array`.
v0.1.21	Aggiunto in: v0.1.21

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

Modalità di asserzione rigorosa

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(). assert.deepEqual() può avere risultati sorprendenti.

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

Dettagli del confronto

I valori primitivi vengono confrontati con l'operatore ==, ad 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 si tratta di proprietà enumerabili.
I wrapper di oggetti vengono confrontati sia come oggetti che come valori non incapsulati.
Le proprietà di Object vengono confrontate senza un ordine specifico.
Le chiavi di Map e gli elementi di Set vengono confrontati senza un ordine specifico.
La ricorsione si arresta quando entrambi i lati differiscono o entrambi i lati incontrano un riferimento circolare.
L'implementazione non testa la proprietà [[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, flags e source di RegExp vengono sempre confrontati, anche se non si tratta di proprietà enumerabili.

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

ESMCJS

import assert from 'node:assert';
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false);

const assert = require('node:assert');
// WARNING: This does not throw an AssertionError!

assert.deepEqual('+00000000', false);

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

ESMCJS

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

// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3);
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}

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

// Values of b are different:
assert.deepEqual(obj1, obj2);
// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }

assert.deepEqual(obj1, obj3);
// OK

// Prototypes are ignored:
assert.deepEqual(obj1, obj4);
// AssertionError: { a: { b: 1 } } deepEqual {}

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 Error, allora verrà generato al posto di AssertionError.

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

[Cronologia]

Versione	Modifiche
v22.2.0, v20.15.0	Vengono ora confrontati anche i valori cause e errors dell'errore.
v18.0.0	Viene ora confrontata anche la proprietà lastIndex delle espressioni regolari.
v9.0.0	Vengono ora confrontate le proprietà simbolo enumerabili.
v9.0.0	Il valore `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 fette di 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>

Esegue dei test per verificare 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 di 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 di oggetti vengono confrontati sia come oggetti sia 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 entrambi i lati incontrano un riferimento circolare.
Il confronto di WeakMap e WeakSet non si basa sui loro valori. Vedi sotto per maggiori dettagli.
lastIndex, flags e source di RegExp vengono sempre confrontati, anche se queste non sono proprietà enumerabili.

ESMCJS

import assert from 'node:assert/strict';

// Questo fallisce perché 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Expected inputs to be strictly deep-equal:
// + 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]] differente:
assert.deepStrictEqual(object, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Tag di tipo differenti:
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 perché Object.is(NaN, NaN) è vero.

// Numeri non incapsulati differenti:
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 perché l'oggetto e la stringa sono identici quando non incapsulati.

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

// Zeri differenti:
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, perché è lo stesso simbolo su entrambi gli oggetti.

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, perché è impossibile confrontare le voci

// Fallisce perché weakMap3 ha una proprietà che weakMap1 non contiene:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
//   WeakMap {
// +   [items unknown]
// -   [items unknown],
// -   unequal: true
//   }

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

// Questo fallisce perché 1 !== '1'.
assert.deepStrictEqual({ a: 1 }, { a: '1' });
// AssertionError: Expected inputs to be strictly deep-equal:
// + 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]] differente:
assert.deepStrictEqual(object, fakeDate);
// AssertionError: Expected inputs to be strictly deep-equal:
// + actual - expected
//
// + {}
// - Date {}

// Tag di tipo differenti:
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 perché Object.is(NaN, NaN) è vero.

// Numeri non incapsulati differenti:
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 perché l'oggetto e la stringa sono identici quando non incapsulati.

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

// Zeri differenti:
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, perché è lo stesso simbolo su entrambi gli oggetti.

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, perché è impossibile confrontare le voci

// Fallisce perché weakMap3 ha una proprietà che weakMap1 non contiene:
assert.deepStrictEqual(weakMap1, weakMap3);
// AssertionError: Expected inputs to be strictly deep-equal:
// + 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 non è definito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error, allora verrà generato invece di 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.

ESMCJS

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

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

Se i valori corrispondono, o se l'argomento string è di un tipo diverso da string, viene generato un AssertionError con una proprietà message impostata sul 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à lanciato 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 sia 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 ignorato.

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

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

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

ESMCJS

import assert from 'node:assert/strict';

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

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

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

ESMCJS

import assert from 'node:assert/strict';

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

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

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

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

[Cronologia]

Versione	Modifiche
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 <Function>
error <RegExp> | <Function>
message <string>

Asserisce che la funzione fn non generi un errore.

In realtà, l'utilizzo di assert.doesNotThrow() non è utile perché non c'è alcun vantaggio nel catturare un errore e poi rilanciarlo. Invece, considera di aggiungere un commento accanto al percorso di codice specifico che non dovrebbe generare errori 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, viene generato un AssertionError. Se l'errore è di un tipo diverso o se il parametro error non è definito, l'errore viene propagato di nuovo al chiamante.

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

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

ESMCJS

import assert from 'node:assert/strict';

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

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

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

Tuttavia, quanto segue risulterà in un AssertionError con il messaggio "Got unwanted exception...":

ESMCJS

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
);

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  TypeError,
);

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

ESMCJS

import assert from 'node:assert/strict';

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  /Wrong value/,
  'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoops

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

assert.doesNotThrow(
  () => {
    throw new TypeError('Wrong value');
  },
  /Wrong value/,
  'Whoops',
);
// Throws: AssertionError: Got unwanted exception: Whoops

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

[Cronologia]

Versione	Modifiche
v16.0.0, v14.18.0	Nella modalità di asserzione Legacy, lo stato è stato modificato 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 Strict

Un alias di assert.strictEqual().

Modalità di asserzione Legacy

[Stabile: 3 - Legacy]

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

Verifica l'uguaglianza superficiale e coercitiva tra i parametri actual ed expected usando l'operatore ==. NaN viene gestito in modo speciale e trattato come identico se entrambi i lati sono NaN.

ESMCJS

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

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 è indefinito, 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 <stringa> | <Error> Predefinito: 'Failed'

Genera un AssertionError con il messaggio di errore fornito o un messaggio di errore predefinito. Se il parametro message è un'istanza di Error, verrà generato al posto di AssertionError.

ESMCJS

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

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 ulteriori 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 invece assert.fail([message]) o altre funzioni assert.

actual <any>
expected <any>
message <stringa> | <Error>
operator <stringa> Predefinito: '!='
stackStartFn <Funzione> 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 generato. Se viene fornito stackStartFn, tutti i frame di stack sopra quella funzione verranno rimossi dallo stacktrace (vedere Error.captureStackTrace). Se non vengono forniti argomenti, verrà utilizzato il messaggio predefinito Failed.

ESMCJS

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

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:

ESMCJS

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

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, viene ora racchiuso in un [`AssertionError`][] che contiene l'intera traccia dello stack.
v10.0.0	Value ora può essere solo `undefined` o `null`. Prima tutti i valori falsi venivano gestiti come `null` e non lanciavano un'eccezione.
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.

ESMCJS

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

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	Aggiunta in: v13.6.0, v12.16.0

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

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

ESMCJS

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

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

Se i valori non corrispondono, o se l'argomento string è di un tipo diverso da string, viene generata una 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à lanciato invece dell'AssertionError.

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

[Cronologia]

Versione	Modifiche
v16.0.0, v14.18.0	Nella modalità di asserzione Legacy, lo stato è stato modificato da Deprecated 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 sezioni di array tipizzati vengono ora gestite correttamente.
v6.1.0, v4.5.0	Gli oggetti con riferimenti circolari possono ora essere utilizzati come input.
v5.10.1, v4.4.3	Gestisce correttamente gli array tipizzati non `Uint8Array`.
v0.1.21	Aggiunta in: v0.1.21

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

Modalità di asserzione rigorosa

Un alias di assert.notDeepStrictEqual().

Modalità di asserzione Legacy

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: utilizzare invece assert.notDeepStrictEqual().

Verifica qualsiasi disuguaglianza profonda. Opposto di assert.deepEqual().

ESMCJS

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

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 generata una 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à lanciato invece dell'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	Gli oggetti con riferimenti circolari possono ora essere utilizzati come input.
v6.4.0, v4.7.1	Le sezioni di 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 la disuguaglianza stretta profonda. Opposto di assert.deepStrictEqual().

ESMCJS

import assert from 'node:assert/strict';

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

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 invece di AssertionError.

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

[Cronologia]

Versione	Modifiche
v16.0.0, v14.18.0	In 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 Strict

Un alias di assert.notStrictEqual().

Modalità di asserzione Legacy

[Stabile: 3 - Legacy]

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

Verifica la disuguaglianza shallow e coercitiva con l'operatore !=. NaN viene gestito in modo speciale e trattato come identico se entrambi i lati sono NaN.

ESMCJS

import assert from 'node:assert';

assert.notEqual(1, 2);
// OK

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

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

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 invece di AssertionError.

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

[Cronologia]

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

actual <any>
expected <any>
message <stringa> | <Error>

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

ESMCJS

import assert from 'node:assert/strict';

assert.notStrictEqual(1, 2);
// OK

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Previsto che "actual" sia strettamente diverso da:
//
// 1

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

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

assert.notStrictEqual(1, 2);
// OK

assert.notStrictEqual(1, 1);
// AssertionError [ERR_ASSERTION]: Previsto 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 sul 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à lanciato invece dell'AssertionError.

`assert.ok(value[, message])`

[Cronologia]

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

value <any>
message <stringa> | <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 sul 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, verrà lanciato invece dell'AssertionError. Se non vengono passati affatto argomenti, 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 lanciato in un file! Vedi sotto per maggiori dettagli.

ESMCJS

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 (ad esempio test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: L'espressione ha valutato a un valore falsy:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: L'espressione ha valutato a un valore falsy:
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: L'espressione ha valutato a un valore falsy:
//
//   assert.ok(0)

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 (ad esempio test.js):
assert.ok(typeof 123 === 'string');
// AssertionError: L'espressione ha valutato a un valore falsy:
//
//   assert.ok(typeof 123 === 'string')

assert.ok(false);
// AssertionError: L'espressione ha valutato a un valore falsy:
//
//   assert.ok(false)

assert.ok(0);
// AssertionError: L'espressione ha valutato a un valore falsy:
//
//   assert.ok(0)

ESMCJS

import assert from 'node:assert/strict';

// L'uso di `assert()` funziona allo stesso modo:
assert(0);
// AssertionError: L'espressione ha valutato a un valore falsy:
//
//   assert(0)

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

// L'uso di `assert()` funziona allo stesso modo:
assert(0);
// AssertionError: L'espressione ha valutato a 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 la promise asyncFn o, se asyncFn è una funzione, chiama immediatamente la funzione e attende che la promise restituita venga completata. Quindi verificherà che la promise venga 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 async per attendere il completamento, si comporta in modo identico a assert.throws().

Se specificato, error può essere una Class, RegExp, una funzione di validazione, un oggetto in cui ogni proprietà verrà testata, o un'istanza di errore in cui ogni proprietà verrà testata, comprese le proprietà non enumerabili message e name.

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

ESMCJS

import assert from 'node:assert/strict';

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

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

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

ESMCJS

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;
  },
);

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;
    },
  );
})();

ESMCJS

import assert from 'node:assert/strict';

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

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

assert.rejects(
  Promise.reject(new Error('Wrong value')),
  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 considera 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().

ESMCJS

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

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

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 è indefinito, viene assegnato un messaggio di errore predefinito. Se il parametro message è un'istanza di un Error allora verrà lanciato invece dell'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 arrow function.
v0.1.21	Aggiunto in: v0.1.21

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

Si aspetta che la funzione fn generi un errore.

Se specificato, error può essere una Class, RegExp, una funzione di validazione, un oggetto di validazione in cui ogni proprietà verrà testata per l'uguaglianza profonda rigorosa, o un'istanza di errore in cui ogni proprietà verrà testata per l'uguaglianza profonda rigorosa 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 o nel caso in cui la validazione dell'errore fallisca.

Oggetto/istanza di errore di validazione personalizzata:

ESMCJS

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',
    },
    // Saranno testate solo le proprietà sull'oggetto di validazione.
    // L'utilizzo di oggetti nidificati richiede che tutte le proprietà siano presenti. Altrimenti
    // la validazione fallirà.
  },
);

// Utilizzo di espressioni regolari per validare le proprietà dell'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, verrà generato un
    // errore.
    name: /^TypeError$/,
    message: /Wrong/,
    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, passerà.
    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 controllate anche quando si utilizza
  // un errore come oggetto di validazione.
  err,
);

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',
    },
    // Saranno testate solo le proprietà sull'oggetto di validazione.
    // L'utilizzo di oggetti nidificati richiede che tutte le proprietà siano presenti. Altrimenti
    // la validazione fallirà.
  },
);

// Utilizzo di espressioni regolari per validare le proprietà dell'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, verrà generato un
    // errore.
    name: /^TypeError$/,
    message: /Wrong/,
    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, passerà.
    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 controllate anche quando si utilizza
  // un errore come oggetto di validazione.
  err,
);

Convalida instanceof utilizzando il costruttore:

ESMCJS

import assert from 'node:assert/strict';

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

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

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

Convalida il messaggio di errore utilizzando RegExp:

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

ESMCJS

import assert from 'node:assert/strict';

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

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 convalide interne sono state superate. Altrimenti fallirà con un AssertionError.

ESMCJS

import assert from 'node:assert/strict';

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

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

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

error non può essere una stringa. Se viene fornita una stringa come secondo argomento, si presume che error venga omesso e la stringa verrà invece utilizzata per message. Questo 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:

ESMCJS

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à poiché 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 proveniente da
// errore e poiché non è chiaro se l'utente intendeva effettivamente corrispondere
// rispetto al messaggio di errore, Node.js genera un errore `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

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

// Se si intendeva abbinare il messaggio di errore, fare invece questo:
// Non genera 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]

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à poiché 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 proveniente da
// errore e poiché non è chiaro se l'utente intendeva effettivamente corrispondere
// rispetto al messaggio di errore, Node.js genera un errore `ERR_AMBIGUOUS_ARGUMENT`.
assert.throws(throwingSecond, 'Second');
// TypeError [ERR_AMBIGUOUS_ARGUMENT]

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

// Se si intendeva abbinare il messaggio di errore, fare invece questo:
// Non genera 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 fonte di confusione e soggetta a errori, evitare una stringa come secondo argomento.

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

Aggiunto in: v23.4.0

[Stable: 1 - Experimental]

Stable: 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, non consentendo la coercizione del 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 insieme.

ESMCJS

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

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

Assert ​

Modalità di asserzione strict ​

Modalità di asserzione legacy ​

Classe: assert.AssertionError ​

new assert.AssertionError(options) ​

Classe: assert.CallTracker ​

new assert.CallTracker() ​

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

tracker.getCalls(fn) ​

tracker.report() ​

tracker.reset([fn]) ​

tracker.verify() ​

assert(value[, message]) ​

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

Dettagli del confronto ​

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

Dettagli del confronto ​

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

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

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

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

assert.fail([message]) ​

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

assert.ifError(value) ​

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

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

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

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

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

assert.ok(value[, message]) ​

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

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

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

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

Assert

Modalità di asserzione strict

Modalità di asserzione legacy

Classe: assert.AssertionError

`new assert.AssertionError(options)`

Classe: `assert.CallTracker`

`new assert.CallTracker()`

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

`tracker.getCalls(fn)`

`tracker.report()`

`tracker.reset([fn])`

`tracker.verify()`

`assert(value[, message])`

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

Dettagli del confronto

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

Dettagli del confronto

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

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

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

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

`assert.fail([message])`

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

`assert.ifError(value)`

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

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

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

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

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

`assert.ok(value[, message])`

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

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

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

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