{"canonical_url":"https://engineer.company/da/glossary/test-driven-development/","content_markdown":"# Testdrevet udvikling\n\n## Hvad det er\n\nTestdrevet udvikling er en måde at programmere på, hvor testen for et stykke\nadfærd skrives før den kode, der leverer adfærden, én lille test ad gangen. Kent\nBeck, der selv kalder sin andel i metoden en genopdagelse, beskriver den som en\narbejdsgang for programmører. I 2023 havde han erfaret, at folk ikke var enige\nom, hvad begrebet dækker, så han skrev arbejdsgangen ned i et kort indlæg med\ntitlen Canon TDD. Her bruger han næsten overalt forkortelsen TDD, af det\nengelske test-driven development.\n\nArbejdsgangen har fem trin:\n\n1. Skriv en liste over de testscenarier, du vil dække.\n2. Gør præcis ét punkt på listen til en konkret test, der kan køres.\n3. Ret koden, så denne test og alle de tidligere går igennem, og føj nye punkter\n   til listen, når du opdager dem.\n4. Forbedr eventuelt implementeringens design ved at refaktorere.\n5. Vend tilbage til trin 2, så længe der står punkter på listen.\n\nListen er analyse, men af adfærd og ikke af design: først grundtilfældet, så\nvariationerne og til sidst de måder, ændringen ikke må ødelægge det, der\nallerede virker. Testen fra trin 2 er en rigtig automatiseret test med\nopsætning, et kald og assertions, og den fejler første gang, den kører, fordi\nden adfærd, den beskriver, først skal skrives. Beck kalder trin 3 at gå fra rød\ntil grøn, altså fra en test, der fejler, til en, der består.\n\nDet er lige så nyttigt at vide, hvad arbejdsgangen ikke er. At skrive alle\ntests, før man skriver en eneste linje kode, er en hyppig klage over TDD, og\nBeck svarer direkte: Det er ikke TDD, og den, der kritiserer det, kritiserer\nnoget andet. Den modsatte vej er han afslappet. Et team, der arbejder anderledes\nog får gode resultater, må gerne fortsætte, og som han skriver, er der ingen\nguldstjerne for at følge trinene til punkt og prikke.\n\n## Hvorfor det betyder noget\n\nBeck skriver selv, hvad arbejdsgangen skal føre til. En programmør, der ændrer\net systems adfærd, skal ende med et system, hvor alt, hvad der virkede før,\nstadig virker, den nye adfærd virker som forventet, koden er klar til den næste\nændring, og programmøren og kollegerne er trygge ved alle tre dele. Fordi hver\ntest skrives, mens ændringen er lille og frisk i hukommelsen, vokser\nsikkerhedsnettet i samme tempo som koden i stedet for at blive lovet til senere.\n\nDet andet argument er design. Beck skelner mellem to slags designbeslutninger:\nhvordan et stykke adfærd kaldes, og hvordan systemet implementerer det. Når\ntesten skrives først, tvinger den beslutningerne om grænsefladen frem, for\ntesten skal kalde noget og sige, hvad der kommer tilbage. Beslutningerne om\nimplementeringen venter til refaktoreringstrinnet, hvor beståede tests beskytter\ndem. En test, der er besværlig at skrive, er et tidligt varsel om, at\ngrænsefladen bliver besværlig at bruge.\n\nDet tredje argument er dobbelttjekket. Den forventede værdi i en test regner et\nmenneske ud fra kravet, og koden når frem til den ad en anden vej. Når de to\ngiver det samme, er to uafhængige veje kommet frem til ét svar, og ifølge Beck\ner det netop dobbelttjekket, der giver TDD en stor del af dets værdi som\nkontrol.\n\nEndelig giver arbejdsgangen et signal om, hvornår man er færdig. Becks råd er at\nblive ved med at teste og kode, indtil frygten for, hvordan koden opfører sig,\ner blevet til kedsomhed. Vanen er meget ældre end indlægget. Beck placerer sin\ngenopdagelse mellem 1994, hvor han skrev SUnit til en konsulentkunde, og oktober\n1995, hvor han viste TDD frem for Ward Cunningham på OOPSLA-konferencen i\nAustin. Hans artikel Simple Smalltalk Testing beskriver et enkelt testframework\ntil Smalltalk, og Pythons dokumentation af unittest henviser stadig til den som\nBecks oprindelige artikel om det mønster, unittest deler.\n\n## Sådan ser det ud i praksis\n\nForestil dig et tjek, der skal finde forbudte buzzwords i teksterne på et\nwebsite. Arbejdet begynder med testlisten, skrevet som almindelige noter:\n\n```text\n- et forbudt ord bliver rapporteret\n- et forbudt ord med stort begyndelsesbogstav bliver rapporteret\n```\n\nTrin 2 gør præcis ét punkt til en test. Det første punkt står først af en grund: Det giver tjekket et kendt forbudt ord og kontrollerer, at ordet bliver rapporteret. Testen fejler, indtil tjekket kan finde det. Testen lægges i en fil ved navn\n`test_wording.py`, som pytest samler op, fordi navnet har formen `test_*.py`:\n\n```python\nfrom wording import find_banned\n\n\ndef test_reports_a_banned_word():\n    assert find_banned(\"we leverage it\", {\"leverage\"}) == [\"leverage\"]\n```\n\nKører man `pytest -q`, fejler testen straks, fordi importen af `find_banned`\nmislykkes. Den fejl er hele pointen: Man har set testen fejle, så når den senere\nbestår, betyder det noget. Den enkleste kode, der får den til at bestå, er nok\nfor nu, i `wording.py`:\n\n```python\ndef find_banned(text, banned):\n    return [word for word in text.split() if word in banned]\n```\n\nTesten består. Det næste punkt bliver den næste test:\n\n```python\ndef test_reports_a_capitalised_banned_word():\n    assert find_banned(\"Leverage it\", {\"leverage\"}) == [\"Leverage\"]\n```\n\nDen fejler, og fordi pytest viser mellemværdierne i en assertion, kan man i\noutputtet se en tom liste, hvor `[\"Leverage\"]` var forventet. At sammenligne\n`word.lower()` i stedet for `word` får den til at bestå. Undervejs opdager\nprogrammøren, at `text.split()` lader tegnsætningen hænge ved ordet, så\n»leverage,« med komma ville slippe igennem. Det kommer på listen og ikke ind i\nkoden, og det bliver den tredje test:\n\n```python\ndef test_reports_a_banned_word_before_a_comma():\n    assert find_banned(\"Use it, leverage, win\", {\"leverage\"}) == [\"leverage\"]\n```\n\nDen fejler, og én linje mere får alle tre til at bestå:\n\n```python\ndef find_banned(text, banned):\n    words = [word.strip(\".,;:!?\") for word in text.split()]\n    return [word for word in words if word.lower() in banned]\n```\n\nTrin 4 er valgfrit, og her er der ikke meget at forbedre: to linjer med hver sin\nopgave. Hvert punkt på listen har nu en test, der består, så arbejdet er gjort.\nDe forventede værdier i testene er alle skrevet ud fra punktet på listen og\naldrig kopieret fra en kørsel.\n\nRækkefølgen på listen var ikke tilfældig, og sitets egen fortegnelse viser\nhvorfor. Et\n[projekt, der skrev tests af selve tjekkene](/da/portfolio/wrote-tests-for-the-checkers-themselves/),\narbejde udført i august 2026, fastslog, at projektets specialbyggede tjek,\nblandt dem en stavekontrol, et tjek af grammatisk person og et tjek af taloverensstemmelse,\nhavde kørt grønt i månedsvis, og at et tjek, der kun har set rene inddata, ikke\nkan skelnes fra et tjek, der slet intet læser. Løsningen var at plante netop den\ndefekt, hvert tjek findes for at fange: Stavekontrollen fodres med et bevidst\nfejlstavet ord, og testen fejler, hvis kørslen kommer rent tilbage,\ntjekket af grammatisk person fodres med prosa i første person og skal afvise den, og\nbuzzword-tjekket fodres med et forbudt ord. To af tjekkene viste sig at læse et\nsnævrere sæt filer, end deres dokumentation påstod. Siden beskriver ikke TDD,\nmen dens pointe er den, TDD bygger ind fra første trin: En test er først noget\nværd, når man har set den fejle.\n\n## Hvor det går galt\n\n**Alle tests skrives først.** At gøre hvert punkt på listen til en test, før en\neneste af dem består, er den misforståelse, Beck fremhæver. Når den første test\ntvinger en til at tænke om, skal alle de spekulative tests laves om, og en\nprogrammør, der er nået til test nummer seks uden at have set noget bestå,\nrammes ifølge Beck af nedtrykthed eller kedsomhed. Skriv én test, få den til at\nbestå, og vælg så den næste. Viser en ny test, at det hidtidige arbejde ikke kan\nklare et tilfælde, må man beslutte, om man skal fortsætte eller starte forfra;\nBecks råd er at starte forfra og vælge en anden rækkefølge.\n\n**Testen har ingen assertion.** En test, der kalder koden og intet tjekker,\nhæver dækningsgraden og beviser intet. Hver test skal have opsætning, et kald og\nen assertion, og Beck foreslår en gang imellem at skrive en test baglæns,\nbegyndende med dens assertions.\n\n**Assertionen slettes.** Når en test nægter at bestå, er det fristende at slette\ndens assertion, så testen lader, som om den består. Få den til at bestå for\nalvor, eller send punktet tilbage på listen, og tænk rækkefølgen om.\n\n**Forventede værdier kopieres fra outputtet.** At køre koden, kopiere det, den\nreturnerede, og indsætte det i testen gør et dobbelttjek til et enkelt tjek:\nTesten bekræfter nu kun, at koden gør det, den gjorde. Regn den forventede værdi\nud fra kravet, i hånden om nødvendigt.\n\n**Refaktorering, mens testen skal bestå.** At ændre struktur og adfærd i samme\ntrin er det, Beck kalder at have to hatte på. Få det til at køre, og gør det så\nrigtigt: Nå grønt med den enkleste ændring, og ryd først op, når testene består.\n\n**For meget oprydning, eller abstraktion for tidligt.** Det føles godt at rydde\nop, og det kan føles tryggere end at tage fat på den næste test. Stop, når koden\ner god nok til denne arbejdsomgang, og lad to stykker kode, der ligner hinanden,\nvære, indtil mønsteret er tydeligt. Becks formulering er kort: »Duplikering er\net fingerpeg, ikke en ordre.«\n\n**Testene kender implementeringen.** Tests, der kalder private metoder eller\ntjekker, hvilke kald koden foretog, i stedet for hvad den gav som resultat, går\ni stykker, hver gang det indre ændres. Erik Kuefler kalder dem skrøbelige tests\ni sit kapitel om enhedstest i _Software Engineering at Google_: De fejler ved en\nændring, der intet har med dem at gøre og ikke indfører nogen reel fejl. I TDD\nkoster det dobbelt, for refaktoreringstrinnet forudsætter tests, der forbliver\ngrønne, mens det indre flytter sig. Test gennem den offentlige grænseflade, tjek\nden tilstand, koden efterlader, frem for samspillet, og navngiv hver test efter\nden adfærd, den tjekker.\n\n## Læs mere\n\n- [Canon TDD](https://newsletter.kentbeck.com/p/canon-tdd)\n  — Kent Becks egen beskrivelse af arbejdsgangen fra 2023: de fem trin, skellet\n  mellem design af grænseflade og af implementering og fejlene ved hvert trin.\n- [Simple Smalltalk Testing: With Patterns](https://web.archive.org/web/20150315073817/http://www.xprogramming.com/testfram.htm)\n  — Becks artikel om et enkelt testframework til Smalltalk med fixtures,\n  testcases og testsuiter, i en arkiveret kopi.\n- [Unit Testing](https://abseil.io/resources/swe-book/html/ch12.html)\n  — Erik Kueflers kapitel i _Software Engineering at Google_ om tests, der\n  overlever refaktorering, test gennem offentlige API'er og test af adfærd.\n- [Get Started](https://docs.pytest.org/en/stable/getting-started.html)\n  — pytests introduktion: installation, en første test, der fejler, med dens\n  rapport, og hvordan testfiler bliver fundet.\n- [unittest: Unit testing framework](https://docs.python.org/3/library/unittest.html)\n  — frameworket i Pythons standardbibliotek, som nævner Becks artikel som den\n  oprindelige beskrivelse af det mønster, det deler.\n\n\u003chttps://engineer.company/da/glossary/test-driven-development/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"De fem trin i testdrevet udvikling, et eksempel i pytest fra testliste til grøn test og de fejl, Kent Beck advarer imod.","formats":{"gemtext":"https://engineer.company/da/glossary/test-driven-development/index.gmi","gopher":"https://engineer.company/da/glossary/test-driven-development/gophermap","html":"https://engineer.company/da/glossary/test-driven-development/","json":"https://engineer.company/da/glossary/test-driven-development/index.json","markdown":"https://engineer.company/da/glossary/test-driven-development/index.md","pdf":"https://engineer.company/da/glossary/test-driven-development/index.pdf"},"kind":"page","language":"da","title":"Hvad er testdrevet udvikling?","url":"https://engineer.company/da/glossary/test-driven-development/","version":1}