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

Blog · Mirko Peters

Self-healing tests: wat de term betekent en waar het ophoudt

By · · Updated

Self-healing testautomatisering herstelt kapotte locators tijdens het uitvoeren van de test. Lees hoe het werkt, wat het niet kan oplossen, hoe het bugs kan verbergen en welke vangrails je instelt.

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

Self-healing testautomatisering betekent dat een testtool een kapotte locator zelfstandig herstelt, zodat een UI-test blijft draaien na een onschuldige wijziging, zoals een hernoemd ID. Deze gids is bedoeld voor testautomatiseringsengineers die de term in een verkooppraatje hebben gehoord en een nuchter antwoord willen. Je leert hoe het herstel werkt, wat het kan oplossen en wat niet, hoe het een echte bug kan verbergen en welke regels het veilig houden. Een uitgewerkt voorbeeld met verzonnen cijfers laat zowel het voordeel als het risico zien.

Belangrijkste punten

  • Self-healing betekent dat een testtool een UI-element op basis van andere aanwijzingen terugvindt wanneer de opgeslagen locator niet meer past, zodat de test kan doorgaan in plaats van te falen.
  • Het werkt bijna uitsluitend op locators, niet op asserts, testflows, bedrijfsregels of timingproblemen, dus het dekt maar een klein deel van het testonderhoud.
  • Het grootste risico is een gemaskeerde regressie: de tool past zich aan een gewijzigd element aan dat eigenlijk een defect is, en de test slaagt terwijl de gebruikerservaring kapot is.
  • Leveranciersdocumentatie zegt dat het herstel tijdens het uitvoeren gebeurt en dat het script ongewijzigd blijft, dus gerepareerde locators moeten nog steeds worden nagekeken en teruggeschreven.
  • Veilig gebruik betekent elk herstel loggen, de herstellingen volgens een vast schema nakijken, de tool nooit asserts laten wijzigen en letten op plotselinge sprongen in het slagingspercentage.

Wat een self-healing test in de praktijk is

Een UI-test vindt elk UI-element op een pagina met een locator. Een locator is een regel zoals "het element met ID btn-pay" of "de knop met de naam Pay". Bij traditionele testautomatisering past een persoon de testscripts aan zodra een regel niet meer past. In een grote testsuite kan één herontwerp honderden stappen rood kleuren. Elke keer dat een test faalt, moet een QA-engineer ernaar kijken, en het team besteedt dagen aan herstelwerk of valt terug op handmatig testen.

Self-healing is het idee dat de tool die regel zelf repareert, zodat een self-healing test een wijziging overleeft die een traditionele test zou breken. Het BugBug-artikel Self Healing Test Automation: Hype & Reality definieert het als mechanismen die automatisch aanpassen hoe een test UI-elementen identificeert wanneer de oorspronkelijke locator niet meer werkt.

Healing betekent niet dat de tool je product begrijpt. Het betekent dat de tool probeert hetzelfde element opnieuw te vinden aan de hand van andere aanwijzingen en daarna de run voortzet. Beschouw een self-healing test als een reparatie voor één smal soort breuk: UI-wijzigingen die het gedrag gelijk laten.

Hoe locator-healing werkt

De details verschillen per testframework en product, maar de meeste self-healing mechanismen volgen hetzelfde patroon.

  1. Leren. Tijdens geslaagde testruns registreert de tool meerdere aanwijzingen per element. BugBug beschrijft dit als een fingerprint: kenmerken zoals ID, tekst, classes, ARIA-labels en positie in de paginastructuur.
  2. Detecteren. Wanneer de opgeslagen locator niets vindt, faalt de tool niet meteen.
  3. Zoeken. De tool doorzoekt de pagina naar het element dat het meest lijkt op het element dat het onthouden heeft. Sterkere, stabielere aanwijzingen wegen zwaarder, en zwakkere dienen als terugvaloptie.
  4. Doorgaan en rapporteren. De tool gebruikt de nieuwe match, rondt de run af en logt wat het heeft gedaan.

De documentatie van BrowserStack over hun self-healing-functie met Playwright volgt dezelfde werkwijze. Er staat dat healing begint zodra de oorspronkelijke locator niet meer wordt gevonden, en dat er minstens één eerdere geslaagde run met dezelfde element-identifier nodig is. Ook staat er dat healing tijdens de run plaatsvindt, zodat één run groen blijft, terwijl het script zelf ongewijzigd blijft. De pagina adviseert om de gehealde locator terug te zetten in je test. Ze noemen ook beperkingen: healing voegt extra analyse toe tijdens een run, de ondersteuning voor Playwright wordt als beperkt omschreven, en het kan niet herstellen als het element echt niet meer bestaat.

