Automatisering van softwaretesten voor user requirements. Waarom is dat nodig? | Foto: wega Informatik AG
Namens ons
Een artikel schrijven over testautomatisering en onze passie, in tijden van ChatGPT? Hoe pakken we dat aan? Heeft een artikel als zodanig nog zin en zo ja, in welke vorm?
Na lang nadenken besluiten we om het artikel te schrijven met hulp van ChatGPT, maar wel in twee delen: in deel 1 vind je onze persoonlijke ervaringen met testautomatisering; we denken dat chatGPT die ervaringen niet heeft. In deel 2 beschrijven we relevante, algemene overwegingen bij testautomatisering. We doen dit in de vorm van checklists, zodat we zo beknopt mogelijk kunnen zijn.
Deel 1: onze persoonlijke ervaringen
Bij wega houden we ons op veel manieren bezig met softwarevalidatie. Het doel daarvan is om formeel aan te tonen dat applicaties in gereguleerde farmaceutische omgevingen correct werken. Een van die activiteiten is het handmatig uitvoeren van test scripts. Daarbij volg je heel precies omschreven teststappen in het systeem dat gevalideerd moet worden. Deze scripts zijn pagina’s vol instructies die stap voor stap exact moeten worden opgevolgd.
Toen sommigen van ons dit voor het eerst deden, hadden we gemengde gevoelens en gedachten. “Wow, dit vraagt echt al mijn concentratie,” hoorden we vaak, net als: “Oh nee, ik heb stap … overgeslagen!”
Maar ook: “Ik verveel me… Hoe kan dat nou? Het is uitdagend, vereist volledige focus en het is interessant om de applicatie op deze manier te ontdekken. Maar toch… dit is vermoeiend. Ik voel me net een robot.”
En dat was het magische woord: robot! Tijd om te automatiseren!
Door na te denken over wat je wél en niet kunt automatiseren, en waar machines beter in zijn dan mensen, ontdekten we een nieuwe en boeiende manier van testen. We leerden ook het verschil begrijpen tussen testen en controleren, zoals dat bijvoorbeeld wordt uitgelegd op tutorialspoint.
Testen is het actief verkennen van het systeem om te beoordelen of het zich gedraagt zoals verwacht. Voelt de gebruiker zich comfortabel met de applicatie? Wordt hij goed ondersteund in zijn werk? Zijn menselijke fouten acceptabel in het gebruik? Is de kwaliteit zoals gehoopt? Is de look & feel aantrekkelijk? Kortom: testen levert een compleet beeld van het systeem op. Het is een creatief en onderzoekend proces dat menselijke beoordeling, ervaring en vaardigheid vereist. En dat kun je niet automatiseren.
Controleren daarentegen is het nagaan of een systeem of onderdeel voldoet aan vooraf gedefinieerde eisen of specificaties, bij ons vaak op hoog niveau. Hierbij gebruik je scripts die de verwachte resultaten vergelijken met dat wat het systeem daadwerkelijk doet. Controleren is een gestructureerd, herhaalbaar proces dat je prima kunt automatiseren.
Maar, zelfs als een testscript stap-voor-stap is beschreven en dus kán worden geautomatiseerd, is dat dan ook zinvol? Zoals vaak is ook hier het antwoord: dat hangt ervan af. En dat klopt. Het hangt af van wat je met testautomatisering wilt bereiken.
Tot nu toe hebben we drie belangrijke doelen ervaren waarbij testautomatisering echt iets toevoegt:
Lagere testinspanning en kosten, met hogere betrouwbaarheid: vooral als je hetzelfde script steeds opnieuw moet uitvoeren, zoals bij regressietests.
Sneller testen: als er net een nieuwe feature is uitgebracht, wil je snel kunnen testen. Dankzij geautomatiseerde scripts kun je deze testen veel sneller uitvoeren dan wanneer je dat handmatig doet.
Betere betrouwbaarheid en gebruikerservaring na implementatie van systeemmonitoring. De digitalisering binnen de Life Sciences leidt tot het ontstaan van applicatie-ecosystemen die meer en meer in (nagenoeg) real-time met elkaar moeten communiceren. Maar wanneer je werkt met applicaties die als SaaS (Software as a Service) worden aangeboden, wordt het lastiger om releases en hun impact op het hele ecosysteem goed te beheren. Tel daar nog bij op dat IT-activiteiten zoals patching en onderhoud vaak buiten kantooruren plaatsvinden, en je hebt te maken met veel factoren die buiten je invloedssfeer liggen. Dat kan ertoe leiden dat cruciale bedrijfsprocessen volledig tot stilstand komen.
In zo’n situatie lijkt ons de meerwaarde van testautomatisering enorm: het vraagt weliswaar een grotere initiële investering om testscripts te ontwikkelen die alle belangrijke processen dekken, maar zodra dit staat kun je alle tests probleemloos inplannen: elk weekend, of zelfs elke nacht. Je kunt je tool zo instellen dat je een melding krijgt zodra er een defect wordt ontdekt. Daarmee kun je pro-actief handelen: misschien los je een potentieel probleem al op voordat gebruikers er iets van merken. En in het slechtste geval kun je ze in elk geval informeren dat een probleem bekend is en wordt aangepakt. En dat scheelt meteen een hoop supportverzoeken.
Tot slot willen we wat van onze ervaringen met je delen:
Alleen al bij het schrijven van geautomatiseerde test scripts test je het systeem heel precies. Je moet elk detail goed omschrijven, je kunt niet zomaar ‘ongeveer’ iets noteren zoals soms bij handmatige scripts.
Fouten in het script merk je meteen, omdat je het script snel en vaak kunt uitvoeren. Bij handmatige scripts zie je pas bij een eerste test-run of de stappen duidelijk en logisch zijn voor mensen.
En tenslotte: geautomatiseerde tests schrijven is gewoon leuk! In plaats van telkens zelf te klikken, zie je nu hoe de muis vanzelf beweegt en de applicatie test. Na uren zelf klikken geeft dat echt voldoening!
Deel 2: Overwegingen bij testautomatisering
Inleiding
Binnen softwareontwikkeling is testen een cruciale stap om te garanderen dat de software voldoet aan de gewenste eisen en correct functioneert. Handmatig testen kan echter veel tijd kosten, foutgevoelig zijn en inefficiënt, zeker bij grote of complexe softwaresystemen. Daarom wint testautomatisering steeds meer aan belang in moderne softwareontwikkelingsprocessen.
Bij testautomatisering gebruik je softwaretools om testen automatisch uit te voeren, vergelijk je de werkelijke resultaten met de verwachte uitkomsten en genereer je gedetailleerde testrapporten. Het doel is om het testproces te versnellen, de nauwkeurigheid te verhogen en het risico op menselijke fouten te verkleinen. Testautomatisering kan worden toegepast op verschillende soorten tests, zoals unittests, integratietests, systeemtests, user interface tests (UI-tests) en regressietests.
Toch is testautomatisering geen kant-en-klare oplossing. Om effectief te zijn, vraagt het om zorgvuldige planning en uitvoering. Het is belangrijk om te bepalen welke tests geschikt zijn om te automatiseren. Zorg ervoor dat het testsysteem robuust is en makkelijk te onderhouden. Daarnaast is het belangrijk dat de geautomatiseerde tests voortdurend gecontroleerd en bijgewerkt worden zodat ze gelijke tred houden met wijzigingen in de software. Daarnaast is het belangrijk om een goede balans te vinden tussen geautomatiseerd en handmatig testen. In sommige gevallen is automatiseren lastig of zelfs onmogelijk.
Voor- en nadelen van geautomatiseerde softwaretests voor validatie
Het automatiseren van softwaretesten voor validatie kan verschillende voordelen opleveren, waaronder:
Meer efficiëntie: geautomatiseerd testen verloopt sneller en consistenter dan handmatig testen, waardoor het testproces sneller en efficiënter kan worden uitgevoerd.
Verbeterde nauwkeurigheid: geautomatiseerde tests sluiten menselijke fouten uit en leveren doorgaans nauwkeurigere resultaten dan handmatig testen.
Betere testdekking: geautomatiseerde tests kunnen meer scenario’s en testgevallen bestrijken dan handmatig testen, wat zorgt voor een grondige controle van alle onderdelen van de software.
Kostenbesparing: vooral bij regressietests kan geautomatiseerd testen de kosten drukken, omdat de benodigde tijd voor testuitvoering aanzienlijk afneemt.
Snellere time-to-market: door sneller bugs en problemen te identificeren, helpt testautomatisering het ontwikkelproces te versnellen en producten sneller op de markt te brengen.
Hoewel er veel voordelen zijn aan geautomatiseerd testen voor dit type validatie zijn er ook enkele mogelijke nadelen om rekening mee te houden.
Vijf redenen waarom je ervoor zou kunnen kiezen om (bepaalde) tests niet te automatiseren:
Hoge initiële investering: Automatisering vereist een aanzienlijke begininvestering in tijd, middelen en expertise. Daarnaast kunnen licentiekosten of royalty’s een rol spelen. Voor kleinere teams of organisaties met beperkte middelen kan dit een struikelblok vormen.
Beperkte reikwijdte: Geautomatiseerde tests testen alleen waarvoor ze geprogrammeerd zijn. Hierdoor worden niet alle scenario’s of randgevallen afgedekt. Handmatig testen blijft dus soms noodzakelijk om volledige dekking te garanderen.
Onderhoudskosten: Geautomatiseerde tests moeten worden onderhouden om ervoor te zorgen dat ze blijven werken naarmate de software evolueert. Dit kan tijdrovend en kostbaar zijn.
Vals-positieven: Geautomatiseerde tests kunnen soms foutmeldingen geven, terwijl er eigenlijk geen probleem is. Dit leidt tot verspilde tijd en middelen bij het onderzoeken van niet-bestaande issues.
Gebrek aan menselijke inzichten: Automatisering kan het menselijke inzicht en de creativiteit niet vervangen die soms nodig zijn om subtiele of complexe problemen te detecteren die een automatische test mogelijk mist.
Geautomatiseerd testen in geavanceerde software validatie biedt aanzienlijke voordelen, zoals meer efficiëntie, nauwkeurigheid, bredere testdekking, kostenbesparing en snellere oplevering. Toch is het belangrijk om ook de nadelen mee te nemen in de afweging en een weloverwogen beslissing te nemen over of, en in welke mate, je testautomatisering gaat inzetten.
Overwegingen bij het opbouwen van een testautomatiseringssysteem
Bij het schrijven van een testautomatiseringssysteem zijn er verschillende belangrijke overwegingen om in gedachten te houden om ervoor te zorgen dat dit pakket effectief en efficiënt is. Hier zijn enkele belangrijke factoren om te overwegen en mogelijke problemen die vermeden moeten worden:
Testdekking: Zorg ervoor dat het testautomatiseringssysteem de kritische scenario’s en functionaliteit van het systeem dekt. Het niet dekken van belangrijke use cases kan leiden tot gemiste defecten, terwijl overmatig testen kan leiden tot inefficiënte testuitvoeringen.
Testomgeving: Zorg ervoor dat de testomgeving nauwkeurig overeenkomt met de productieomgeving, inclusief hardware, software en netwerkconfiguraties. Verschillen tussen de omgevingen kunnen leiden tot valse testresultaten of gemiste defecten.
Testonderhoud: Zorg ervoor dat het testautomatiseringssysteem onderhoudbaar en schaalbaar is. Wijzigingen in het systeem of de vereisten moeten worden weerspiegeld in het testautomatiseringssysteem en verouderde of achterhaalde tests moeten worden verwijderd.
Testrapportage: Zorg ervoor dat het testautomatiseringssysteem duidelijke en bruikbare rapporten levert, inclusief testresultaten, logbestanden en screenshots. Slechte rapportage kan het moeilijk maken om defecten te identificeren en te diagnosticeren.
Testuitvoering: Zorg ervoor dat het testautomatiseringssysteem betrouwbaar en efficiënt kan worden uitgevoerd, met minimale handmatige tussenkomst. Onbetrouwbare of inefficiënte testuitvoeringen kunnen leiden tot verspilde tijd en middelen.
Testframework: Zorg ervoor dat het testautomatiseringssysteem is gebouwd op een robuust en schaalbaar testframework. Een ontoereikend of slecht ontworpen framework kan leiden tot onderhoudsproblemen, instabiele tests en moeilijkheden bij het opschalen.
Enkele mogelijke problemen die vermeden moeten worden bij het schrijven van een het testautomatiseringssysteem zijn:
Focus op kwantiteit boven kwaliteit: Het is belangrijk om ervoor te zorgen dat de tests in de suite effectief en efficiënt zijn, in plaats van te proberen zoveel mogelijk scenario’s te dekken.
Verwaarlozing van onderhoud: Testautomatiseringssystemen vereisen voortdurend onderhoud om effectief te blijven. Verwaarlozing van onderhoud kan leiden tot verouderde of achterhaalde tests.
Onvoldoende testdata: Testdata moet nauwkeurig, relevant en up-to-date zijn om effectief te kunnen testen.
Te veel vertrouwen op automatisering: Het is belangrijk om geautomatiseerde tests in balans te houden met handmatig testen, aangezien sommige scenario’s moeilijk of onpraktisch te automatiseren zijn.
Slecht ontworpen testframework: Een slecht ontworpen testframework kan leiden tot onderhoudsproblemen, onstabiele tests en moeilijkheden bij het opschalen.
Door deze factoren in overweging te nemen en mogelijke problemen te vermijden, kun je een effectief en efficiënt testautomatiseringssysteem creëren dat helpt om de kwaliteit van je systeem te waarborgen.
Overwegingen bij keuze, invoer en gebruik van testgegevens
Bij het automatiseren van tests is het belangrijk om testdata te gebruiken die verschillende scenario’s afdekken, zodat je kunt controleren of het systeem zich onder uiteenlopende omstandigheden gedraagt zoals je zou verwachten. Er zijn meerdere manieren om testdata aan te leveren, elk met hun eigen aandachtspunten:
Handmatige invoer:
Je kunt de testdata handmatig in je geautomatiseerde testscripts invoeren. Dit is echter tijdrovend en foutgevoelig. Het is belangrijk dat de data correct wordt ingevoerd, want fouten kunnen leiden tot onjuiste testresultaten.
CSV- of Excel-bestanden:
Je kunt testdata opslaan in CSV- of Excel-bestanden en deze inlezen in je testscript. Dit bespaart tijd en verkleint de kans op fouten. Let er wel op dat de structuur van de data klopt en dat de bestanden toegankelijk en actueel zijn.
Databasequery’s:
Je kunt testdata direct ophalen uit een database via SQL-query’s. Dit is vaak efficiënt, maar vereist wel kennis van SQL en databasebeheer.
API’s:
Testdata kan ook via API’s worden opgehaald, bijvoorbeeld vanuit externe systemen of webservices. Dit is vooral handig bij het testen van integraties.
Belangrijke aandachtspunten bij het gebruik van testdata:
Zorg dat de testdata representatief is voor realistische situaties.
Controleer of de testdata correct en actueel is.
Hou rekening met de omvang en complexiteit van de data.
Plan het onderhoud van de testdata, bijvoorbeeld als er wijzigingen nodig zijn.
Bescherm gevoelige gegevens volgens het beleid van je organisatie en eventuele wet- en regelgeving.
Houd rekening met de prestaties van het systeem bij het gebruik van grote datasets.
Zorg dat de testdata toegankelijk is en zonder problemen kan worden geïmporteerd in de geautomatiseerde tests.
Door met deze aspecten rekening te houden, zorg je ervoor dat je geautomatiseerde tests betrouwbare en relevante data gebruiken. Dit vergroot de kans dat je fouten op tijd opspoort en dat de kwaliteit van het systeem gewaarborgd blijft.
Vertaald naar het Nederlands door Monique van Helden
