Ce sunt testele parametrizate și testele bazate pe date?

Question

Accepted Answer

**Testele parametrizate (bazate pe date)** execută **aceeași logică de test cu mai multe seturi de intrări și ieșiri așteptate** — evitând duplicarea testului pentru fiecare caz. Ele facilitează testarea multor scenarii (inclusiv cazuri limită) într-un mod concis.

## Problema: teste duplicate

```text
Without parameterization, testing many input/output cases means COPYING the test:
  test('add 2+3', () => expect(add(2,3)).toBe(5));
  test('add 0+0', () => expect(add(0,0)).toBe(0));
  test('add -1+1', () => expect(add(-1,1)).toBe(0));
  → lots of near-identical, repetitive tests (tedious, hard to maintain)
```

## Teste parametrizate — un test, multe cazuri

```js
// run the SAME test logic over a TABLE of cases (Jest's test.each)
test.each([
  [2, 3, 5],
  [0, 0, 0],
  [-1, 1, 0],
  [100, 200, 300],
])('add(%i, %i) === %i', (a, b, expected) => {
  expect(add(a, b)).toBe(expected);     // one logic, run per case
});
// → each row is a separate reported test case; add a case = add a row
```

Majoritatea framework-urilor sprijin aceasta (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`).

## Beneficii

```text
✓ CONCISE — test many scenarios without duplicating the test body
✓ Easy to ADD CASES — just add a row of data (great for edge cases / many inputs)
✓ Each case reported SEPARATELY — you see exactly which input failed
✓ Clear, maintainable — the data table documents the cases
→ Ideal for functions with many input/output combinations and edge cases.
```

## De ce contează

Înțelegerea testelor parametrizate (bazate pe date) este valoroasă deoarece facilitează **testarea multor scenarii într-un mod concis**, ceea ce sprijină testarea temeinică (în special a cazurilor limită), deci este cunoaștere practică utilă.

Problema pe care o rezolvă — testarea multor combinații de intrare/ieșire ar necesita altfel **duplicarea testului pentru fiecare caz** (obositor, repetitiv, greu de menținut) — este reală, iar testele parametrizate o rezolvă prin execuția **aceleiași logici de test peste un tabel de cazuri**.

Aceasta face ca testarea multor scenarii să fie **concisă** (un corp de test, multe cazuri), **facilitează adăugarea de cazuri** (doar adaugă un rând de date — ceea ce încurajează testarea mai multor intrări și **cazuri limită**, sprijinind acoperirea temeinică a cazurilor limită care surprinde bug-urile), **raportează fiecare caz separat** (deci vezi exact care intrare a eșuat, ajutând la depanare), și menține testele ușor de menținut (tabelul de date documentează clar cazurile).

Faptul că majoritate framework-urilor sprijin aceasta (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`) o face practic aplicabilă în diverse stive tehnologice.

Testele parametrizate sunt ideale pentru funcții cu multe combinații de intrare/ieșire — obișnuite pentru funcții de utilitate, validatoare, parsere și calcule — unde facilitează testarea gamei complete de cazuri (inclusiv granițe și cazuri limită) fără povara codului de test duplicat.

Acest mod concis și ușor de menținut de a realiza o acoperire largă a intrărilor încurajează testarea mai temeinică.

Deoarece testarea multor scenarii (în special a cazurilor limită) este importantă pentru testarea temeinică și testele parametrizate fac aceasta concisă și ușor de menținut (evitând teste duplicate, încurajând acoperire largă a intrărilor), și pentru că înțelegerea lor și a sprijinului framework-ului este utilă pentru testare eficace, înțelegerea testelor parametrizate și bazate pe date este cunoaștere valoroasă și practic relevantă — o tehnică utilă pentru testarea multor cazuri într-un mod concis, sprijinind acoperirea temeinică a cazurilor limită pe care o cere testarea eficace, și un instrument la îndemână aplicat oriunde funcțiile au multe combinații de intrare/ieșire de verificat.