Hur använder du en AI-assistent för att skriva enhetstester för en befintlig funktion?

Question

Accepted Answer

Om den används väl är AI utmärkt på **uppräkningen** av testning — den brainstormar kantfall och skriver snabbt standard kod. Men du måste **verifiera att påståendena är meningsfulla**, för AI kommer gärna att skriva tester som godkänns utan att bevisa något.

## Arbetsflödet

1. **Ge den funktionen plus dess kontrakt** — vad den ska göra, in-/utmatningstyper och hur den ska hantera ogiltig inmatning. Tester kan inte vara bättre än den specifikation du beskriver.
2. **Be uttryckligen om kantfall** — gränser (0, tom, max) och felvägar (null, negativ, fel typ), inte bara den lyckliga vägen.
3. **Verifiera att påståendena är meningsfulla** — ett test som hävdar kodens aktuella beteende (även om det är felaktigt) är värdelöst. Kontrollera att varje påstående kodifierar det *avsedda* kontraktet.

## Exempel

```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 föreslog kantfallen (0 och 100) och felvägen som du kanske skulle glömma. Din uppgift är att bekräfta att `toBe(80)` är det *korrekta* förväntade värdet, inte bara vad funktionen råkar returnera.

## Varför det spelar roll

Den svåra delen av testning är inte att skriva `test(...)`-blocken — det är **att tänka på de fall du annars skulle missa**, och AI är genuint bra på denna bredd. Men den har ingen aning om vad din kod *ska* göra om du inte säger det, så utan övervakning tenderar den att skriva **tester som speglar implementeringen** (de godkänns, men skulle godkännas även om funktionen var fel). Genom att behandla AI som en kantfallsgenerator medan du äger påståendena får du bred täckning och verklig korrekthet — hastighet från AI, omdöme från dig.