Hoe gebruikt u een AI-assistent om unit tests voor een bestaande functie te schrijven?

Question

Accepted Answer

Goed gebruikt is een AI uitstekend in het **opsommings**gedeelte van testen — het brainstormt randgevallen en schrijft de boilerplate snel. Maar u moet **verifiëren dat de assertions zinvol zijn**, omdat een AI graag tests schrijft die slagen zonder iets te bewijzen.

## Waarom het belangrijk is

1. **Geef het de functie plus zijn contract** — wat het moet doen, de input-/outputtypen en hoe het ongeldige invoer moet afhandelen. Tests kunnen niet beter zijn dan de specificatie die u beschrijft.
2. **Vraag expliciet om randgevallen** — grenzen (0, leeg, max) en foutpaden (null, negatief, verkeerd type), niet alleen het happy path.
3. **Verifiëer dat de assertions zinvol zijn** — een test die het huidige gedrag van de code beweert (zelfs als het buggy is) is waardeloos. Controleer of elke assertion het *beoogde* contract codeert.

## Voorbeeld

```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
});
```

De AI stelde de randgevallen (0 en 100) en het foutpad voor dat u zou kunnen vergeten. Uw taak is om te bevestigen dat `toBe(80)` de *juiste* verwachte waarde is, niet gewoon wat de functie toevallig retourneert.

## Waarom het belangrijk is

Het moeilijke gedeelte van testen is niet het typen van de `test(...)`-blokken — het is **nadenken over de gevallen die u anders zou missen**, en een AI is daar echt goed in. Maar het weet niet wat uw code *zou moeten* doen tenzij u het zegt, dus zonder toezicht schrijft het **tests die de implementatie spiegelen** (ze slagen, maar ze zouden slagen zelfs als de functie fout zou zijn). Als u de AI als edge-case-generator behandelt terwijl u eigenaar bent van de assertions, krijgt u brede dekking en echte correctheid — snelheid van de AI, oordeel van u.