M365Con 2027 – gratis online conferentie · 11–22 Jan 2027 · 120 sessions→ m365con.net

Blog · Mirko Peters

Unittests, integratietests en end-to-end-tests: waar AI het meeste helpt

By · · Updated

Unittests versus integratietests versus end-to-end-tests: wat elk controleert, hoeveel je er moet schrijven en waar AI het meeste helpt, van het opstellen van unittests tot het nakijken van browserflows.

Automatically translated with AI from the original post. Read the English original

Unittests, integratietests en end-to-end-tests: dat is de vraag achter elke teststrategie voor software. Elk niveau controleert iets anders, kost iets anders en geeft een ander soort zekerheid. Deze gids is bedoeld voor QA-leads die gevraagd worden waar AI in het softwaretesten een plek moet krijgen. Je ziet wat elk niveau controleert, hoeveel tests van elk soort een gezonde suite bevat, waar AI het meeste helpt en waar het extra risico oplevert. Een uitgewerkt voorbeeld met verzonnen cijfers laat zien hoe één team heeft bepaald waar het zijn inspanning in stopte.

Belangrijkste punten

  • Een unittest controleert één stuk code, een integratietest controleert de koppeling met iets buiten de applicatie, en een end-to-end-test doorloopt het uitgerolde systeem via de interface.
  • De testpiramide zegt dat je veel kleine, snelle unittests moet schrijven, een aantal grovere tests en heel weinig tests op hoog niveau, omdat hogere niveaus trager zijn en meer onderhoud vragen.
  • AI is het nuttigst waar de output klein is en makkelijk te controleren, zoals bij het opstellen van unit- en API-tests, en waar een persoon elke gegenereerde test kan nakijken.
  • Door AI gegenereerde tests kunnen de codedekking opblazen zonder het gedrag te valideren, bijvoorbeeld tests die code uitvoeren maar zwakke of ontbrekende asserties hebben.
  • Behandel AI-output op elk niveau als concept, en houd menselijk oordeel voor dubbelzinnige flows, visuele controles en toegankelijkheidsreviews.

Unittests, integratietests en end-to-end-tests: wat elk controleert

Martin Fowlers artikel The Practical Test Pyramid geeft duidelijke definities.

  • Unittests zorgen ervoor dat een bepaald onderdeel van je codebase, het testobject, werkt zoals bedoeld. Ze hebben de smalste scope van alle testtypen. Dit is het niveau van unittesting dat ontwikkelaars het vaakst schrijven.
  • Integratietests controleren de integratie van je applicatie met onderdelen die erbuiten liggen, zoals een database, een bestandssysteem of een afzonderlijke service. Fowler geeft de voorkeur aan smalle tests die één externe integratiepunt tegelijk testen. Dit is het werk van integratietesten.
  • End-to-end-tests testen de uitgerolde applicatie via de gebruikersinterface en dekken het volledige geïntegreerde systeem. Fowler noemt ze brede stack-tests. Dit is end-to-end-testen.

Het belangrijkste verschil tussen unittesten en integratietesten is de scope: één onderdeel van de code tegenover de koppeling tussen onderdelen. Functionele tests en systeemtests controleren de software ook van buitenaf, en e2e-testen is de browsergedreven variant, dus spreek af welke termen je gebruikt.

Ontwikkelaars schrijven meestal unittests en draaien die bij elke commit. Onthoud het verschil aan de hand van de vraag die elk niveau beantwoordt: een unittest vraagt of deze functie correct is. Een integratietest vraagt of we correct met dit andere systeem communiceren. Een end-to-end-test vraagt of een gebruiker deze reis kan voltooien.

Hoeveel van elk: de testpiramide

De testpiramide is de gebruikelijke manier om de balans te beschrijven. Fowler adviseert om veel kleine en snelle unittests te schrijven, een aantal grovere tests en heel weinig tests op hoog niveau. Hij formuleert het als regel: hoe hoger het niveau, hoe minder tests je moet hebben.

De reden is kosten. Volgens het artikel loopt unittesting heel snel, zijn integratietests meestal veel trager omdat er echte externe onderdelen bij betrokken zijn, en draait end-to-end testen behoorlijk traag. End-to-end testen vraagt ook veel onderhoud en staat bekend om zijn onbetrouwbaarheid.

Die onbetrouwbaarheid is op schaal meetbaar. Een post op de Google Testing Blog, Flaky Tests at Google and How We Mitigate Them, meldt dat ongeveer 1,5 procent van de testruns een wisselend resultaat gaf en bijna 16 procent van de tests enige onbetrouwbaarheid vertoonde.

Alle drie de niveaus dragen bij aan regressietesten, omdat ze na elke wijziging opnieuw worden uitgevoerd.

