Unit-, integratie- en end-to-endtests onderzoeken software op verschillende niveaus, en leggen daardoor ook verschillende soorten fouten bloot. Lees hoe je per niveau een passende test kiest en welke rol testdekking, onderhoudbaarheid en testomgevingen spelen. Een freelance developer kan helpen om die teststrategie op je software af te stemmen.
Testniveaus kiezen op basis van de fout die je wilt vinden
Je kiest een testniveau op basis van het deel van het systeem dat je wilt controleren. Bij een unit test pak je één specifiek stukje, bijvoorbeeld een functie of klasse. Integratietest? Dan kijk je juist of die onderdelen samen functioneren zoals verwacht. En een end-to-endtest? Die loopt een hele gebruikersroute door, van de interface tot alles wat daarachter ligt. Zo bepaal je niet alleen de omvang, maar vooral ook waar je een fout zichtbaar wilt maken.
Stel: een rekenfout in een bedrag komt voort uit verkeerde logica, dan hoort die thuis in een unit test. Verschijnt die foute waarde in de database? Ga dan voor een integratietest. Komt het verkeerde totaalbedrag uiteindelijk bij de gebruiker op het scherm, terwijl jouw code in orde lijkt? Dan spoort een end-to-endtest de fout op die door alle lagen is geslopen. Eén probleem duikt soms op meerdere plekken op, maar testen dichtbij de bron maken het makkelijker om gericht te zoeken.
Dus: zet niet automatisch alles op één testniveau. Kijk naar waar je het probleem verwacht, wat het kost als het misgaat en welke afhankelijkheden je erbij nodig hebt. Zo voorkom je dat je een zware end-to-endtest gebruikt voor het vangen van een simpele programmeerfout, of juist een cruciale ketenfout mist door die alleen op detail te testen.
Unit tests vinden fouten in logica en randgevallen
Met een unit test controleer je één afgebakend onderdeel in isolation. Denk aan een functie die iets valideert, een klasse die een status wijzigt, of een module die een rekensom uitvoert. Omdat je weinig afhankelijkheden meeneemt, vind je de oorzaak van een mislukte unit test meestal snel. Handig bij voorwaarden, grenswaarden, het afvangen van fouten en combinaties van invoer die je niet dagelijks ziet langskomen.
Test niet alleen het gebruikelijke pad. Kijk bijvoorbeeld naar lege invoer, waarden precies op een grens, foute combinaties, of situaties waarin een dependency (zoals een klok of externe dienst) je test zou kunnen verstoren. Gebruik daarvoor een mock of stub: je bootst het gedrag dan na, zodat schommelingen in een externe service geen afleiding zijn. Dan test je de kernlogica, in plaats van een storing op de lijn.
Let op: te veel gebruik van mocks maakt je test minder realistisch. Je kunt zo voorbij gaan aan problemen die in de praktijk tussen je code en een dependency ontstaan. Houd je dus bij het testen van de eigen logica, en grijp alleen naar mocken als dat nodig is voor het isoleren van de juiste grens. Als de functie aan de buitenkant niet verandert, hoeft de test niet per se aangepast te worden bij refactoring.
Test je maatwerk in WordPress? Lees meer over WordPress-plug-ins.
Integratietests controleren contracten tussen onderdelen
Integratietests laten je zien of componenten daadwerkelijk volgens afspraak met elkaar werken. Voorbeelden: applicatiecode die iets in een database schrijft, een API die een bericht op een queue zet, of een client die een externe service aanroept. Je controleert niet puur logica, maar juist details als veldnamen, serialisatie, foutcodes, transacties en de interpretatie van lege of ontbrekende waarden.
Vaak ontstaat een fout doordat twee onderdelen allebei correct lijken, maar elkaars verwachtingen niet snappen. Denk aan een datum die in het verkeerde formaat van applicatie naar database gaat, of dat een API-wijziging alleen zichtbaar wordt als alles samen draait. Met een echte database of representatieve mock-service spoor je mismatches op die je met stubs niet vindt.
Ga na wat je wilt checken als je kiest tussen een echte dependency, container of nagebootst gedrag. Gebruik een echte database als je queries, constraints en migraties controleert; simuleer een extern systeem als je wilt voorkomen dat je afhankelijk bent van beschikbaarheid of limieten. Betrek niet teveel systemen tegelijk, want bij meer koppelingen wordt het lastiger om de schuldige te vinden. Focus op de verbindingen waar afwijkingen echt pijn doen. Voor PHP-applicaties kun je ook een beroep doen op een PHP developer.
End-to-endtests toetsen complete gebruikersroutes
Met een end-to-endtest voer je alles uit alsof je de gebruiker bent, van invullen tot het uiteindelijke resultaat op het scherm. Je test zo bijvoorbeeld het doorlopen van een formulier, het indienen van een aanvraag en het tonen van de status in de user interface. Dit combineert gedrag uit de browser, je applicatielogica, API's, opslag, configuratie. Alles samen, dus.
Hiermee vind je fouten die uit de hele keten komen. Denk aan uitzonderingstoestanden: de knop werkt niet door een frontend-wijziging, een route is verkeerd gekoppeld, het authenticatiecookie ontbreekt, of een achtergrondtaak doet niets. Je ziet zo dat de applicatie technisch draait, maar de gebruiker er alsnog niets aan heeft. Maar als zo’n test faalt, ligt de oorzaak niet meteen voor het oprapen.
Beperk daarom het aantal scenario’s tot trajecten waar bedrijf of gebruiker echt wat te verliezen hebben. Tests worden onbetrouwbaar als selectors afhangen van veranderlijke CSS-klassen, of als je vaste wachttijden en gedeelde accounts gebruikt. Kies vaste ankerpunten, wacht op concrete signalen, en houd testdata gescheiden waar het kan. Met end-to-endtests controleer je geen rekenregels of edge cases; dat werkt sneller en grondiger in andere lagen.
Testdekking zegt niet hoeveel fouten je daadwerkelijk vindt
Testdekking betekent: hoeveel van je code komt er tijdens tests voorbij. Dat vertelt iets, maar een hoog getal betekent nog niet dat de belangrijkste uitkomsten zijn gecontroleerd. Een regel kan wel uitgevoerd zijn, zonder dat iemand kijkt of het resultaat klopt. Met een kleine hoeveelheid goed gekozen tests kun je bovendien soms meer relevante risico’s afvangen, zeker als die focussen op belangrijke beslissingen en foutafhandeling.
Let op het verschil tussen regeldekking, takdekking en daadwerkelijk gedrag. Regeldekking toont welke regels je raakt; takdekking pakt alternatieven van voorwaarden mee. Maar geen van beide laat automatisch zien of je assertions ertoe doen. Een test die alleen checkt of een functie niet crasht, kan slagen terwijl die dezelfde foute waarde blijft teruggeven. Combineer dekking met het beoordelen van cases, code reviews en aandacht voor risicovolle domeinregels.
Een target voor dekking maakt ongeteste code zichtbaar, handig dus. Maar mik je alleen op een bepaald percentage, dan levert dat soms lege of oppervlakkige tests op. Gebruik dekking om blinde vlekken in beeld te krijgen. Is de dekking lager geworden bij een betalingsproces, autorisatie of belangrijke validatie? Dat verdient meer aandacht dan bij iets wat nauwelijks impact heeft als het misgaat.
Onderhoudbare tests controleren gedrag zonder de implementatie vast te zetten
Testcode is óók software. Je moet begrijpen wat een test precies controleert, waarom een fout relevant is, en waar je dan moet zoeken. Goede naamgeving, korte scenario’s en assertions die één heldere uitkomst toetsen, helpen je hierbij. Hulpmethoden kunnen code herhalen voorkomen, maar vage of impliciete testlagen maken niet altijd duidelijk wat er getest wordt.
Het beste zijn tests die contracten en zichtbaar gedrag vastleggen, niet willekeurige details van de uitvoering. Leg je vast welke interne methode als eerste wordt aangeroepen, dan breken je tests misschien bij een onschuldige wijziging. Soms is het belangrijk om interacties te checken, bijvoorbeeld als maar één bericht mag worden verstuurd. Leg die verwachting dan vast als onderdeel van je contract, en vermijd het stuk voor stuk navlooien van interne stappen.
Flaky tests zijn tests die soms lukken en soms niet, zonder echte reden. Vaak veroorzaakt gedeelde toestand, parallel testen, tijdgevoeligheid of willekeurige data zo’n probleem. Een automatische retry maskeert dat tijdelijk, maar lost de echte oorzaak niet op. Zorg voor voldoende foutinformatie bij mislukken, maak testdata uniek en wacht niet zomaar een paar seconden, maar op een zichtbaar resultaat. Haal tests weg die je geen bruikbaar signaal meer geven, of repareer ze. Lees ook over logging en foutafhandeling bij betrouwbare automatisering.
Testomgevingen bepalen hoe betrouwbaar resultaten zijn
Een test stelt alleen wat voor als de omgeving klopt. Unit tests draaien meestal makkelijk lokaal en vragen weinig infrastructuur. Integratietests hebben vaker een database, queue of testservice nodig (al dan niet in een container). End-to-endtests willen een browser, auth, achtergrondtaken en testdata die bij elkaar passen. Zit er een verschil tussen je lokale omgeving en de production setting, dan kunnen fouten onder de radar blijven.
Maak je omgevingen steeds hetzelfde aan: houd bij welke versie je draait van een database, voer je migraties identiek uit, leg configuratie vast. Als je afhankelijk bent van handmatig aangemaakte testaccounts of achtergebleven data, dan veroorzaak je onvoorspelbare testresultaten. Laat testdata automatisch maken en opruimen als het even kan, en geef iedere test apart zijn eigen gegevens als je parallel runt.
Je hoeft niet altijd te clonen wat in productie draait. Een apart testexemplaar van de database voorkomt bijvoorbeeld ruis van andere teams. Gesimuleerde externe diensten kunnen je meer grip geven bij end-to-end, maar daarmee weet je niet zeker of de provider het contract echt volgt. Kies per dependency: wanneer is isolatie handig, wanneer representativiteit? Noteer welke risico’s je daarmee wel of juist niet afdekt.
Verdeel testscenario’s op basis van snelheid, risico en diagnose
Een praktische testopzet combineert verschillende niveaus. Unit tests werken goed voor veel logische varianten, draaien snel en geven direct aan waar het mis is. Integratietests zijn nuttig rond grenzen waarop data, protocollen of instellingen samenkomen. End-to-endtests controleer je voor een beperkt aantal routes die echt bedrijfskritisch zijn, of belangrijk voor de gebruiker. Hoe je verdeelt? Niet standaard, maar afhankelijk van je software: veel complexe rekenregels? Meer unit tests. Belangrijke koppelingen? Extra integratiechecks.
Stel jezelf drie vragen per scenario: hoe groot zijn de gevolgen bij falen, op welk niveau kun je de fout het scherpst isoleren, en wat heb je qua omgeving echt nodig om betrouwbaar te testen? Een lastige validatieregel is spotgoedkoop en exact te voorzien van unit tests, een constraint in de database test je het handigst met een echte database als integratietest. Een belangrijke inlogroute verdient soms een aanvullende end-to-endtest, ondanks afdekking op detailniveau.
Krijg je een incident, kijk dan op welk niveau dat eerder gespot had kunnen worden. Een ingewikkelde berekening glipt soms door tot productie, voeg dan een unit test toe. Blijkt het om een API-mismatch te gaan? Zet in op sterke integratietests bij dat raakvlak. Elke fout met een end-to-endtest gaan afdekken vertraagt je suite en maakt zoeken naar oorzaken onduidelijk. Het doel is niet dat iedere bug reproduceerbaar is, maar dat je weet tot welke klasse hij hoort.
Veelgestelde vragen
In welke volgorde voer je unit-, integratie- en end-to-endtests uit in een CI-pipeline?
Begin met de snelle unit tests, dan de integratietests, en eindig met de end-to-endtests. Zo zie je snel of er basale dingen misgaan, maar voer je toch diepere controles uit voor je iets echt doorvoert.
- Laat unit tests telkens draaien bij elke commit of pull request.
- Start integratietests als alle benodigde delen van je app en extra services beschikbaar zijn.
- Zet end-to-endtests na succesvolle eerdere stappen aan, eventueel tegelijk voor verschillende scenario’s.
Kritische gebruiksroutes kan je niet altijd tot de nacht wachten: een kleine, essentiële set aan end-to-endtests kan soms direct na elke wijziging nodig zijn. De rest hoeft misschien maar eens per dag te lopen. Zorg altijd dat je weet welke testlaag of wijziging aandacht vraagt, als iets faalt.
Wat is mutation testing en wanneer is het nuttig?
Mutation testing werkt zo: een tool past kleine willekeurige veranderingen toe op je code (zoals het omdraaien van een vergelijking), en kijkt of je tests dit opmerken. Slaat iedere test dan nog steeds groen uit? Dan heb je waarschijnlijk een test die de uitkomsten niet echt checkt.
- Draai mutation testing vooral voor stukken logica waar fouten veel pijn kunnen doen, zoals prijzen of autorisatie.
- Kijk kritisch naar mutaties die blijven leven en schrijf alleen nieuwe tests als ze echt van belang zijn.
- Behandel het percentage mutaties niet als doel op zich; sommige mutaties boeien simpelweg niet, andere zijn lastig te vangen.
Mutation testing kost extra tijd en middelen, dus het vervangt je gewone tests niet. Handig als hulpmiddel om te zien waar je assertions tekortschieten, niet als permanente bescherming voor al je code.
Hoe voeg je tests toe aan een legacy-applicatie zonder alles eerst te refactoren?
Plaats nieuwe tests rondom het bestaande gedrag dat je wilt behouden, zonder meteen alles te gaan herschrijven. Je legt zo vast hoe de code zich nu gedraagt en verkleint de kans dat je per ongeluk iets belangrijks sloopt wanneer je een bug fix toepast.
- Kies een specifieke bugfix of kleine wijziging als startpunt.
- Zet je test zo neer dat hij het bestaande gedrag betrouwbaar waarneemt, op het best bereikbare niveau.
- Krijg je de code niet makkelijk getest, voeg dan een kleine vervangbare dependency toe. Een hele module herschrijven is vaak niet nodig.
Breid testdekking uit terwijl je werkt aan nieuwe onderdelen. Tijdelijke karakteriseringstests hoeven niet alles vast te leggen; focus op uitkomsten die voor gebruikers en andere delen van het systeem cruciaal zijn.
Hoe test je een integratie met een externe API zonder die API bij elke test aan te roepen?
Meestal test je een externe API door de meeste oproepen te mocken, en een periodieke check te doen tegen de echte API. Dan blijven je tests snel, en ben je niet afhankelijk van de uptime of limieten van de provider.
- Gebruik ge-mockte antwoorden om je applicatie te testen op succes, fouten en onverwachte responses.
- Als er een sandbox beschikbaar is, kun je daarmee echte authenticatie en het API-contract valideren.
- Bewaak privacy: sla geen live resultaten met gevoelige info op. Anonimiseer, wis geheimen, en let op mogelijke lekinformatie.
Mocks tonen niet dat de echte provider zich aan het contract houdt. Plan daarom regelmatig een échte check met sandbox of gerichte live-aanroep, en zorg dat een tijdelijke storing daar niet je hele testrun op slot zet.
Mag je productiegegevens gebruiken in een testomgeving?
Gebruik productiegegevens alleen in een testomgeving als het absoluut niet anders kan, en regel dan privacy en beveiliging goed. Productiedata bestaat vaak uit persoonsgegevens, bedrijfsinformatie of andere gevoelige data die buiten de originele omgeving niet veilig is.
- Kies waar mogelijk gesimuleerd materiaal en dek relevante cases af.
- Heb je een echte dataset nodig, zorg dan dat je geanonimiseerd of gemaskeerd werkt en check goed dat de gegevens niet makkelijk terug te herleiden zijn.
- Beperk wie erbij kan, hoe lang je het bewaart en waar je data opslaat; gooi alles weg zodra het niet meer nodig is.
Kijk niet alleen naar de testbestanden: gevoelige data zit soms ook in logs, screenshots of foutmeldingen. Stem je aanpak af op wat het privacybeleid voorschrijft, houd de wetgeving in het oog, en leg vast wie de verantwoordelijkheid draagt voor zulke datasets.
Foto: EqualStock IN