Als je ooit een bug in je code hebt moeten opsporen, weet je hoe frustrerend het kan zijn. Deze frustratie neemt alleen maar toe als je aan een grote codebase werkt.
Door te testen kunt u controleren of de resultaten van uw code overeenkomen met uw verwachtingen. Op deze manier kunt u een probleem gemakkelijk identificeren en oplossen voordat u uw toepassing implementeert. Testen helpt je niet alleen om codefouten sneller op te sporen, maar dwingt je ook om goede code te schrijven.
1. Statisch testen
Statisch testen verwijst naar tests die worden uitgevoerd zonder code uit te voeren. Dit gebeurt door de code te vergelijken met eerder ingestelde codeerregels. De gebruikelijke manieren om statische tests uit te voeren, zijn pluizen en typecontrole.
Linting houdt in dat de code wordt gecontroleerd op programmeer- en stijlfouten. Een linter analyseert de code en signaleert mogelijke fouten. Voorbeelden van linting-tools zijn EsLint, PyLint en CSSLint.
Typecontrole is het proces van het afdwingen van typeregels en beperkingen op waarden. Sommige programmeertalen zijn sterk getypeerd, wat betekent dat ze fouten veroorzaken wanneer waarden niet goed zijn getypt.
Sommige talen, zoals JavaScript, hebben echter een zwak typesysteem en zijn meer vergevingsgezind. In deze talen zijn fouten moeilijk te ontdekken en is een bibliotheek voor typecontrole essentieel. Voor JavaScript kunt u: gebruik TypeScript om krachtig typen af te dwingen.
U kunt ook statische analysetools gebruiken om code automatisch te analyseren. Deze tools verifiëren de kwaliteit van de code en rapporteren over eventuele problemen die worden gevonden. Voorbeelden van statische analysetools op de markt zijn SonarQube, DeepSource en SpotBugs. Zorg er bij het kiezen van een statische analyser voor dat deze uw programmeertaal ondersteunt.
2. Eenheidstests
Unit tests controleren de kleinste testbare onderdelen van een applicatie om te bepalen of ze werken zoals verwacht. U kunt eenheidstests schrijven voor functies, modules, objecten, enz.
Hoewel eenheidstests tijdrovend kunnen zijn, zouden ze meer tijd moeten besparen dan u zou besteden de applicatie debuggen nadat je alle code hebt geschreven.
Over het algemeen bestaat unit-testen uit vier stappen:
- De tests maken
- De test beoordelen
- basislijn
- Het uitvoeren van de test.
U kunt unit-tests handmatig schrijven of automatiseren met behulp van een unit-testraamwerk. Bij een handmatige test zou u code schrijven om de functie of eenheid die u nodig hebt te testen, en later de testcode verwijderen.
Als u een raamwerk gebruikt, specificeer dan de eenheid die u aan het testen bent en de verwachte resultaten, en voer vervolgens de test uit. Het toetsingskader registreert dan de falende en geslaagde tests. Het is over het algemeen beter om een framework te gebruiken omdat het sneller is.
Zorg er bij het schrijven van een eenheidstest voor dat de eenheid die u test onafhankelijk is. Als het afhankelijk is van externe gegevens zoals variabelen, kunt u mocks gebruiken. Mocks vervangen de ontbrekende gegevens die in het apparaat worden gebruikt.
Als u bijvoorbeeld een functie test die afhankelijk is van gegevens opgehaald uit een API, kunt u een nepgegevensobject maken voor testdoeleinden.
3. Integratietests
Integratietests controleren hoe verschillende componenten samen functioneren. Dit in tegenstelling tot unit tests die onafhankelijke componenten testen. Je schrijft integratietesten na unittests.
Integratietests zijn essentieel omdat ze ervoor zorgen dat uw toepassingslogica klopt.
Overweeg bijvoorbeeld twee modules: een die gegevens ophaalt uit een API en een andere die deze analyseert. U wilt er zeker van zijn dat uw code de juiste gegevens heeft opgehaald en correct heeft geanalyseerd.
Dit is waar integratietesten om de hoek komen kijken. Het zorgt ervoor dat er geen fouten optreden in de logische stroom van de ene module naar de andere.
4. End-to-end-tests
End-to-end testen controleert de applicatiestroom vanuit het perspectief van de eindgebruiker. Het proces test de applicatie van begin tot eind, aangezien de gebruiker de applicatie zal gebruiken. Deze tests bieden meer dekking dan unittests of integratietests.
End-to-end tests definiëren de afhankelijkheden, databases en externe communicatie van de applicatie. Ze bootsen een realistisch scenario zo nauwkeurig mogelijk na.
Bij het testen van een aanmeldingsformulier zal een end-to-end-test bijvoorbeeld verschillende scenario's testen, zoals:
- Een gebruiker die zowel het e-mailadres als het wachtwoord invoert
- Een gebruiker die een zwak wachtwoord gebruikt
- Een gebruiker die een ongeldig e-mailadres gebruikt
- Een gebruiker die alleen een e-mail verzendt
- Een gebruiker die alleen een wachtwoord invoert
De end-to-end-tests zorgen ervoor dat de toepassing zich in deze scenario's gedraagt zoals verwacht.
Schrijftests vs. Code schrijven
Het is van vitaal belang om uw applicatie vroeg in het ontwikkelingsproces te testen. Hoewel al deze tests essentieel zijn, is het belangrijk om een balans te vinden die voor u werkt. Anders besteed je te veel tijd aan het schrijven van tests in plaats van code.
Het testen van eenheden is cruciaal voor de meeste toepassingen en misschien wilt u er voldoende tijd aan besteden. Zodra u unit tests uitvoert, kunt u er zeker van zijn dat de bouwstenen van uw applicatie correct werken.