assert (node:assert/strict) în Node.js

import assert from "node:assert/strict";
assert.equal(actual, asteptat)
assert.deepEqual(actual, asteptat)
assert.throws(fn, [eroare])
await assert.rejects(promisiune, [eroare])

Ce face assert (node:assert/strict)

Modulul node:assert are funcții care verifică o condiție și aruncă AssertionError dacă nu este îndeplinită. Le folosești în teste și, uneori, în cod, pentru situații care nu ar trebui să apară niciodată.

Importă varianta strictă, node:assert/strict: acolo equal compară cu === și deepEqual compară profund, inclusiv tipurile. În varianta veche, nestrictă, equal folosește == (deci "5" este egal cu 5) și este marcată ca moștenire (legacy).

Funcții principale: ok(valoare), equal / notEqual, deepEqual (obiecte și tablouri), partialDeepStrictEqual (doar proprietățile din valoarea așteptată, stabil din 22.17 / 24.0), match(text, regex), throws(fn) și rejects(promisiune) pentru erori. Mesajul erorii arată diferența dintre valori.

Parametri

Parametru	Descriere
ok(valoare, [mesaj])	Valoarea trebuie să fie adevărată.
equal / notEqual	Comparație cu === (în modul strict).
deepEqual / notDeepEqual	Comparație profundă a obiectelor și tablourilor.
throws(fn, [așteptat])	Funcția trebuie să arunce; așteptat poate fi clasă, regex sau obiect.
rejects(promisiune, [așteptat])	Promisiunea trebuie respinsă (se folosește cu await).
match(text, regex)	Textul trebuie să se potrivească.

Ce returnează

Nimic (undefined) dacă verificarea trece; altfel aruncă AssertionError.

Exemple

Exemplul 1: Verificări care trec

import assert from "node:assert/strict";

const elev = { nume: "Ana", oras: "Iași", note: [9, 10], email: "ana@exemplu.ro" };

assert.ok(elev.note.length > 0);
assert.equal(elev.nume, "Ana");
assert.deepEqual(elev.note, [9, 10]);
assert.partialDeepStrictEqual(elev, { oras: "Iași", note: [9, 10] });
assert.match(elev.email, /@exemplu\.ro$/);
assert.throws(() => JSON.parse("{greșit"), SyntaxError);
await assert.rejects(Promise.reject(new Error("timeout")), /timeout/);

console.log("Toate verificările au trecut.");

Rezultat

Toate verificările au trecut.

Exemplul 2: Ce arată o verificare care pică

import assert from "node:assert/strict";

try {
  assert.deepEqual({ nume: "Ion", nota: 7 }, { nume: "Ion", nota: 8 });
} catch (eroare) {
  console.log(eroare.name, eroare.code);
  console.log(eroare.message);
}

Rezultat

AssertionError ERR_ASSERTION
Expected values to be strictly deep-equal:
+ actual - expected

  {
+   nota: 7,
-   nota: 8,
    nume: 'Ion'
  }

Exemplul 3: Strict față de nestrict

import assertVechi from "node:assert";
import assert from "node:assert/strict";

assertVechi.equal("5", 5);          // trece: compară cu ==
console.log("assert vechi: trece");

try {
  assert.equal("5", 5);
} catch (eroare) {
  console.log("assert/strict:", eroare.message.split("\n")[0]);
}

Rezultat

assert vechi: trece
assert/strict: Expected values to be strictly equal:

Greșeli frecvente

• Importi node:assert fără /strict: equal și deepEqual folosesc == și acceptă valori de tipuri diferite.
• Scrii assert.throws(fn()): funcția este apelată înainte de verificare și eroarea scapă. Dă funcția, nu rezultatul: assert.throws(() => fn()).
• Folosești equal pentru obiecte sau tablouri: două obiecte diferite nu sunt niciodată ===. Folosește deepEqual.

Comenzi înrudite

• node --test (node:test): Rulează testele automate cu testerul inclus în Node.js: test, describe, it, fără Jest sau Mocha.
• util.inspect / util.format: Transformă orice valoare în text lizibil, ca console.log (inspect), și formatează șiruri cu %s, %d, %o (format).