Cum folosești un asistent AI pentru a scrie teste unitare pentru o funcție existentă?

Question

Accepted Answer

Folosit bine, un AI este excelent în partea de **enumerare** a testării — face brainstorming al cazurilor limită și scrie boilerplate rapid. Dar trebuie să **verifici că afirmațiile sunt semnificative**, pentru că un AI va scrie cu plăcere teste care trec fără a dovedi nimic.

## Fluxul de lucru

1. **Dai-i funcția plus contractul ei** — ce ar trebui să facă, tipurile de intrare/ieșire și cum ar trebui să gestioneze intrarea invalidă. Testele nu pot fi mai bune decât specificația pe care o descrii.
2. **Cere explicit cazuri limită** — limite (0, gol, max) și căi de eroare (null, negativ, tip greșit), nu doar calea norocoasă.
3. **Verifică că afirmațiile sunt semnificative** — un test care afirmă comportamentul curent al codului (chiar dacă are buguri) este inutil. Verifică că fiecare afirmație codifică contractul *intenționat*.

## De ce este important

```js
// Function under test, with its contract:
// applyDiscount(price, percent) -> price reduced by percent.
// Contract: percent must be 0..100; throws RangeError otherwise. price >= 0.
function applyDiscount(price, percent) {
  if (percent < 0 || percent > 100) throw new RangeError('percent out of range');
  return price - (price * percent) / 100;
}
```

```js
// AI-suggested test cases (Jest) — note the edge and error paths, not just happy path:
test('applies a normal discount', () => {
  expect(applyDiscount(100, 20)).toBe(80);       // happy path
});
test('0% leaves price unchanged', () => {
  expect(applyDiscount(100, 0)).toBe(100);       // boundary: lower edge
});
test('100% makes it free', () => {
  expect(applyDiscount(100, 100)).toBe(0);       // boundary: upper edge
});
test('rejects percent above 100', () => {
  expect(() => applyDiscount(100, 150)).toThrow(RangeError); // error path
});
```

AI a propus cazurile limită (0 și 100) și calea de eroare pe care ai putea să o uiți. Sarcina ta este să confirmi că `toBe(80)` este valoarea așteptată *corectă*, nu doar ceea ce returnează funcția.

## De ce este important

Parte dificilă a testării nu este dactilografierea blocurilor `test(...)` — este **gândirea la cazuri pe care altfel le-ai rata**, și un AI este cu adevărat bun la asta. Dar nu știe ce *ar trebui* să facă codul tău dacă nu-i spui, deci fără supraveghere are tendința de a scrie **teste care oglindesc implementarea** (trec, dar ar trece chiar dacă funcția ar fi greșită). Tratând AI ca un generator de cazuri limită în timp ce deții afirmațiile, obții acoperire largă și corectitudine reală — viteză de la AI, judecată de la tine.