Wie nutzt man einen KI-Assistenten, um Unit Tests für eine bestehende Funktion zu schreiben?

Question

Accepted Answer

Richtig eingesetzt ist ein KI-Assistent hervorragend bei der **Aufzählung** von Testfällen — er brainstormt Edge Cases und schreibt Boilerplate-Code schnell. Aber du musst **überprüfen, dass die Assertions aussagekräftig sind**, denn ein KI-Assistent wird gerne Tests schreiben, die bestehen, ohne etwas zu beweisen.

## Der Workflow

1. **Gib ihm die Funktion plus ihren Vertrag** — was sie tun soll, die Ein-/Ausgabetypen und wie sie ungültige Eingaben handhaben soll. Tests können nicht besser sein als die Spezifikation, die du beschreibst.
2. **Frag explizit nach Edge Cases** — Grenzen (0, leer, Maximum) und Fehlerpfade (null, negativ, falscher Typ), nicht nur den Happy Path.
3. **Überprüfe, dass die Assertions aussagekräftig sind** — ein Test, der das aktuelle Verhalten des Codes behauptet (auch wenn es fehlerhaft ist), ist wertlos. Überprüfe, dass jede Assertion den *beabsichtigten* Vertrag kodiert.

## Beispiel

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

Der KI-Assistent schlug die Grenzfälle (0 und 100) und den Fehlerpfad vor, den du übersehen könntest. Deine Aufgabe ist es, zu bestätigen, dass `toBe(80)` der *korrekte* erwartete Wert ist, nicht nur das, was die Funktion zufällig zurückgibt.

## Warum es wichtig ist

Der schwierige Teil beim Testen besteht nicht darin, die `test(...)` Blöcke zu tippen — es ist **an die Fälle zu denken, die du sonst vergessen würdest**, und ein KI-Assistent ist darin wirklich gut. Aber er hat keine Ahnung, was dein Code *tun soll*, wenn du es ihm nicht sagst, also neigt er dazu, **Tests zu schreiben, die die Implementierung spiegeln** (sie bestehen, aber würden auch bestehen, wenn die Funktion falsch wäre). Den KI-Assistenten als Edge-Case-Generator zu behandeln, während du die Assertions verantwortest, gibt dir umfangreiche Abdeckung und echte Korrektheit — Geschwindigkeit vom KI-Assistenten, Urteilskraft von dir.