Hvad er mutation testing?

Question

Accepted Answer

**Mutation testing** evaluerer **kvaliteten af en testsuite** ved bevidst at introducere små bugs ("mutanter") i koden og kontrollere, om testene **opdager dem**. Det måler, hvor gode tests faktisk er til at detektere fejl — langt ud over coverage, som kun måler udførelse.

## Hvordan mutation testing fungerer

```text
1. A tool makes small changes (MUTATIONS) to the code, e.g.:
   → change + to -, > to >=, true to false, remove a statement, change a constant
   → each mutation = a deliberate "bug" (a MUTANT version of the code)
2. Run the TEST SUITE against each mutant:
   → tests FAIL → the mutant is "KILLED" (good — tests caught the bug) ✓
   → tests PASS → the mutant "SURVIVED" (bad — tests DIDN'T catch the bug) ✗
3. MUTATION SCORE = % of mutants killed → measures how good the tests are at catching bugs
```

## Hvorfor det er bedre end coverage

```text
COVERAGE → measures if code was EXECUTED (not if behavior was verified) → can be high with
  weak tests (no real assertions)
MUTATION TESTING → measures if tests actually DETECT bugs (changes in behavior):
  → a surviving mutant reveals a GAP — tests execute that code but don't verify it well
    (weak/missing assertions, untested behavior)
→ A much stronger signal of TEST QUALITY than coverage.
```

## Overvejelser

```text
✓ Reveals weak tests (high coverage but surviving mutants = false confidence)
⚠️ COMPUTATIONALLY EXPENSIVE (runs the suite many times — once per mutant) → slow
⚠️ "Equivalent mutants" (mutations that don't change behavior) → false survivors to ignore
→ Tools: Stryker (JS), PIT (Java), mutmut (Python). Use on critical code; run periodically.
```

## Hvorfor det betyder noget

At forstå mutation testing er værdifuld viden på seniorplan, fordi det giver et **meget stærkere mål for testkvalitet end coverage**, og adresserer coverings vigtigste svaghed, så det er nyttigt til at evaluere og forbedre testsuites.

Den grundlæggende indsigt er, at **coverage måler udførelse, ikke verifikation** — kode kan være "dækket" (udført) af tests, der faktisk ikke verificerer dens adfærd (svage eller manglende assertions), hvilket giver falsk sikkerhed. **Mutation testing** adresserer dette ved at måle, om tests faktisk **detekterer bugs**: det introducerer små bevidste bugs (mutanter) i koden og kontrollerer, om testene opdager dem (en mutant "dræbt" af fejlende tests er godt; en "overlevende" mutant betyder, at testene ikke opfangede den bug).

**Mutationsscore** (procentdelen af mutanter dræbt) er et langt stærkere tegn på testkvalitet end coverage, fordi det afslører, om tests faktisk verificerer adfærd — en **overlevende mutant afslører et reelt hul** (tests udfører koden men verificerer den ikke godt, f.eks. svage assertions eller utestet adfærd), som coverage ville gå glip af.

At forstå dette — at mutation testing afslører svage tests skjult bag høj coverage — er nøgleværdien, og adresserer begrænsningen i, at høj coverage ikke garanterer gode tests.

At forstå **overvejelserne** — at det er **beregningsmæssigt dyrt** (at køre suiten én gang per mutant, hvilket gør det langsomt), at "ækvivalente mutanter" (mutationer, der ikke ændrer adfærd) er falske overlevende, som skal ignoreres, og at værktøjer findes (Stryker, PIT, mutmut) — afspejler praktisk bevidsthed om hvornår og hvordan man bruger det (på kritisk kode, periodisk, i stedet for konstant).

Fordi testkvalitet virkelig betyder noget (coverage alene kan give falsk sikkerhed) og mutation testing giver et meget stærkere mål ved at kontrollere, om tests faktisk opfanger bugs, og fordi det at forstå det, dets fordel frem for coverage, og dets praktiske overvejelser er nyttigt til virkelig at evaluere og forbedre testsuites, er forståelse af mutation testing værdifuld viden på seniorplan — en sofistikeret teknik til at måle reel testkvalitet, adresserer coverings vigtigste svaghed, og afspejler den dybere forståelse af testeffektivitet, der forventes for seniorrollen, som er bekymret med ægte testkvalitet, ikke kun coverage-tal.