Error: expect(received).toBeCloseTo(expected, precision)
Numărul primit nu e destul de aproape de cel așteptat pentru precizia cerută. toBeCloseTo(x, n) acceptă o diferență sub 10^-n / 2. Cu precizie prea mare, o rotunjire la bani pică; cu valori chiar diferite, problema e calculul. Alege precizia potrivită (2 pentru bani) sau verifică formula.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
toBeCloseTo(asteptat, precizie) e soluția pentru comparațiile cu numere zecimale, unde toBe pică din cauza reprezentării în virgulă mobilă (0.1 + 0.2 dă 0.30000000000000004). Trece dacă |primit - asteptat| < 10^-precizie / 2; implicit, precizia e 2 (diferență sub 0,005). Raportul arată Expected, Received și Expected precision, iar în Jest și diferența.
Când pică, compară diferența cu precizia:
- o diferență mică (
24.1879vs24.19) cu precizie 3 sau 4: testul cere mai multe zecimale decât are rezultatul rotunjit. Pentru bani, precizia 2 e cea potrivită; - o diferență mare (
24.19vs23.79): calculul e greșit (cota, cantitatea, discountul), iartoBeCloseToși-a făcut treaba.
Atenție și la sens: al doilea argument e numărul de zecimale, nu toleranța (toBeCloseTo(24.19, 0.01) nu înseamnă „±0,01”).
De ce apare: cauzele frecvente
1Precizie mai mare decât rotunjirea
expect(pretCuTva(19.99, 0.21)).toBeCloseTo(24.19, 3); // 24.1879expect(pretCuTva(19.99, 0.21)).toBeCloseTo(24.19, 2);Diferența e 0,0021: sub 0,005 (precizie 2), dar peste 0,0005 (precizie 3).
2toBe pe un rezultat zecimal
expect(0.1 + 0.2).toBe(0.3);expect(0.1 + 0.2).toBeCloseTo(0.3);Rezultatul exact e 0.30000000000000004. toBeCloseTo acceptă diferența de reprezentare.
3Toleranța dată ca al doilea argument
expect(total).toBeCloseTo(258, 0.01);expect(total).toBeCloseTo(258, 2);Al doilea argument e numărul de zecimale. 0.01 dă o precizie care nu are sens.
Repară eroarea, direct în pagină
Testul prețul cu TVA pică cu toBeCloseTo(expected, precision): pretCuTva(19.99, 0.21) dă 24.1879, iar testul cere 3 zecimale față de 24.19. Prețurile se afișează în lei cu 2 zecimale. Repară precizia aserțiunii, apoi afișează rezultatul rotunjit la 2 zecimale.
import { test, expect } from '@playwright/test';
function pretCuTva(pret, cota) {
return pret * (1 + cota);
}
test('prețul cu TVA', async () => {
const rezultat = pretCuTva(19.99, 0.21);
expect(rezultat).toBeCloseTo(24.19, 3);
console.log(rezultat.toFixed(2));
});Indiciu
Cu câte zecimale lucrezi când e vorba de lei?
Reparația
import { test, expect } from '@playwright/test';
function pretCuTva(pret, cota) {
return pret * (1 + cota);
}
test('prețul cu TVA', async () => {
const rezultat = pretCuTva(19.99, 0.21);
expect(rezultat).toBeCloseTo(24.19, 2);
console.log(rezultat.toFixed(2));
});De ce merge
toBeCloseTo(24.19, 3) cerea o diferență sub 0,0005, dar rezultatul nerotunjit, 24.1879, e la 0,0021 de 24.19. Pentru sume în lei contează 2 zecimale: cu precizia 2, diferența acceptată e sub 0,005, iar testul trece. toFixed(2) arată valoarea cum ar apărea pe bon.
Alte forme ale mesajului
Error: expect(received).toBeCloseTo(expected, precision) Expected: 24.19 Received: 24.1879 Expected precision: 3 Expected difference: < 0.0005 Received difference: 0.0021Error: expect(received).not.toBeCloseTo(expected, precision)Error: expect(received).toBeCloseTo(expected)
Cum o eviți pe viitor
- Pentru bani, calculează în bani (numere întregi) sau rotunjește explicit:
Math.round(x * 100) / 100. - Folosește
toBeCloseTo(x, 2)pentru sume în lei și păstrează precizia implicită dacă nu ai motiv. - Când diferența e mare, nu mări toleranța: verifică formula.
Întrebări frecvente
De ce 0.1 + 0.2 nu dă 0.3?
Fiindcă numerele zecimale se reprezintă în binar aproximativ. Asta e valabil în aproape toate limbajele, nu doar în JavaScript.
Pot compara bani cu toBe?
Da, dacă lucrezi în bani (întregi): expect(totalBani).toBe(25800). Așa face și API-ul ShopRapid, care întoarce prețurile în bani.
Erori înrudite
Error: expect(received).toBe(expected) // Object.is equality Valoarea comparată cu toBe nu e identică cu cea așteptată. În testele Playwright cauza tipică e un await lipsă (Received: Promise {}) sau o valoare citită prea devreme cu textContent()/count(). Folosește aserțiunile pe locator, care așteaptă: await expect(locator).toHaveText('1'). Error: expect(received).toBeGreaterThan(expected) Valoarea primită nu e mai mare decât pragul. Când Received e NaN, problema e conversia: Number('3.499,00') dă NaN, fiindcă prețurile românești au punct la mii și virgulă zecimală. Curăță textul înainte de conversie (scoate punctele, virgula devine punct) sau compară valori deja numerice, din API. Error: expect(received).toEqual(expected) // deep equality Obiectul sau lista primită diferă de cea așteptată: alt element, altă ordine, un spațiu în plus sau un tip diferit ("3" față de 3). Compară liniile Expected și Received din raport și corectează valoarea așteptată sau transformă datele (sortare, trim, Number) înainte de comparație. Învață Testare automată de la zero, cu exerciții la fiecare lecție
Curs Test Automation (Playwright și Selenium): lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 20 lecții sunt gratuite.
