{"canonical_url":"https://engineer.company/sv/glossary/test-driven-development/","content_markdown":"# Testdriven utveckling\n\n## Vad det är\n\nTestdriven utveckling är ett sätt att programmera där testet för ett visst\nbeteende skrivs före koden som ger beteendet, ett litet test i taget. Kent Beck,\nsom själv kallar sin del i metoden en återupptäckt, beskriver den som ett\narbetsflöde för programmerare. År 2023 hade han märkt att folk inte var överens\nom vad begreppet täcker, så han skrev ner arbetsflödet i ett kort inlägg med\ntiteln Canon TDD. Där använder han nästan överallt förkortningen TDD, efter\nengelskans test-driven development.\n\nArbetsflödet har fem steg:\n\n1. Skriv en lista över de testscenarier du vill täcka.\n2. Gör exakt en punkt på listan till ett konkret test som går att köra.\n3. Ändra koden så att det här testet och alla tidigare går igenom, och för upp\n   nya punkter på listan allteftersom du upptäcker dem.\n4. Förbättra eventuellt implementationens design genom att refaktorera.\n5. Gå tillbaka till steg 2 så länge det finns punkter kvar på listan.\n\nListan är analys, men av beteende och inte av design: först grundfallet, sedan\nvariationerna och till sist de sätt på vilka ändringen inte får förstöra det som\nredan fungerar. Testet från steg 2 är ett riktigt automatiserat test med\nförberedelse, ett anrop och påståenden (assertions), och det fallerar första\ngången det körs, eftersom beteendet det beskriver återstår att skriva. Beck\nkallar steg 3 att gå från rött till grönt, alltså från ett test som fallerar\ntill ett som går igenom.\n\nDet är lika nyttigt att veta vad arbetsflödet inte är. Att skriva alla tester\ninnan man skriver en enda kodrad är ett vanligt klagomål på TDD, och Beck svarar\nrakt på sak: det är inte TDD, och den som kritiserar det kritiserar något annat.\nÅt andra hållet är han lika avslappnad. Ett team som arbetar annorlunda och får\nbra resultat får gärna fortsätta så, och som han skriver delas det inte ut någon\nguldstjärna för att följa stegen till punkt och pricka.\n\n## Varför det spelar roll\n\nBeck skriver själv vad arbetsflödet ska leda till. En programmerare som ändrar\nett systems beteende ska sluta med ett system där allt som fungerade förut\nfortfarande fungerar, det nya beteendet fungerar som väntat, koden är redo för\nnästa ändring och programmeraren och kollegerna känner sig trygga med alla tre\ndelarna. Eftersom varje test skrivs medan ändringen är liten och färsk i minnet\nväxer skyddsnätet i samma takt som koden i stället för att utlovas till senare.\n\nDet andra argumentet är design. Beck skiljer mellan två slags designbeslut: hur\nett beteende anropas och hur systemet implementerar det. När testet skrivs först\ntvingar det fram besluten om gränssnittet, eftersom testet måste anropa något\noch säga vad som kommer tillbaka. Besluten om implementationen får vänta till\nrefaktoreringssteget, då tester som går igenom skyddar dem. Ett test som är\nkrångligt att skriva är ett tidigt tecken på att gränssnittet blir krångligt att\nanvända.\n\nDet tredje argumentet är dubbelkontrollen. Det förväntade värdet i ett test\nräknar en människa fram ur kravet, och koden når fram till det en annan väg. När\nde två ger samma resultat har två oberoende vägar lett till samma svar, och\nenligt Beck är det just dubbelkontrollen som ger TDD en stor del av dess värde\nsom kontroll.\n\nSlutligen ger arbetsflödet en signal om när man är klar. Becks råd är att\nfortsätta testa och koda tills rädslan för hur koden beter sig har förvandlats\ntill leda. Vanan är mycket äldre än inlägget. Beck förlägger återupptäckten till\ntiden mellan 1994, då han skrev SUnit åt en konsultkund, och oktober 1995, då\nhan demonstrerade TDD för Ward Cunningham på OOPSLA-konferensen i Austin. Hans\nartikel Simple Smalltalk Testing beskriver ett enkelt testramverk för Smalltalk,\noch Pythons dokumentation av unittest hänvisar fortfarande till den som Becks\nursprungliga artikel om det mönster som unittest delar.\n\n## Så ser det ut i praktiken\n\nTänk dig en kontroll som ska hitta förbjudna modeord i texterna på en webbplats.\nArbetet börjar med testlistan, skriven som vanliga anteckningar:\n\n```text\n- ett förbjudet ord rapporteras\n- ett förbjudet ord med stor begynnelsebokstav rapporteras\n```\n\nSteg 2 gör exakt en punkt till ett test. Den första punkten står först av en anledning: den ger kontrollen ett känt förbjudet ord och kontrollerar att ordet rapporteras. Testet fallerar tills kontrollen kan hitta det. Testet\nhamnar i en fil som heter `test_wording.py`, och pytest plockar upp den eftersom\nnamnet 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ör man `pytest -q` fallerar testet direkt, eftersom importen av `find_banned`\nmisslyckas. Det felet är hela poängen: man har sett testet fallera, så när det\ngår igenom senare betyder det något. Den enklaste koden som får det att gå\nigenom räcker för stunden, 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\nTestet går igenom. Nästa punkt blir nästa test:\n\n```python\ndef test_reports_a_capitalised_banned_word():\n    assert find_banned(\"Leverage it\", {\"leverage\"}) == [\"Leverage\"]\n```\n\nDet fallerar, och eftersom pytest visar mellanvärdena i ett påstående syns en\ntom lista i utdata där `[\"Leverage\"]` förväntades. Att jämföra `word.lower()` i\nstället för `word` får det att gå igenom. Under tiden märker programmeraren att\n`text.split()` låter skiljetecknen sitta kvar på ordet, så ”leverage,” med\nkommatecken skulle slinka igenom. Det hamnar på listan och inte i koden, och\nblir det tredje testet:\n\n```python\ndef test_reports_a_banned_word_before_a_comma():\n    assert find_banned(\"Use it, leverage, win\", {\"leverage\"}) == [\"leverage\"]\n```\n\nDet fallerar, och en rad till får alla tre att gå igenom:\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\nSteg 4 är frivilligt, och här finns inte mycket att förbättra: två rader med var\nsin uppgift. Varje punkt på listan har nu ett test som går igenom, så arbetet är\nklart. De förväntade värdena i testerna är alla skrivna utifrån punkten på\nlistan och aldrig kopierade från en körning.\n\nOrdningen på listan var ingen slump, och webbplatsens egen portfölj visar\nvarför. Ett\n[projekt som skrev tester för själva kontrollerna](/sv/portfolio/wrote-tests-for-the-checkers-themselves/),\narbete utfört i augusti 2026, konstaterade att projektets egna kontrollprogram,\nbland dem en stavningskontroll, en kontroll av berättarrösten och en kontroll av\nsifferkonsistens, hade varit gröna i månader, och att ett kontrollprogram som\nbara någonsin har sett felfri indata inte går att skilja från ett som inte läser\nnågonting alls. Lösningen var att plantera just det fel som varje\nkontrollprogram finns till för att hitta: stavningskontrollen matas med ett\navsiktligt felstavat ord, och testet fallerar om körningen kommer tillbaka\nfelfri, kontrollen av berättarrösten matas med prosa i första person och måste\navvisa den, och kontrollen av modeord matas med ett förbjudet ord. Två av\nkontrollprogrammen visade sig läsa en snävare uppsättning filer än deras\ndokumentation påstod. Sidan beskriver inte TDD, men dess poäng är densamma som\nTDD bygger in från första steget: ett test är värt något först när man har sett\ndet fallera.\n\n## Var det går fel\n\n**Alla tester skrivs först.** Att göra varje punkt på listan till ett test innan\nett enda av dem går igenom är den feltolkning som Beck lyfter fram. När det\nförsta testet tvingar fram en omprövning måste alla de spekulativa testerna\ngöras om, och en programmerare som har kommit till test nummer sex utan att ha\nsett något gå igenom drabbas enligt Beck av nedstämdhet eller leda. Skriv ett\ntest, få det att gå igenom och välj sedan nästa. Visar ett nytt test att arbetet\nhittills inte klarar ett visst fall får man avgöra om man ska fortsätta eller\nbörja om; Becks råd är att börja om och välja en annan ordning.\n\n**Testet saknar påstående.** Ett test som anropar koden och inte kontrollerar\nnågot höjer täckningsgraden och bevisar ingenting. Varje test behöver\nförberedelse, ett anrop och ett påstående, och Beck föreslår att man då och då\nprovar att skriva ett test baklänges, med påståendena som utgångspunkt.\n\n**Påståendet tas bort.** När ett test vägrar gå igenom är det frestande att ta\nbort dess påstående, så att testet låtsas gå igenom. Få det att gå igenom på\nriktigt, eller skicka tillbaka punkten till listan och tänk om kring ordningen.\n\n**Förväntade värden kopieras från utdata.** Att köra koden, kopiera det den\nreturnerade och klistra in det i testet gör en dubbelkontroll till en enkel\nkontroll: testet bekräftar nu bara att koden gör det den gjorde. Räkna fram det\nförväntade värdet ur kravet, för hand om det behövs.\n\n**Refaktorering medan testet ska gå igenom.** Att ändra struktur och beteende i\nsamma steg är vad Beck kallar att bära två hattar. Få det att köra och gör det\nsedan rätt: nå grönt med den enklaste ändringen, och städa först när testerna\ngår igenom.\n\n**För mycket städning, eller abstraktion för tidigt.** Det känns bra att städa,\noch det kan kännas tryggare än att ta itu med nästa test. Sluta när koden är\ntillräckligt bra för den här arbetsomgången, och låt två kodavsnitt som liknar\nvarandra vara i fred tills mönstret är tydligt. Becks formulering är kort:\n”Duplicering är en vink, inte en order.”\n\n**Testerna känner till implementationen.** Tester som anropar privata metoder\neller kontrollerar vilka anrop koden gjorde, i stället för vad den gav för\nresultat, går sönder varje gång det inre ändras. Erik Kuefler kallar dem sköra\ntester i kapitlet om enhetstester i _Software Engineering at Google_: de\nfallerar vid en ändring som inte har med dem att göra och inte för in något\nverkligt fel. I TDD kostar det dubbelt, eftersom refaktoreringssteget\nförutsätter tester som förblir gröna medan det inre flyttas runt. Testa genom\ndet publika gränssnittet, kontrollera det tillstånd koden lämnar efter sig\nsnarare än samspelet, och namnge varje test efter beteendet det kontrollerar.\n\n## Läs mer\n\n- [Canon TDD](https://newsletter.kentbeck.com/p/canon-tdd)\n  — Kent Becks egen beskrivning av arbetsflödet från 2023: de fem stegen,\n  skillnaden mellan design av gränssnitt och av implementation och misstagen i\n  varje steg.\n- [Simple Smalltalk Testing: With Patterns](https://web.archive.org/web/20150315073817/http://www.xprogramming.com/testfram.htm)\n  — Becks artikel om ett enkelt testramverk för Smalltalk med fixturer, testfall\n  och testsviter, i en arkiverad kopia.\n- [Unit Testing](https://abseil.io/resources/swe-book/html/ch12.html)\n  — Erik Kueflers kapitel i _Software Engineering at Google_ om tester som\n  överlever refaktorering, testning genom publika API:er och testning av\n  beteenden.\n- [Get Started](https://docs.pytest.org/en/stable/getting-started.html)\n  — introduktionen till pytest: installation, ett första test som fallerar, med\n  sin rapport, och hur testfiler hittas.\n- [unittest: Unit testing framework](https://docs.python.org/3/library/unittest.html)\n  — ramverket i Pythons standardbibliotek, som nämner Becks artikel som den\n  ursprungliga beskrivningen av mönstret det delar.\n\n\u003chttps://engineer.company/sv/glossary/test-driven-development/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"De fem stegen i testdriven utveckling, ett exempel i pytest från testlista till grönt test och de misstag Kent Beck varnar för.","formats":{"gemtext":"https://engineer.company/sv/glossary/test-driven-development/index.gmi","gopher":"https://engineer.company/sv/glossary/test-driven-development/gophermap","html":"https://engineer.company/sv/glossary/test-driven-development/","json":"https://engineer.company/sv/glossary/test-driven-development/index.json","markdown":"https://engineer.company/sv/glossary/test-driven-development/index.md","pdf":"https://engineer.company/sv/glossary/test-driven-development/index.pdf"},"kind":"page","language":"sv","title":"Vad är testdriven utveckling?","url":"https://engineer.company/sv/glossary/test-driven-development/","version":1}