{"canonical_url":"https://engineer.company/sv/glossary/unit-test/","content_markdown":"# Enhetstest\n\n## Vad det är\n\nEtt enhetstest är en liten, automatisk kontroll av en enda kodbit för sig: det\nanropar en funktion, en klass eller en liten modul med utvalda indata och\nkontrollerar att det som kommer tillbaka är det som ska komma tillbaka. Sådana\ntester utformas vanligtvis för att köras i samma process som koden de testar,\nbli klara snabbt och inte behöva nätverk, databas eller webbläsare. Det är\nanvändbara val som gäller resurser och isolering, inte garantier som följer enbart av\ntestets snäva omfång. Testet kallas också unit test, och arbetet med att skriva\ndem kallas enhetstestning. Projektets samling av dem är dess svit av enhetstester.\n\nVad som räknas som en enhet är mindre givet än namnet antyder. I kapitlet om\nunit testing i _Software Engineering at Google_ använder Erik Kuefler ordet om\ntester med relativt snävt omfång, till exempel en enda klass eller metod, och\ntillägger att en enhet kan vara så liten som en funktion eller så bred som en\ngrupp närliggande paket. Den gräns som går att använda i praktiken går där andra\nanropar koden: en enhet är det som erbjuder ett gränssnitt som någon utanför är\nberoende av, och dess tester använder gränssnittet på samma sätt som anroparna.\n\nDe moderna ramverken har ett gemensamt ursprung. Kent Becks artikel _Simple\nSmalltalk Testing: With Patterns_ beskrev ett litet ramverk uppbyggt av\nfixtures, testfall, kontroller och sviter, och rekommenderade att utvecklarna\nskrev sina egna enhetstester, ett per klass. Pythons `unittest` skriver i sin\ndokumentation att det ursprungligen inspirerades av JUnit, och det har samma\nfyra begrepp: en test fixture (förberedelsen ett test behöver och städningen\nefteråt), ett testfall (den enskilda testenheten), en testsvit och en\ntestkörare. Båda drar en gräns som är värd att hålla fast vid: en failure är en\nkontroll som fick fel svar, medan en error är något testet inte hade räknat med\nalls, till exempel ett undantag som kastas långt inne i koden.\n\nEnhetstester ligger i den smala änden av en skala. I bokens kapitel om testning\nsorterar Adam Bender tester efter omfång: smala tester kallas vanligen unit\ntests, mellanstora tester som täcker några komponenter tillsammans är\nintegrationstester, och stora tester som driver hela systemet är\nend-to-end-tester.\n\n## Varför det spelar roll\n\nSnabbhet är det första skälet. Ett litet, isolerat enhetstest körs i samma process som koden\ndet testar, så en utvecklare kan köra tusentals av dem under en vanlig\narbetsdag, och ett misstag syns medan ändringen som orsakade det fortfarande\nstår på skärmen. Googles riktlinjer är raka om vad de tillåter: ett litet test\nfår inte sova, göra I/O eller röra nätverket eller disken. Begränsningarna gör det lättare att bygga snabba tester med\nupprepningsbara resultat, och ett team lär sig lita på en svit som ger samma\nsvar varje gång.\n\nDet andra är felsökning. När ett smalt test fallerar sitter felet i en liten\nkodbit, oftast den som just ändrades. När ett test som driver hela systemet\nfallerar kan felet sitta var som helst mellan webbläsaren och databasen. Därför\nbeskriver _Software Engineering at Google_ en pyramid som en grov riktlinje:\nungefär 80 % smala tester, 15 % integrationstester och 5 % end-to-end-tester.\n\nDet tredje är förändring. En svit som kontrollerar beteende genom ett publikt\ngränssnitt gör det möjligt att bygga om koden bakom gränssnittet utan rädsla:\ngår testerna fortfarande igenom får anroparna fortfarande det de ska ha.\nKueflers ideal är ett test som aldrig behöver ändras om inte kraven ändras, så\natt en ren refaktorering inte rör ett enda test.\n\nEnhetstester dokumenterar också. Ett test som är uppkallat efter ett beteende,\nmed enkla indata och ett förväntat resultat utskrivet i sin helhet, visar nästa\nläsare hur koden ska anropas och vad den lovar, och till skillnad från en\nkommentar fallerar det så fort det slutar stämma.\n\n## Så ser det ut i praktiken\n\nTa en funktion som läser varaktigheter som `1h30m` ur en konfigurationsfil och\nräknar om dem till sekunder:\n\n```python\n# durations.py\nUNITS = {\"h\": 3600, \"m\": 60, \"s\": 1}\n\n\ndef to_seconds(text: str) -\u003e int:\n    \"\"\"Räkna om \"1h30m\" eller \"45s\" till ett helt antal sekunder.\"\"\"\n    total, digits = 0, \"\"\n    for char in text:\n        if char.isdigit():\n            digits += char\n        elif char in UNITS and digits:\n            total += int(digits) * UNITS[char]\n            digits = \"\"\n        else:\n            raise ValueError(f\"not a duration: {text!r}\")\n    if digits or not text:\n        raise ValueError(f\"not a duration: {text!r}\")\n    return total\n```\n\nFunktionens enhetstester, skrivna för pytest, kontrollerar två beteenden: vad\nden tar emot och vad den avvisar.\n\n```python\n# test_durations.py\nimport pytest\n\nfrom durations import to_seconds\n\n\n@pytest.mark.parametrize(\n    \"text,expected\",\n    [(\"45s\", 45), (\"2m\", 120), (\"1h30m\", 5400), (\"0s\", 0)],\n)\ndef test_counts_each_unit(text, expected):\n    assert to_seconds(text) == expected\n\n\n@pytest.mark.parametrize(\"text\", [\"\", \"90\", \"h\", \"1x\", \"1.5h\"])\ndef test_refuses_what_it_cannot_read(text):\n    with pytest.raises(ValueError):\n        to_seconds(text)\n```\n\nKör man `pytest` i katalogen samlar det in alla filer som heter `test_*.py`\neller `*_test.py`, och de två funktionerna vecklas ut till nio fall, ett per rad\nmed parametrar. Dokumentationen till pytest beskriver varje test som arrange,\nact, assert och cleanup; här är förberedelsen parameterraden, handlingen är det\nenda anropet, och det finns inget att städa upp eftersom inget utanför\nfunktionen berörs. Råkar någon senare sätta minuten till `3600` sekunder\nfallerar två testfall, och rapporten namnger vart och ett efter dess parametrar:\n`test_counts_each_unit[2m-120]` visar `7200` mot förväntade `120`, och\n`test_counts_each_unit[1h30m-5400]` visar `111600` mot `5400`. Lägg märke till\natt de förväntade värdena är uträknade för hand, inte kopierade från det koden\nreturnerade första gången.\n\nSamma kontroller i standardbibliotekets `unittest` skulle bli en underklass till\n`unittest.TestCase` med metoder vars namn börjar på `test`, och med\n`assertEqual` och `assertRaises`; `python -m unittest` hittar som standard filer\nsom matchar `test*.py`. Go har byggt in konventionen i verktygskedjan: en\nfunktion `func TestXxx(t *testing.T)` i en fil vars namn slutar på `_test.go`\nkörs av `go test`.\n\nSkalan ändrar bokföringen, inte idén.\n[Databasgeneratorn med 981 testfall](/sv/portfolio/held-the-generator-to-981-tests-and-92-coverage/),\nett arbete utfört i juli 2026, räknar 383 testfunktioner som blir 981 fall när\nde parametriserade har expanderats, fördelade på 45 filer och 7 944 rader.\nBygget upprätthåller ett golv på 92 % grentäckning, sviten ligger på ungefär\n95 %, och varningar behandlas som fel. Sidan är ärlig om hur långt talet räcker:\ntvå av de fel som hittades senare i projektet låg i kod som täckningsrapporten\nvisade som täckt.\n\n## Var det går fel\n\n**Testerna speglar implementationen.** Ett test som griper in i privata\nhjälpfunktioner eller kontrollerar den exakta ordningen av interna anrop går\nsönder varje gång koden byggs om, trots att inget en anropare kan se har\nändrats. Kuefler kallar det ett skört test och pekar ut överdriven användning\nav mockningsramverk som den vanligaste orsaken till att tester av interaktioner\ngår snett. Testa genom det publika gränssnittet, kontrollera det tillstånd som\nanropet lämnar efter sig snarare än anropen som ledde dit, och använd riktiga\nobjekt där de är billiga.\n\n**Testerna är beroende av varandra.** Ett test skapar en post, nästa läser den,\noch sviten går igenom bara i den ordningen. Kör ett enda test, eller samma\ntester i en annan ordning, och det fallerar av ett skäl som ingen läsare kan se.\nBecks ramverk skapade sina testdata och kastade dem igen för varje test, och\ndokumentationen för `unittest` ber att ett testfall ska vara helt\nsjälvständigt. Ge varje test en egen fixture och städa efter det.\n\n**Täckning blir målet.** Täckning visar att en rad kördes, inte att något\nkontrollerade vad den gjorde. Ett test utan en enda assertion höjer siffran och\nbevisar ingenting, och _Software Engineering at Google_ varnar för att ett krav\npå 80 % brukar bli ett tak, så att ändringar landar på exakt miniminivån.\nBehandla siffran som ett golv, och läs assertions under kodgranskningen.\n\n**Ett test per metod.** Att ge varje metod i produktionskoden en egen\ntestmetod ser prydligt ut, men testet växer varje gång metoden får en ny gren,\ntills ingen kan säga vad det kontrollerar. Kueflers råd är att testa beteenden\ni stället: ett beteende per test, uppkallat efter det det bevisar, så att en\nfelrapport kan läsas som en mening om vad som gick sönder.\n\n**Testet väntar på att tiden ska gå.** En `sleep()` som ska ge något tid att\nbli klart gör sviten långsammare vid varje körning och fallerar ändå på en\nbelastad maskin. I ett enhetstest är tiden indata: ge koden en klocka eller en\ntidsstämpel, så att testet själv kan ställa in den tidpunkt det behöver i\nstället för att vänta på den.\n\n## Läs mer\n\n- [unittest: Unit testing framework](https://docs.python.org/3/library/unittest.html)\n  — ramverket i Pythons standardbibliotek: fixtures, testfall, sviter,\n  testkörare, testupptäckt och skillnaden mellan en failure och en error.\n- [Anatomy of a test](https://docs.pytest.org/en/stable/explanation/anatomy.html)\n  — pytests förklaring av arrange, act, assert och cleanup.\n- [Get Started](https://docs.pytest.org/en/stable/getting-started.html)\n  — pytests egen introduktion: vanlig `assert`, testupptäckt och\n  `pytest.raises`.\n- [Unit Testing](https://abseil.io/resources/swe-book/html/ch12.html)\n  — Erik Kueflers kapitel i _Software Engineering at Google_ om sköra tester,\n  publika API:er, tillstånd framför interaktioner och testning av beteenden.\n- [Simple Smalltalk Testing: With Patterns](https://web.archive.org/web/20150315073817/http://www.xprogramming.com/testfram.htm)\n  — Kent Becks artikel om ramverket, om att skriva enhetstester ett per klass\n  och om failures och errors, i en arkiverad kopia.\n- [testing](https://pkg.go.dev/testing)\n  — Gos standardpaket för testning: `TestXxx`-funktioner, `_test.go`-filer och\n  `go test`.\n\n\u003chttps://engineer.company/sv/glossary/unit-test/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Vad som räknas som en enhet, hur ett test förblir snabbt och oberoende, ett genomräknat exempel i pytest och vanorna som gör en svit skör.","formats":{"gemtext":"https://engineer.company/sv/glossary/unit-test/index.gmi","gopher":"https://engineer.company/sv/glossary/unit-test/gophermap","html":"https://engineer.company/sv/glossary/unit-test/","json":"https://engineer.company/sv/glossary/unit-test/index.json","markdown":"https://engineer.company/sv/glossary/unit-test/index.md","pdf":"https://engineer.company/sv/glossary/unit-test/index.pdf"},"kind":"page","language":"sv","title":"Vad är ett enhetstest?","url":"https://engineer.company/sv/glossary/unit-test/","version":1}