Wat is unit testen eigenlijk?
Unit testen is het testen van de kleinste stukjes code – meestal functies of methoden – om te controleren of ze correct werken.
- Waarom? Om problemen vroegtijdig op te sporen door elk klein onderdeel van je software te testen.
- Hoe? Schrijf tests die specifieke invoer in je code stoppen en kijk of je de juiste uitvoer krijgt.
- Waarmee? Enkele voorbeelden van tools zijn JUnit voor Java, NUnit voor .NET en Jest voor JavaScript. Het is een vrij gangbare praktijk in softwareontwikkeling om unit-testen uit te voeren om het werk op te splitsen. Hiermee kun je zien of je code werkt zoals verwacht, wat cruciaal is voor het bouwen van betrouwbare software. Maar het kost ook moeite en tijd, wat ons bij de belangrijkste vraag brengt: is het de moeite waard of niet?
Voordelen van unit testen
Er zijn een aantal goede redenen waarom ontwikkelaars dol zijn op unit testen.
Vroegtijdig bugs opsporen
Een van de grootste voordelen van unit testen is dat je bugs vroegtijdig opspoort. Door kleine stukjes code direct te testen, kun je problemen opsporen en oplossen voordat ze uitgroeien tot grote, vervelende problemen. Dit bespaart je later veel gedoe. Stel, je werkt aan een groot project en er sluipt een bug in de code. Als je die vroegtijdig opspoort met unit-tests, is het veel gemakkelijker om hem te verhelpen dan wanneer je hem ontdekt nadat meerdere componenten in de code zijn opgenomen. Wanneer je de code moet wijzigen of bibliotheken moet bijwerken, voorkomen unit-tests dat die wijzigingen ergens anders problemen veroorzaken. Zo is het gemakkelijker om je codebase gezond en up-to-date te houden. Als je bijvoorbeeld besluit een stuk code te refactoren om de prestaties te verbeteren, kun je met unit tests snel controleren of je wijzigingen de functionaliteit van de bestaande code hebben verstoord. Door elk onderdeel van je code afzonderlijk te testen, wordt het samenvoegen van alles een stuk eenvoudiger. Wanneer je weet dat elk onderdeel correct werkt, verklein je het risico op integratieproblemen. Dan wordt het integreren van al die onderdelen een stuk minder lastig.
Handige documentatie
Unittests dienen ook als documentatie. Ze laten zien hoe je code zou moeten werken en wat hij moet doen. Dit is enorm handig voor nieuwe ontwikkelaars die net aan een project zijn begonnen of wanneer je je moet herinneren wat je zes maanden geleden hebt gedaan. In plaats van door commentaren of verouderde documentatie te spitten, kun je de unit tests bekijken om te begrijpen wat je van de code mag verwachten (en of deze aan de verwachtingen voldoet).
Beter codeontwerp
Het schrijven van tests dwingt je om na te denken over codeontwerp, wat kan leiden tot modulaire en onderhoudbare code, omdat je vanaf het begin moet overwegen hoe gemakkelijk het is om te testen. Bij het schrijven van unit tests vraag je jezelf in feite af: "Hoe kan ik deze functie of module testen?" Het resultaat: beter gestructureerde en meer ontkoppelde code.
Bespaar geld
Het vroegtijdig vinden en oplossen van bugs is goedkoper dan er later mee te maken krijgen. Je pakt problemen eerder op, wat je kan helpen om dure reparaties te voorkomen en geld te besparen. Hoe later je een bug vindt, hoe duurder het is om deze te repareren (zowel qua geld als qua verloren tijd).
Nadelen van unit testen
Maar het is niet allemaal rozengeur en maneschijn. Er kleven een aantal nadelen aan unit-testen en er zijn redenen waarom sommige ontwikkelaars er een hekel aan hebben.
Het kost tijd om het op te zetten
Dit is waar het wat minder prettig wordt: het opzetten van een unit-testomgeving en het schrijven van goede tests kost tijd. Soms heel veel tijd. De initiële inspanning kan lastig te rechtvaardigen zijn, vooral met een strak schema. Bij de start van een nieuw project kan de druk om snel functionaliteiten te leveren het verleidelijk maken om unit-testen over te slaan. Dit kan echter nog meer werk betekenen wanneer er bugs opduiken.
Tests actueel houden
Het kan lastig zijn om tests actueel te houden, vooral als ze niet goed geschreven zijn. Verouderde of slechte tests verhogen de werklast en vertragen de boel. Telkens wanneer je wijzigingen aan de code aanbrengt, moet je de unit tests bijwerken om die wijzigingen te weerspiegelen. De onderhoudsinspanning kan aanzienlijk zijn, vooral bij grote projecten.
Vals gevoel van veiligheid
Zelfs als je unit tests slagen, betekent dat niet dat je software geen bugs bevat. Te veel vertrouwen op unit tests kan je een vals gevoel van veiligheid geven, waardoor je mogelijk minder grondig test op andere gebieden. Unit tests dekken alleen individuele code-eenheden, niet de interacties daartussen. Je hebt ook andere tests nodig, zoals integratie- en systeemtests.
Problemen met isolatie
Het testen van applicatieonderdelen in isolatie kan lastig zijn, vooral als je code afhankelijk is van externe bronnen, zoals databases of diensten van derden. Mocks en stubs helpen, maar kunnen de zaken ook ingewikkelder maken. Als uw functie bijvoorbeeld afhankelijk is van een databasequery, moet u de databaserespons in uw unit-test mocken. Unit-tests testen niet hoe verschillende onderdelen van uw applicatie samenwerken. U hebt nog steeds integratie- en systeemtests nodig om het grotere geheel te dekken. Hoewel unit tests geweldig zijn om problemen op microniveau op te sporen, zijn integratietests nog steeds onvermijdelijk voor andere gebieden.
Best practices voor unit testen
Enkele tips om unit testen optimaal te benutten.
Blijf gefocust
Test de absoluut cruciale onderdelen van je applicatie, zoals functies die belangrijke gegevens of berekeningen verwerken. Schrijf tests voor deze gebieden om het maximale uit unit-testen te halen.
Schrijf goede testcases
Dek alle mogelijke invoer, zelfs randgevallen en potentiële fouten. Elke testcase moet onafhankelijk zijn en afzonderlijk worden uitgevoerd. Goede testcases zijn duidelijk, beknopt en dekken een breed scala aan scenarioʼs.
Automatiseer tests
Gebruik een testframework dat past bij uw ontwikkelomgeving. Geautomatiseerde tests geven je continue feedback over de gezondheid van je code. Automatisering vereist minder inspanning van jou om tests uit te voeren en zorgt voor meer consistentie. Voer tests regelmatig uit tijdens de ontwikkeling om problemen vroegtijdig op te sporen. Integreer je tests in je continuous integration/continuous deployment (CI/CD) pipeline. Testen spoort regressies vroegtijdig op en voorkomt de introductie van nieuwe bugs.
Houd tests actueel
Werk tests bij wanneer je de code wijzigt (ten minste wanneer je deze in aanzienlijke mate wijzigt). Ze moeten immers relevant en nauwkeurig blijven. Telkens wanneer je nieuwe functies toevoegt of bestaande code herstructureert, moet je je tests bijwerken om die wijzigingen te weerspiegelen, zodat de tests hun doel blijven dienen.
Is unit testen tijdverspilling?
Het antwoord hierop hangt af van je project en situatie.
Wanneer is unit testen een goed idee?
Wanneer je bugs zo snel mogelijk wilt verhelpen in complexe projecten, is unit testen een redder in nood. De tijd en moeite lonen zich doordat problemen vroegtijdig worden opgespoord en je code betrouwbaarder wordt. Als je project een lange levensduur heeft, er meerdere ontwikkelaars aan werken of er vraag is naar foutloze componenten, kan unit testen je veel problemen besparen. Wanneer unit testen misschien niet de moeite waard is: Aan de andere kant is de tijd en moeite misschien niet de moeite waard voor een kleiner project, vooral als je een strakke deadline hebt. In deze gevallen zijn integratie- en systeemtesten wellicht praktischer. Als je werkt aan een snel prototype of een eenmalig project waarbij snelheid belangrijker is dan robuustheid, kun je ervoor kiezen om unit tests over te slaan en meer te vertrouwen op handmatig testen en code reviews. Hoe kun je unit testing dan wel effectief inzetten? Als je nog niet bekend bent met unit testing, begin dan met de meest kritieke onderdelen van je codebase. Breid je tests geleidelijk uit naarmate je er meer vertrouwd mee raakt.
- Deel de verantwoordelijkheid voor het schrijven en onderhouden van tests om de werkdruk te verdelen.
- Voer je tests consistent uit en houd ze up-to-date.
- Combineer unit-testen met andere teststijlen (bijvoorbeeld integratietesten en end-to-end-testen).
- Gebruik automatiseringstools die goed aansluiten op je ontwikkelomgeving.
- Doe eerst de meest noodzakelijke onderdelen om de functionaliteit te dekken die er het meest toe doet.
- Beoordeel en herschrijf je tests. Dit helpt ze relevant te houden en zorgt ervoor dat ze waarde blijven bieden naarmate je codebase evolueert.
- Deel kennis en best practices en ondersteun elkaar bij het schrijven en onderhouden van tests.
Testen of niet testen?
Unit testen kan zeker nuttig zijn. Het stelt je in staat om bugs vroegtijdig op te sporen, maakt het veiliger om je code te wijzigen en biedt zelfs handige documentatie. Maar het kent ook een paar vervelende nadelen. Het opzetten ervan kan even duren, het bijwerken van tests is een hele klus en soms kan het je een vals gevoel van veiligheid geven.
Dus, is unit testen de moeite waard? Dat hangt af van waaraan je werkt en wat je doelen zijn. Voor veel ontwikkelaars en teams wegen de voordelen van unit-testen meestal op tegen de nadelen. Als je de beste werkwijzen volgt en unit-testen onderdeel maakt van je workflow, kan het je helpen betere software te bouwen.