Sommige nieuwere tools gebruiken AI-self-healing: een model, vaak gebouwd op generatieve AI, kiest het vervangende element in plaats van een vaste scoringsregel. De gids van T-Plan wijst erop dat AI-ondersteunde healing probabilistisch gedrag in het testen brengt, en dat betrouwbare automatisering waar mogelijk deterministisch moet blijven. BugBug voegt toe dat healing niet inhoudt dat een AI-agent de testlogica herschrijft, en ook geen echt begrip van de applicatie heeft.

Marketing zegt vaak dat AI-testen de healing doet. In de praktijk beslaat AI in softwaretesten een breed spectrum, van eenvoudige similarity-scoring tot een model dat kandidaat-elementen rangschikt. Vraag een leverancier wat de AI precies beslist, en of het logboek laat zien waarom. Als de AI het verkeerde element kiest, kan er een defect doorglippen. Een AI-keuze heeft dus dezelfde controle nodig als elke andere heal.

Voordelen van self-healing, en wat het niet kan oplossen

Healing helpt vooral bij oppervlakkige wijzigingen:

  • Een ontwikkelaar hernoemt een ID of CSS-klasse, en het gedrag blijft hetzelfde.
  • Een layoutverschuiving zet een knop op een andere plek.
  • Een upgrade van een componentenbibliotheek past de markup aan, maar niet het scherm.

In deze gevallen zijn de voordelen reëel: minder onderhoud aan tests, en onschuldige UI-wijzigingen laten niet langer in één keer veel testcases falen.

De self-healingmogelijkheden van een tool passen binnen een bredere teststrategie voor test automation, naast exploratory testing, voor continu testen. Ze beschermen de testdekking van de gebruikersinterface tegen UI-churn. Unit-tests en API-tests gebruiken geen schermlocators, dus daarvoor is helemaal geen healing nodig.

Healing helpt niet bij de meeste andere oorzaken van falende tests. BugBug stelt dat healing vrijwel uitsluitend op locators van toepassing is, niet op asserties, verwachte waarden, testflows of bedrijfsregels. Het lost geen timingproblemen op en ook geen slechte testarchitectuur. Als je probleem onstabiele waits of gedeelde testdata is, behandel flaky tests dan eerst als apart onderwerp, want healing geneest ze niet. Hetzelfde artikel stelt dat healing moeite heeft met rolgebaseerde systemen, dynamische dashboards, meerstapstransacties en sterk voorwaardelijke schermen, en dat healing moeilijker wordt naarmate er meer context nodig is om een element te identificeren.

Goede locators en stabiele test-ID's voorkomen ook veel breuken, nog voordat healing nodig is. De best practices van Playwright adviseren locators die weergeven wat gebruikers zien, zoals rol en tekst, in plaats van kwetsbare CSS- of XPath-paden. Dit advies helpt ook in Selenium-suites.

Self-healing testautomatisering en het risico van verborgen regressies

Het belangrijkste risico is eenvoudig te benoemen. Een self-healingtool die zich aanpast, kan zich ook aanpassen aan een defect.

De gids van T-Plan over self-healing testautomatisering noemt dit een verborgen regressie: een framework past zich mogelijk automatisch aan een gewijzigd element aan dat in werkelijkheid een defect vertegenwoordigt, waardoor de test slaagt terwijl de gebruikerservaring verslechtert. Het voegt eraan toe dat dit valse zekerheid creëert en het vertrouwen in automatisering verkleint. Ook wijst het erop dat self-healingsystemen het verkeerde vervangende element kunnen kiezen, dat hoe agressiever de healing, hoe groter het risico op verkeerde matches, en dat sommige fouten zichtbaar moeten blijven.

Denk aan een Opslaan-knop in de applicatie die getest wordt, die na een foutieve merge op dezelfde plek wordt vervangen door een Verwijderen-knop. Een test die zoekt naar "de knop in de voettekst van het formulier" kan zich aanpassen naar de nieuwe knop, erop klikken en doorgaan. De suite blijft groen, en de bug gaat live.

Daarom is een stijgend slagingspercentage niet altijd goed nieuws. Als je slagingspercentage na een UI-release sterk omhooggaat zonder dat de tests zijn aangepast, bekijk dan eerst het healing-log voordat je gaat feesten.

Waarborgen die het veilig maken om te gebruiken

