{"canonical_url":"https://engineer.company/nb/glossary/test-driven-development/","content_markdown":"# Testdrevet utvikling\n\n## Hva det er\n\nTestdrevet utvikling er en måte å programmere på der testen for en bit atferd\nskrives før koden som leverer atferden, én liten test om gangen. Kent Beck, som\nselv kaller sin andel i metoden en gjenoppdagelse, beskriver den som en\narbeidsflyt for programmerere. I 2023 hadde han erfart at folk ikke var enige om\nhva begrepet dekker, så han skrev ned arbeidsflyten i et kort innlegg med\ntittelen Canon TDD. Der bruker han nesten overalt forkortelsen TDD, av det\nengelske test-driven development.\n\nArbeidsflyten har fem trinn:\n\n1. Skriv en liste over testscenarioene du vil dekke.\n2. Gjør nøyaktig ett punkt på listen om til en konkret test som kan kjøres.\n3. Endre koden slik at denne testen og alle de tidligere går gjennom, og før opp\n   nye punkter på listen etter hvert som du oppdager dem.\n4. Forbedre eventuelt designet av implementasjonen ved å refaktorere.\n5. Gå tilbake til trinn 2 så lenge det står punkter på listen.\n\nListen er analyse, men av atferd og ikke av design: først grunntilfellet, så\nvariasjonene og til slutt måtene endringen ikke må ødelegge det som allerede\nvirker på. Testen fra trinn 2 er en ekte automatisert test med oppsett, et kall\nog påstander (assertions), og den feiler første gang den kjøres, fordi atferden\nden beskriver, først skal skrives. Beck kaller trinn 3 å gå fra rødt til grønt,\naltså fra en test som feiler, til en som består.\n\nDet er like nyttig å vite hva arbeidsflyten ikke er. Å skrive alle testene før\nman skriver en eneste kodelinje er en vanlig innvending mot TDD, og Beck svarer\nrett ut: Det er ikke TDD, og den som kritiserer det, kritiserer noe annet. Den\nandre veien er han like avslappet. Et team som jobber annerledes og får gode\nresultater, kan gjerne fortsette med det, og som han skriver, deles det ikke ut\nnoen gullstjerne for å følge trinnene til punkt og prikke.\n\n## Hvorfor det er viktig\n\nBeck skriver selv hva arbeidsflyten skal føre til. En programmerer som endrer\natferden til et system, skal ende opp med et system der alt som virket før,\nfortsatt virker, den nye atferden virker som forventet, koden er klar for neste\nendring, og programmereren og kollegene er trygge på alle tre delene. Fordi hver\ntest skrives mens endringen er liten og fersk i minnet, vokser sikkerhetsnettet\ni samme tempo som koden i stedet for å bli lovet til senere.\n\nDet andre argumentet er design. Beck skiller mellom to slags designbeslutninger:\nhvordan en bit atferd kalles, og hvordan systemet implementerer den. Når testen\nskrives først, tvinger den fram beslutningene om grensesnittet, for testen må\nkalle noe og si hva som kommer tilbake. Beslutningene om implementasjonen venter\ntil refaktoreringstrinnet, der beståtte tester beskytter dem. En test som er\ntungvint å skrive, er et tidlig tegn på at grensesnittet blir tungvint å bruke.\n\nDet tredje argumentet er dobbeltkontrollen. Den forventede verdien i en test\nregner et menneske ut fra kravet, og koden kommer fram til den en annen vei. Når\nde to gir det samme, har to uavhengige veier nådd samme svar, og ifølge Beck er\ndet nettopp dobbeltkontrollen som gir TDD en stor del av verdien som kontroll.\n\nTil slutt gir arbeidsflyten et signal om når man er ferdig. Becks råd er å\nfortsette å teste og kode til frykten for hvordan koden oppfører seg, har blitt\ntil kjedsomhet. Vanen er mye eldre enn innlegget. Beck plasserer gjenoppdagelsen\nmellom 1994, da han skrev SUnit for en konsulentkunde, og oktober 1995, da han\ndemonstrerte TDD for Ward Cunningham på OOPSLA-konferansen i Austin. Artikkelen\nhans Simple Smalltalk Testing beskriver et enkelt testrammeverk for Smalltalk,\nog Pythons dokumentasjon av unittest viser fortsatt til den som Becks\nopprinnelige artikkel om mønsteret unittest deler.\n\n## Slik ser det ut i praksis\n\nTenk deg en kontroll som skal finne forbudte moteord i tekstene på et nettsted.\nArbeidet begynner med testlisten, skrevet som vanlige notater:\n\n```text\n- et forbudt ord blir rapportert\n- et forbudt ord med stor forbokstav blir rapportert\n```\n\nTrinn 2 gjør nøyaktig ett punkt om til en test. Det første punktet står først av en grunn: Det gir kontrollen et kjent forbudt ord og sjekker at ordet blir rapportert. Testen feiler til kontrollen kan finne det. Testen legges i en\nfil som heter `test_wording.py`, og pytest plukker den opp fordi navnet har\nformen `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\nKjører man `pytest -q`, feiler testen straks, fordi importen av `find_banned`\nmislykkes. Den feilen er hele poenget: Man har sett testen feile, så når den\nbestår senere, betyr det noe. Den enkleste koden som får den til å bestå, holder\nforeløpig, 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. Neste punkt blir neste test:\n\n```python\ndef test_reports_a_capitalised_banned_word():\n    assert find_banned(\"Leverage it\", {\"leverage\"}) == [\"Leverage\"]\n```\n\nDen feiler, og fordi pytest viser mellomverdiene i en påstand, viser utdataene\nen tom liste der `[\"Leverage\"]` var forventet. Å sammenligne `word.lower()` i\nstedet for `word` får den til å bestå. Underveis oppdager programmereren at\n`text.split()` lar tegnsettingen henge ved ordet, så «leverage,» med komma ville\nsluppet gjennom. Det havner på listen og ikke i koden, og blir den tredje\ntesten:\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 feiler, og én linje til får alle tre til å 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\nTrinn 4 er valgfritt, og her er det lite å forbedre: to linjer med hver sin\noppgave. Hvert punkt på listen har nå en test som består, så arbeidet er gjort.\nDe forventede verdiene i testene er alle skrevet ut fra punktet på listen og\naldri kopiert fra en kjøring.\n\nRekkefølgen på listen var ikke tilfeldig, og nettstedets egen portefølje viser\nhvorfor. Et\n[prosjekt som skrev tester for selve kontrollverktøyene](/nb/portfolio/wrote-tests-for-the-checkers-themselves/),\narbeid utført i august 2026, slo fast at prosjektets egne kontrollskript, blant\ndem en stavekontroll, en kontroll av grammatisk person og en kontroll av tallkonsistens, hadde\nvært grønne i månedsvis, og at et kontrollskript som aldri har sett annet enn\nrene inndata, ikke kan skilles fra et som ikke leser noe i det hele tatt.\nLøsningen var å plante nettopp den feilen hvert kontrollskript finnes for å\nfinne: Stavekontrollen får et bevisst feilstavet ord, og testen feiler hvis\nkjøringen kommer tilbake ren, kontrollen av grammatisk person får prosa i første person og må\navvise den, og moteordkontrollen får et forbudt ord. To av kontrollskriptene\nviste seg å lese et smalere sett med filer enn dokumentasjonen deres hevdet.\nSiden beskriver ikke TDD, men poenget er det samme som TDD bygger inn fra første\ntrinn: En test er først verdt noe når man har sett den feile.\n\n## Hvor det går galt\n\n**Alle testene skrives først.** Å gjøre hvert punkt på listen om til en test før\nen eneste av dem består, er den feiltolkningen Beck trekker fram. Når den første\ntesten tvinger en til å tenke om, må alle de spekulative testene gjøres om, og\nen programmerer som har kommet til test nummer seks uten å ha sett noe bestå,\nrammes ifølge Beck av nedstemthet eller kjedsomhet. Skriv én test, få den til å\nbestå, og velg så den neste. Viser en ny test at arbeidet så langt ikke klarer\net tilfelle, må man bestemme seg for om man skal fortsette eller begynne på\nnytt; Becks råd er å begynne på nytt og velge en annen rekkefølge.\n\n**Testen har ingen påstand.** En test som kaller koden og ikke sjekker noe, øker\ndekningsgraden og beviser ingenting. Hver test trenger oppsett, et kall og en\npåstand, og Beck foreslår å prøve av og til å skrive en test baklengs, med\npåstandene som utgangspunkt.\n\n**Påstanden slettes.** Når en test nekter å bestå, er det fristende å slette\npåstanden, slik at testen later som om den består. Få den til å bestå på\nordentlig, eller send punktet tilbake til listen og tenk gjennom rekkefølgen på\nnytt.\n\n**Forventede verdier kopieres fra utdataene.** Å kjøre koden, kopiere det den\nreturnerte, og lime det inn i testen gjør en dobbeltkontroll til en\nenkeltkontroll: Testen bekrefter nå bare at koden gjør det den gjorde. Regn ut\nden forventede verdien fra kravet, for hånd om nødvendig.\n\n**Refaktorering mens testen skal bestå.** Å endre struktur og atferd i samme\ntrinn er det Beck kaller å ha to hatter på. Få det til å kjøre, og gjør det så\nriktig: Nå grønt med den enkleste endringen, og rydd først opp når testene\nbestår.\n\n**For mye opprydding, eller abstraksjon for tidlig.** Det føles godt å rydde, og\ndet kan føles tryggere enn å ta fatt på neste test. Stopp når koden er god nok\nfor denne økten, og la to kodebiter som ligner hverandre, være i fred til\nmønsteret er tydelig. Becks formulering er kort: «Duplisering er et vink, ikke\nen ordre.»\n\n**Testene kjenner implementasjonen.** Tester som kaller private metoder eller\nsjekker hvilke kall koden gjorde, i stedet for hva den ga som resultat, brekker\nhver gang innmaten endres. Erik Kuefler kaller dem skjøre tester i kapittelet om\nenhetstester i _Software Engineering at Google_: De feiler ved en endring som\nikke har noe med dem å gjøre og ikke innfører noen reell feil. I TDD koster det\ndobbelt, for refaktoreringstrinnet forutsetter tester som forblir grønne mens\ninnmaten flytter seg. Test gjennom det offentlige grensesnittet, sjekk\ntilstanden koden etterlater, heller enn samspillet, og gi hver test navn etter\natferden den sjekker.\n\n## Les mer\n\n- [Canon TDD](https://newsletter.kentbeck.com/p/canon-tdd)\n  — Kent Becks egen beskrivelse av arbeidsflyten fra 2023: de fem trinnene,\n  skillet mellom design av grensesnitt og av implementasjon og feilene ved hvert\n  trinn.\n- [Simple Smalltalk Testing: With Patterns](https://web.archive.org/web/20150315073817/http://www.xprogramming.com/testfram.htm)\n  — Becks artikkel om et enkelt testrammeverk for Smalltalk med fixtures,\n  testtilfeller og testsuiter, i en arkivert kopi.\n- [Unit Testing](https://abseil.io/resources/swe-book/html/ch12.html)\n  — Erik Kueflers kapittel i _Software Engineering at Google_ om tester som\n  overlever refaktorering, testing gjennom offentlige API-er og testing av\n  atferd.\n- [Get Started](https://docs.pytest.org/en/stable/getting-started.html)\n  — innføringen i pytest: installasjon, en første test som feiler, med\n  rapporten, og hvordan testfiler blir funnet.\n- [unittest: Unit testing framework](https://docs.python.org/3/library/unittest.html)\n  — rammeverket i Pythons standardbibliotek, som nevner Becks artikkel som den\n  opprinnelige beskrivelsen av mønsteret det deler.\n\n\u003chttps://engineer.company/nb/glossary/test-driven-development/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"De fem trinnene i testdrevet utvikling, et eksempel i pytest fra testliste til grønn test og feilene Kent Beck advarer mot.","formats":{"gemtext":"https://engineer.company/nb/glossary/test-driven-development/index.gmi","gopher":"https://engineer.company/nb/glossary/test-driven-development/gophermap","html":"https://engineer.company/nb/glossary/test-driven-development/","json":"https://engineer.company/nb/glossary/test-driven-development/index.json","markdown":"https://engineer.company/nb/glossary/test-driven-development/index.md","pdf":"https://engineer.company/nb/glossary/test-driven-development/index.pdf"},"kind":"page","language":"nb","title":"Hva er testdrevet utvikling?","url":"https://engineer.company/nb/glossary/test-driven-development/","version":1}