Flaky end-to-end tests: waarom ze falen en hoe je ze terugbrengt
By Mirko Peters · · Updated
Flaky end-to-end tests slagen en falen zonder dat de code verandert. Lees welke vijf oorzaken er vaak zijn, hoe je waits en testdata oplost, en wat je doet met tests die je niet kunt repareren.
Automatically translated with AI from the original post. Read the English original
Flaky end-to-end tests zijn geautomatiseerde browsertests die op de ene run slagen en op de volgende falen, zonder dat de code, de test of de omgeving is veranderd. Deze gids is bedoeld voor QA-leads en automatiseringsengineers die meer tijd kwijt zijn aan het opnieuw draaien van rode builds dan aan het oplossen van bugs. Je ziet waarom deze tests flaky zijn, wat de vijf gangbare oorzaken zijn, hoe je de ergste daarvan (wachten) oplost, en hoe je tests beheert die je nog niet kunt repareren. Een uitgewerkt voorbeeld met verzonnen cijfers laat zien hoe je de grondoorzaak in drie stappen vindt.
Belangrijkste punten
- Een flaky test slaagt soms en faalt soms, zonder dat de code, de test of de omgeving is veranderd. Een fout zegt dus niets zolang je de run niet herhaalt.
- Google meldde dat ongeveer 1,5 procent van de testruns flaky was en bijna 16 procent van de tests enige mate van flakiness vertoonde. Flakiness is op schaal dus normaal en vraagt om een plan.
- De vijf gangbare oorzaken zijn gedeelde status, timing, externe diensten, de systeemklok en gelekte resources. Timing is in browsertests het eerste om te controleren.
- Vervang vaste pauzes door waits op een zichtbare conditie, en geef elke test zijn eigen data, zodat tests elkaar niet kunnen verstoren.
- Zet een flaky test tijdelijk in quarantaine, maar begrens hoeveel tests er mogen staan en hoelang. Anders verliest de regressiesuite langzaam zijn waarde.
Waarom flaky tests zoveel schade doen
Een test is flaky wanneer het resultaat niet reproduceerbaar is. Martin Fowlers artikel over non-determinisme in tests definieert een niet-deterministische test als een test die "soms slaagt en soms faalt", "zonder merkbare verandering in de code, de tests of de omgeving."
De schade komt door verlies van vertrouwen. Als een rode build een echte bug kan zijn of ruis, leren mensen rode builds te negeren. Dan glipt een echte fout erdoorheen. Teams verspillen ook tijd: elke fout moet opnieuw gedraaid worden voordat iemand kan zeggen of het ertoe doet. Een instabiele testsuite vertraagt ook de CI-pijplijn, omdat elke mislukte testrun wacht op een herhaling en de merge-wachtrij erachter blokkeert.
De cijfers van grote systemen laten zien dat dit normaal is, niet zeldzaam. In een bericht op de Google Testing Blog, Flaky Tests at Google and How We Mitigate Them, staat dat ongeveer 1,5 procent van alle testruns een flaky resultaat gaf en bijna 16 procent van de tests enige mate van flakiness had. Er staat ook dat ongeveer 84 procent van de overgangen van geslaagd naar gefaald die het bericht observeert een flaky test betreft, en dat het gemiddelde project ongeveer 1.000 afzonderlijke tests bevat. Jouw cijfers zullen anders zijn, maar de les blijft gelden: op schaal is flakiness een zekerheid, dus je hebt een proces nodig.
Browsergebaseerde end-to-end testing is bijzonder kwetsbaar. Elke test is afhankelijk van een browser, een netwerk, een uitgerolde applicatie, testaccounts en vaak diensten van derden. Meer bewegende delen betekent meer kansen om te variëren. Daarom zijn e2e-tests doorgaans minder stabiel dan unit tests, die veel minder bewegende delen hebben.
De vijf gangbare oorzaken van flaky end-to-end tests
Fowlers artikel noemt vijf veelvoorkomende oorzaken. Elk ervan geldt ook voor browsertests.
- Gebrek aan isolatie. Tests delen status, zoals databaserecords of een ingelogde sessie, waardoor de ene test ziet wat een andere test heeft gewijzigd. Oplossing: bouw de beginsituatie opnieuw op voor elke test, of ruim na afloop op.
- Asynchroon gedrag. De pagina heeft tijd nodig om te reageren, en de test handelt te vroeg of te laat. Fowler adviseert om nooit vaste pauzes (sleeps) te gebruiken om op asynchrone reacties te wachten, maar een callback of polling te gebruiken.
- Externe services. Een live betalingssandbox, mailservice of identity provider is traag of ligt eruit. Oplossing: vervang het externe systeem door een testdouble wanneer de test het echte systeem niet nodig heeft.
- Tijd. Tests die de systeemklok uitlezen, gedragen zich anders om middernacht, aan het einde van de maand of over tijdzones heen. Oplossing: beheer de klok in de test.
- Resourcelekken. Een test laat een verbinding of sessie open staan, en een latere, niet-gerelateerde test faalt wanneer de resource op raakt.
De Google-post voegt daar concurrency, afhankelijkheid van niet-deterministisch of ongedefinieerd gedrag, instabiele code van derden en infrastructuurproblemen aan toe. Gebruik beide lijsten als checklist wanneer je de grondoorzaak van een falende test onderzoekt.
Pak eerst de wachttijden aan
Bij browsertests is timing meestal de eerste verdachte. Een test die op een knop klikt voordat die klaar is, of een melding controleert voordat die verschijnt, slaagt op een snelle machine en faalt op een drukke machine.
Een vaste pauze zoals "wacht 5 seconden" is het slechtste antwoord. Het kost tijd wanneer de pagina snel is, en het faalt nog steeds wanneer de pagina traag is. Fowler beschrijft polling als regelmatig kijken, niet slechts één keer, en stelt dat de tijdslimieten nooit letterlijke waarden in de test mogen zijn.
Moderne tools hebben dit al ingebouwd. De documentatie van Playwright over actionability somt de controles op die het uitvoert voordat het een actie uitvoert: het element moet zichtbaar zijn, stabiel (de positie verandert niet tussen animatieframes), ingeschakeld, in staat om events te ontvangen op het klikpunt en, bij typen, bewerkbaar. Playwright wacht tot de controles slagen, of faalt met een timeoutfout. De best-practicespagina voegt toe dat web-first assertions opnieuw proberen totdat de voorwaarde is vervuld.
Praktische regels:
- Wacht op een voorwaarde die een gebruiker zou kunnen zien, zoals een kop of een rij, en niet op een aantal seconden.
- Geef de voorkeur aan een selector op basis van rol, tekst of een test-ID boven lange CSS- of XPath-paden, die breken wanneer de paginalay-out verandert.
- Stel één ruime timeout in voor de hele stap in plaats van veel kleine pauzes.
- Controleer het resultaat met een assertion die opnieuw probeert.
Isoleer testdata en de testomgeving
De tweede grote hefboom is data. Geef elke test een eigen account, eigen order of eigen map. Laat twee tests nooit hetzelfde record bewerken. Als tests parallel moeten draaien, garandeert gedeelde data willekeurige fouten.
Kijk ook naar de omgeving. Een gedeeld stagingsysteem waarop andere teams midden in jouw run uitrollen, veroorzaakt fouten die geen testaanpassing kan oplossen. Spreek deploymentvensters af, of draai je suite tegen een eigen omgeving.
Als een stap afhankelijk is van een externe service, vraag je jezelf af of de test over die service gaat. Zo niet, vervang die dan door een stub. Houd een klein aantal tests die de echte service gebruiken, en behandel die als aparte groep.
Maak ten slotte elke fout gemakkelijk te diagnosticeren. Bewaar in je CI-pijplijn het log, een screenshot en een trace van elke mislukte testrun. De best-practicespagina van Playwright raadt aan een trace te verzamelen bij de eerste herhaling van een falende test, zodat je kunt terugkijken wat er gebeurd is in plaats van te gokken. Met een log en een trace wordt een instabiele test een helder workflowprobleem dat je kunt oplossen, bijvoorbeeld een timeout bij één trage UI-stap.
Wat te doen met tests die je nog niet kunt oplossen
Sommige instabiele tests hebben meer tijd nodig dan je hebt, en sommige hangen af van code die je niet beheert. Beheer ze dan open en zichtbaar, en houd de resultaten van de stabiele tests betrouwbaar.
- Quarantaine. Fowler beschrijft het verplaatsen van niet-deterministische tests naar een aparte suite, zodat gezonde tests betrouwbare feedback blijven geven. Hij voegt eraan toe dat tests in quarantaine snel opgelost moeten worden, en dat je moet beperken hoeveel er zich kunnen opstapelen of hoe lang ze mogen blijven staan.
- Opnieuw proberen met registratie. Google beschrijft het opnieuw uitvoeren van falende tests en het markeren van een test als instabiel, zodat deze pas als gefaald wordt gerapporteerd na drie keer na elkaar falen. De post noemt dit nauwelijks een perfecte oplossing en waarschuwt dat het een echte race condition of een andere bug in de geteste code gemakkelijk kan maskeren.
- Houd flakiness in de gaten over tijd. Google beschrijft ook tools die veranderingen in het flakiness-niveau van een test detecteren. Zelfs een eenvoudige lijst van tests met hun slagingspercentage laat zien waar je eerst moet kijken.
Wat je ook kiest, maak de lijst met flaky tests zichtbaar, geef elke test een eigenaar en zet er een datum op.
Voorbeeld: de oorzaak vinden in drie stappen
De cijfers zijn verzonnen.
Een suite heeft 200 browsertests. In twee weken falen er 14 minstens één keer zonder codewijziging. Dat is 7 procent van de tests.
- Groepeer op oorzaak. Het team leest de foutlogs en sorteert de 14 tests. Acht falen op een timeout bij een knop, vier falen omdat twee tests dezelfde klantrecord bewerken, en twee falen alleen na een deployment naar staging.
- Pak de grootste groep aan. Het team vervangt de vaste wachttijden in de acht timingtests door wachten op zichtbare situaties. Zeven stoppen met falen.
- Pak de volgende groep aan. Elke test die de gedeelde klant bewerkte, maakt nu zijn eigen klant aan. De vier tests stoppen met falen.
Na de derde stap blijven er drie flaky tests over. Het team zet de twee deployment-gerelateerde tests in quarantaine en geeft elke test een eigenaar en een deadline van twee weken. Het aandeel flaky tests in de suite daalt van 7 procent naar 1,5 procent, en het team controleert dit elke week opnieuw.
Veelgemaakte fouten
- Wachttijden toevoegen. Ze verbergen het probleem een tijdje en vertragen elke run.
- Alles opnieuw proberen en doorgaan. Herhalingen zonder registratie verbergen echte defecten, en de oorzaak blijft bestaan.
- Testdata delen tussen tests. Parallelle runs maken hier willekeurige fouten van.
- Externe diensten in elke test testen. Vervang ze door stubs waar de dienst niet het doel van de test is.
- Quarantaine onbeperkt laten groeien. Een quarantaine zonder eigenaar wordt een kerkhof.
- Eerst de tool de schuld geven. Controleer timing, data en omgeving voordat je van framework wisselt.
Hoe software kan helpen
Begin met wat je framework biedt: automatisch wachten, traces en herhalingen in CI. Voeg een dashboard toe met fouten per test en per oorzaak, zodat patronen zichtbaar worden. Een spreadsheet werkt in het begin prima. Tools die een AI-agent gebruiken om tests uit te voeren op basis van stappen in gewone taal, kunnen sommige timingproblemen verminderen, omdat de agent bepaalt hoe lang er gewacht wordt. Ze brengen wel hun eigen risico's mee, zoals verkeerd geïnterpreteerde instructies. Test ze eerst op een paar tests en vergelijk het flaky-percentage voordat je beslist.
Volgende stap
Maak deze week een lijst van je tien meest onbetrouwbare tests, ken aan elke test een waarschijnlijke oorzaak uit de vijf hierboven toe, en los de wachtproblemen als eerste op. Volg daarna elke week het aandeel flaky end-to-end tests, en bescherm de waarde van je regressietestsuite met een limiet op quarantaine.