De handleidingen van T-Plan en BugBug geven vergelijkbaar advies. Dat geldt of je zelf self-healing implementeert of een self-healing tool koopt:

  1. Registreer elke heal. Leg de oude locator, de nieuwe locator, de betrouwbaarheid van de match en de wijziging die de tool op de pagina heeft doorgevoerd vast.
  2. Beoordeel volgens een vast schema. Laat de aanpassingen niet onbeperkt stilzwijgend doorgaan. Bekijk het heal-log na elke release en keur elk item goed of af.
  3. Gebruik de suggestiemodus als dat kan. Laat de tool een oplossing voorstellen en vereis dat een persoon die accepteert.
  4. Laat het nooit de asserties wijzigen. Healing mag wijzigen hoe een element wordt gevonden. Het mag nooit wijzigen wat de test verwacht, want dat is het doel van de test.
  5. Verwerk de fixes in de bron. Omdat healing alleen de run herstelt, werk je het script bij met de betere locator.
  6. Beperk de scope. Niet elk element moet zelfstandig healen. Kritieke flows zoals betalingen hebben misschien strengere controles nodig, zoals visuele tests, die controleren hoe de pagina eruitziet.
  7. Houd de trend in de gaten. Een plotselinge stijging van het slagingspercentage vraagt om een verklaring, want self-healing automatisering kan een suite gezonder doen lijken dan hij is.

Voorbeeld: een refactor van de checkout, met en zonder healing

De cijfers zijn verzonnen.

Een team heeft 400 geautomatiseerde tests die in de browser draaien. Een front-end refactor hernoemt de ID's op de checkoutpagina. Zonder healing falen 60 tests op locators, en elke testfout moet worden bekeken. Een engineer heeft ongeveer twee dagen nodig om ze te repareren, en in die tijd heeft het team geen betrouwbaar regressieresultaat.

Met healing ingeschakeld repareert de tool de locators tijdens de testuitvoering, zodat elke test doorloopt, en 55 van die 60 tests slagen met de gerepareerde locators. De QA-lead ziet elke heal in het rapport. Vijf falen nog steeds, omdat hun elementen bewust zijn verwijderd. De engineer besteedt een halve dag aan die vijf en nog een uur aan het lezen van het heal-log.

In het log lijken twee heals fout. In een test voor het bewerken van een adres klikte de tool op "Adres verwijderen" waar de test "Adres opslaan" wilde. De test controleerde alleen of de pagina nog laadde, dus slaagde hij. De engineer past beide locators aan en voegt een sterkere assertion toe: het opgeslagen adres moet in de lijst verschijnen.

Het resultaat: ongeveer twee dagen reparatiewerk wordt teruggebracht tot ruwweg één dag. De besparing is reëel, maar die bestaat alleen omdat een persoon het log heeft gelezen. Zonder die controle zouden twee tests groen zijn gebleven terwijl ze het verkeerde testten.

Veelgemaakte fouten

  • Self-healing zien als vervanging voor goede locators. Stabiele locators op basis van rol, tekst of test-ID voorkomen breuken en kosten niets.
  • Het stilzwijgend laten draaien. Als niemand het log leest, stapelen verkeerde heals zich ongezien op.
  • Verwachten dat het flaky tests oplost. Timingproblemen en instabiele testdata vragen om andere oplossingen.
  • Het gebruiken op kritieke controles zonder extra waarborgen. Voeg visuele regressietests of datacontroles toe aan betalings- en machtigingsflows.
  • De cijfers van een leverancier over lagere onderhoudsinspanning geloven zonder pilot. Meet het echte effect op je eigen suite voordat je je vastlegt.

Hoe software kan helpen

Veel frameworks voor testautomatisering, cloudplatforms en andere automatiseringstools bieden nu healing, in verschillende vormen: eenvoudige fallback-locators, similarity scoring en AI-gebaseerde keuze van elementen. Vergelijk ze op de punten hierboven, niet op het label. Vraag of het self-healing platform elke heal laat zien, of je die kunt goedkeuren en of je hem kunt exporteren als wijziging in het script. Een gewone Selenium- of Playwright-suite met goed gekozen locators en een korte beoordelingsgewoonte is een geldig alternatief voor elke self-healing tool. Draai een pilot op één instabiel onderdeel en vergelijk de onderhoudstijd voordat je beslist. Tools die zijn gebouwd op AI-agents, vaak agentic AI genoemd, die werken met stappen in gewone taal, roepen dezelfde vragen over beoordeling op.

Volgende stap

Kies één deel van je end-to-end testing-suite dat vaak breekt, schakel daar voor één release healing in en beoordeel elke heal handmatig. Bepaal daarna op basis van het aantal juiste heals of self-healing testautomatisering een bredere rol in je suite verdient.

Entities in this article

End-to-end testing AI agent Generative AI

Related articles

RSS