Fowler waarschuwt ook voor de omgekeerde vorm, die hij de testijsjeskegel noemt: veel handmatige en browsergebaseerde tests bovenaan, weinig unittests onderaan. Hij beschrijft dit als een nachtmerrie om te onderhouden die veel te lang duurt om te draaien. Als je testset er zo uitziet, zal AI de vorm niet verbeteren. Het levert mogelijk alleen sneller meer van de trage tests op.

Unittesting versus integratietesten: wanneer je welk niveau gebruikt

De vergelijking van TestRail tussen unit- en integratietesten somt praktische verschillen op. Unittests zijn snel te implementeren en snel uit te voeren, en ze worden meestal door ontwikkelaars gedaan. Bij integratietesten zijn vaak QA-engineers en testers betrokken. Unittests gebruiken mocks en stubs om externe systemen te vermijden, terwijl integratietesten zich richten op echte interacties, maar toch mocks kunnen gebruiken als een externe service niet beschikbaar, onbetrouwbaar of kostbaar is.

De voordelen van unittesten zijn snelle feedback, vroege detectie van bugs en modulairder code. De zwakte is dat een set unittests niet laat zien of de onderdelen samen werken, en dat is wat integratietesten toevoegen. TestRail adviseert unittests voor geïsoleerde logica vroeg in de ontwikkeling, en integratietests voor workflows die modules, databases of externe diensten overspannen. Het beschrijft twee manieren om die laatste uit te voeren: Big Bang, waarbij alles na de ontwikkeling samen wordt getest en wat lastiger te debuggen is, en incrementeel, waarbij kleine groepen stap voor stap worden getest, waardoor problemen makkelijker te lokaliseren zijn.

Fowler geeft een regel om het niveau te bepalen: als een test op hoger niveau een fout vindt en geen enkele test op lager niveau faalt, schrijf dan een test op lager niveau. Duw tests zo ver mogelijk naar beneden in de piramide, en verwijder tests op hoog niveau die dubbel werk zijn met wat lagere niveaus al dekken. Een complete teststrategie gebruikt alle drie de niveaus, waarbij elk hoger niveau zich richt op wat de lagere niveaus niet kunnen dekken.

Twee verwante vragen komen vaak voor. Fowler merkt op dat sommigen de middenlaag integratietests noemen en anderen componenttests, en dat afspraken over de termen belangrijker zijn dan de naam. Hij zegt ook dat acceptatietests, die de software vanuit het perspectief van de gebruiker controleren, op elk niveau kunnen zitten, en dus staan ze loodrecht op de piramide. Unittesten en end-to-end testen zijn daarom de twee uiteinden van één schaal, geen concurrerende scholen.

Deze tests zijn eenvoudig te automatiseren in een pipeline. TestRail zegt dat unittests meestal vroeg draaien, vaak direct na een push of pull request, en dat integratietests later draaien, zodra de app is uitgerold naar een staging- of testomgeving. Samen vormen ze een kwaliteitspoort.

Waar AI het meeste helpt

Tools op basis van generatieve AI verschillen, maar in de richtlijnen van leveranciers zie je een patroon. Het Parasoft-artikel over hoe AI wordt gebruikt bij softwaretesten adviseert teams om unit- en API-tests te genereren terwijl wijzigingen nog vers zijn. Het noemt ook dat AI helpt bij het maken van API-tests, het voorstellen van asserties en het opbouwen van datascenario's. Verder merkt het op dat service virtualization, waarmee trage, kostbare of niet-beschikbare afhankelijkheden worden gesimuleerd, integratietesten ondersteunt.

Dit past bij de piramide. De redenen zijn onze eigen gevolgtrekking, geen meting:

  • Kleine output is makkelijk te reviewen. Een gegenereerde unittest bestaat uit een paar regels. Een reviewer kan hem lezen, uitvoeren en binnen een minuut bepalen of hij het juiste controleert.
  • Snelle feedback legt slechte tests bloot. Een unittest die fout is, faalt of slaagt snel, zodat je het probleem dezelfde dag vindt.
  • Duidelijke invoer en uitvoer. Functies en API-aanroepen hebben gedefinieerde invoer en uitvoer, zodat een tool een precies doel heeft.
  • Veel repetitieve gevallen. Grenswaarden en foutpaden zijn bij unittesten repetitief, en een concept bespaart typewerk.

Laat AI concepten maken, maar laat een persoon de verantwoordelijkheid dragen: wie een gegenereerde test accepteert, is verantwoordelijk voor wat die controleert, net als bij een test die met de hand is geschreven.

