AssertionError [ERR_ASSERTION]: The error is expected to be an instance of "TypeError". Received "RangeError"
assert.throws(fn, TypeError) a primit o eroare, dar de alt tip decât cel cerut. Mesajul spune tipul așteptat și tipul primit, iar dedesubt mesajul erorii. De obicei verificările din cod sunt în ordinea greșită (întâi intervalul, apoi tipul) sau codul aruncă un Error generic.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Al doilea argument al lui assert.throws (și assert.rejects) poate fi o clasă de eroare: TypeError, RangeError, o clasă proprie ca ValidationError. Testul trece doar dacă eroarea aruncată e instanță a acelei clase. Aici funcția a aruncat, dar o eroare de alt tip.
Mesajul are trei părți: tipul așteptat ("TypeError"), cel primit ("RangeError") și, după Error message:, mesajul erorii primite. Din ultimul vezi ce ramură a codului a rulat de fapt.
Cauza tipică: validările sunt în ordinea greșită. Pentru valoarea "-5" (text), o comparație p < 0 convertește textul în număr și dă true, așa că se aruncă RangeError înainte să ajungă verificarea de tip. Alte cauze: codul aruncă new Error(...) generic, iar testul cere o clasă specifică, sau clasa e importată din alt modul decât cel care o aruncă.
De ce apare: cauzele frecvente
1Verificarea de tip după cea de interval
if (pret < 0) throw new RangeError("Prețul nu poate fi negativ");
if (typeof pret !== "number") throw new TypeError("Prețul trebuie să fie număr");if (typeof pret !== "number") throw new TypeError("Prețul trebuie să fie număr");
if (pret < 0) throw new RangeError("Prețul nu poate fi negativ");Comparația "-5" < 0 convertește textul în număr. Verificând întâi tipul, textul e oprit înainte de orice comparație.
2Codul aruncă Error generic
throw new Error("Email invalid");
// testul: assert.throws(fn, ValidationError)class ValidationError extends Error {}
throw new ValidationError("Email invalid");Testul poate verifica tipul doar dacă eroarea are tipul respectiv. Clasele proprii fac tratarea erorilor mai precisă și în aplicație.
3Tu vrei de fapt să verifici mesajul
assert.throws(() => valideaza(""), TypeError);assert.throws(() => valideaza(""), { name: "RangeError", message: /gol/ });Cu un obiect poți verifica și numele, și mesajul. Alege verificarea care exprimă regula reală.
Repară eroarea, direct în pagină
Testul „respinge prețul trimis ca text” pică cu AssertionError [ERR_ASSERTION]: The error is expected to be an instance of "TypeError". Received "RangeError", pentru că valoarea "-5" ajunge întâi la verificarea de interval. Reordonează verificările din valideazaPret, ca toate cele trei teste să treacă.
const assert = require("assert");
function test(nume, fn) {
try {
fn();
console.log(`ok - ${nume}`);
} catch (err) {
console.log(`FAIL - ${nume}`);
console.error(err.message);
process.exitCode = 1;
}
}
function valideazaPret(pret) {
if (pret < 0) throw new RangeError("Prețul nu poate fi negativ");
if (typeof pret !== "number") throw new TypeError("Prețul trebuie să fie număr");
return pret;
}
test("acceptă un preț valid", () => assert.strictEqual(valideazaPret(42), 42));
test("respinge prețul negativ", () => assert.throws(() => valideazaPret(-5), RangeError));
test("respinge prețul trimis ca text", () => assert.throws(() => valideazaPret("-5"), TypeError));ok - acceptă un preț valid ok - respinge prețul negativ ok - respinge prețul trimis ca text
Indiciu
Verificarea cu typeof trebuie să ruleze înaintea comparației cu 0.
Reparația
const assert = require("assert");
function test(nume, fn) {
try {
fn();
console.log(`ok - ${nume}`);
} catch (err) {
console.log(`FAIL - ${nume}`);
console.error(err.message);
process.exitCode = 1;
}
}
function valideazaPret(pret) {
if (typeof pret !== "number") throw new TypeError("Prețul trebuie să fie număr");
if (pret < 0) throw new RangeError("Prețul nu poate fi negativ");
return pret;
}
test("acceptă un preț valid", () => assert.strictEqual(valideazaPret(42), 42));
test("respinge prețul negativ", () => assert.throws(() => valideazaPret(-5), RangeError));
test("respinge prețul trimis ca text", () => assert.throws(() => valideazaPret("-5"), TypeError));De ce merge
Comparația "-5" < 0 convertește textul în numărul -5 și dă true, așa că funcția arunca RangeError pentru o valoare care de fapt avea tipul greșit. Cu verificarea typeof prima, orice text e oprit cu TypeError înainte de comparație, iar numerele negative ajung în continuare la RangeError. Ordinea corectă e întotdeauna: tipul întâi, intervalul după.
Alte forme ale mesajului
AssertionError [ERR_ASSERTION]: The error is expected to be an instance of "TypeError". Received "RangeError" Error message: Prețul nu poate fi negativAssertionError [ERR_ASSERTION]: The error is expected to be an instance of "ValidationError". Received "Error"AssertionError [ERR_ASSERTION]: The error is expected to be an instance of "NotFoundError". Received "TypeError"
Cum o eviți pe viitor
- Validează în ordinea: există valoarea, are tipul corect, e în interval.
- Folosește clase de eroare diferite pentru situații diferite și testează-le explicit.
- Testează cu date „murdare”, așa cum vin din formulare și JSON (texte în loc de numere, spații, valori goale).
Întrebări frecvente
De ce "-5" < 0 e adevărat?
Operatorii < și > convertesc textul în număr când celălalt operand e număr. "-5" devine -5, deci comparația reușește, deși valoarea nu e un număr.
Pot cere mai multe tipuri de eroare acceptate?
Da, cu o funcție de validare: assert.throws(fn, (err) => err instanceof TypeError || err instanceof RangeError). Funcția trebuie să întoarcă true.
Erori înrudite
AssertionError [ERR_ASSERTION]: Missing expected exception. assert.throws() aștepta ca funcția să arunce o eroare, dar funcția a rulat fără eroare. Ori codul testat are un bug (validarea lipsește sau e greșită), ori funcția e async și întoarce o promisiune respinsă, caz în care trebuie await assert.rejects(). AssertionError [ERR_ASSERTION]: Got unwanted exception.
Actual message: "Cantitate invalidă: 100" assert.doesNotThrow(fn) a picat pentru că fn a aruncat o eroare, deși testul spunea că nu trebuie. Mesajul de după Actual message e eroarea aruncată de codul tău: pornește de la ea. De obicei e o condiție de validare greșită la limită (< în loc de <=). AssertionError [ERR_ASSERTION]: The input did not match the regular expression /^RO\d{2}[A-Z]{4}/. Input: assert.match(text, regex) a pică: textul primit nu se potrivește cu expresia regulată. Sub mesaj vezi exact textul (Input). Compară-l cu modelul: de obicei e o diferență de litere mari/mici, un spațiu în plus sau un format greșit produs de cod. Învață Node.js de la zero, cu exerciții la fiecare lecție
Curs Node.js: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