Voor integratietesten kan AI een testcase of testdata als concept opstellen en afhankelijkheden simuleren, maar een persoon moet bepalen wat het contract met het andere systeem is, en integratietesten verifiëren juist dat contract.

Op het niveau van end-to-end testen helpt AI op een andere manier. Tools die stappen in gewone taal in een browser uitvoeren, kunnen de kosten van het schrijven van een gebruikersreistest verlagen. Ze veranderen de kosten van het uitvoeren ervan niet, en ze nemen de noodzaak van een duidelijke regel voor geslaagd of mislukt niet weg.

Waar AI het minst helpt, en waar je op moet letten

Het Parasoft-artikel is duidelijk over de grenzen. Het stelt dat menselijke review bij elke door AI gegenereerde wijziging moet blijven en dat je AI-output als concept moet behandelen. Het stelt dat AI, slecht gebruikt, de dekking kan opblazen zonder gedrag te valideren, en het waarschuwt voor lege tests die codepaden doorlopen maar zwakke of ontbrekende asserties hebben. Het noemt uitvoer die per run afwijkt bij dezelfde invoer een waarschuwingssignaal. Verder stelt het dat AI geen veiligheidskritieke wijzigingen kan goedkeuren en menselijk oordeel niet kan vervangen bij dubbelzinnige processen, visuele controles en toegankelijkheidsreviews. Voor data waarschuwt het tegen prompts die geheimen of gereguleerde gegevens bevatten.

Testストラテジーen die AI gebruiken, hebben vier controles nodig:

  1. Dekking die stijgt maar niets vangt. Controleer asserties, niet alleen de dekkingscijfers.
  2. Tests die de code spiegelen. Een test die de implementatie herhaalt, slaagt ook als de logica fout is.
  3. Onstabiele output. Als een gegenereerde test tussen runs verandert, leg dan de versie vast die je hebt gereviewd.
  4. Data die het gebouw verlaat. Plak geen geheimen, klantgegevens of gereguleerde gegevens in een prompt.

Voorbeeld: waar één team zijn inspanning in stopt

De cijfers zijn verzonnen.

Een team heeft 600 geautomatiseerde tests: 450 unittests, 110 integratietests en 40 end-to-end tests. De browsertests nemen 50 minuten van een pipeline van 60 minuten in beslag, en zes ervan falen elke week willekeurig.

De QA-lead doet drie zetten. Ten eerste maakt een AI-assistent concepten van unittests voor nieuwe code, en een ontwikkelaar reviewt elk concept. In de eerste maand levert de assistent 120 tests op. Reviewers wijzen er 30 af omdat de asserties zwak zijn, dus 90 komen in de suite terecht.

Ten tweede maakt AI concepten van testdata voor de integratietests, en de contracten blijven met de hand geschreven.

Ten derde krijgen de 40 end-to-end tests geen AI-ondersteuning. De lead verwijdert zes duplicaten die al door een snellere test op lager niveau worden gedekt, en de pipeline daalt van 60 naar 48 minuten. De AI-inspanning ging naar de plek waar review het goedkoopst is, en de trage laag werd kleiner.

Veelgemaakte fouten

  • AI gebruiken om meer browsertests toe te voegen. De trage, onstabiele laag groeit, en de pipeline wordt trager.
  • Gegenereerde tests ongelezen accepteren. Zwakke asserties geven dekking zonder veiligheid.
  • Succes meten aan het aantal tests. Tel in plaats daarvan de gevonden defecten en de bespaarde minuten.
  • Integratietesten overslaan. Unittests plus een paar gebruikersreizen kunnen kapotte contracten tussen systemen missen.
  • Gevoelige gegevens in prompts plakken. Stel een beleid op voordat je de eerste prompt invoert.

Hoe software kan helpen

Je bestaande testframework en CI-systeem rapporteren al de looptijden en faalpercentages. Begin daar en groepeer de cijfers per niveau. Code-reviewtools helpen bij de AI-concepten, omdat reviewers de gegenereerde test naast de code kunnen zien. Lees dekkingstools naast een asserties-controle, zodat dekking niet voor kwaliteit wordt aangezien. Voeg een AI-assistent eerst toe aan één niveau van softwaretesten en vergelijk de reviewtijd, afgewezen concepten en ontsnapte defecten voordat je de pilot uitbreidt.

Volgende stap

Tel je tests op elk testniveau en noteer de looptijd en het percentage instabiele tests van elk niveau. Kies daarna één niveau voor een AI-pilot en schrijf op wat je gaat meten, zodat je volgende discussie over unit- vs. integratie- vs. end-to-end tests begint met data.

Entities in this article

Unit testing Integration testing End-to-end testing Generative AI

Related articles

RSS