Mutatietesten, of programmamutatie, is een white-box testtechniek die bedrijven helpt bij het ontwikkelen van een reeks nieuwe softwarecontroles en tegelijkertijd de huidige processen van een project doorlicht. Dit is een relatief nieuwe aanpak, die ervoor zorgt dat zowel ontwikkelaars als testers volgens hoge normen werken.
Een applicatie is slechts zo succesvol of goed als de eigen kwaliteitsborgingsprocedures – wat betekent dat het essentieel is dat organisaties meer dan één soort testtechniek omarmen.
Leren over mutatietests kan testteams helpen hun vaardigheden en algemene repertoire te vergroten – zodat zij de betrouwbaarheid van deze controles kunnen verbeteren. Mutatietesten zijn een complex en gevoelig proces, dus het is van vitaal belang dat testers grondig onderzoek doen naar de voordelen, uitdagingen en programma’s van derden die een succesvolle implementatie kunnen garanderen.
In dit artikel kijken we naar mutatietesten en hoe die de kwaliteitsborging verbeteren, en naar andere belangrijke overwegingen voor softwaretestteams.
Wat zijn mutatietesten in softwaretesten?
In de context van software betekent mutatietesten dat een kwaliteitsborgingsteam opzettelijk fouten – of “mutaties” – in de code van een toepassing introduceert om te zien hoe het team reageert. Het doel is een fout te creëren en ervoor te zorgen dat de testsuite elke wijziging in de toepassing kan identificeren.
Bij het bewerken van de programmacode kan een mutatietester een waar/onwaar-uitdrukking verwisselen, een verklaring verwijderen of gewoon een waarde veranderen. Deze fouten kunnen zich op verschillende manieren manifesteren tijdens andere softwarecontroles; ze zijn allemaal gemakkelijk op te sporen door een deskundig en ervaren testteam.
De mutaties zelf zijn vaak erg klein, zodat de tester die de code muteert kan observeren hoe het team deze veranderingen ontdekt. Significante veranderingen zouden zelfs bij een vluchtige blik duidelijk zijn – dus kleine fouten zijn meestal de beste manier om ervoor te zorgen dat het bedrijf robuuste testpraktijken toepast.
Deze techniek kijkt specifiek naar de effectiviteit van de testcases van een team; de documenten die de testinformatie bevatten. Het team kan ook automatiseringssoftware van derden gebruiken om deze controles uit te voeren; in dat geval wordt bij mutatietests gekeken hoe goed dit platform fouten in de programmacode kan opsporen.
1. Wanneer moet u een mutatietest uitvoeren?
Aangezien het doel van mutatietests is de huidige kwaliteitscontroles te valideren en te verbeteren, is het voor teams van essentieel belang dit vroeg in de testfase uit te voeren. Dit betekent dat als de testsuite de mutanten niet kan identificeren en “doden”, er genoeg tijd is om ingrijpende veranderingen van enige omvang aan te brengen in de testprocedures van de organisatie.
Omdat dit een zeer veelzijdige methode is, is mutatietests toepasbaar voor vrijwel elk type software, waaronder web-, mobiele en desktopprogramma ‘s. Dit werkt het best tijdens de unit-testfase – waarin de kleinste onderdelen van een applicatie worden onderzocht.
2. Wanneer u geen mutatietest hoeft te doen
Er zijn nog steeds enkele scenario’s waarin mutatie en algemene white-box tests niet geschikt zijn voor een programma; dit kan verschillende redenen hebben.
Bijvoorbeeld, als de testers alleen willen controleren met black-box testing – in dat geval zouden ze zich in plaats daarvan richten op de front-end voor die sessie of zelfs de algemene testfase.
Sommige bedrijven vinden white-box testing vervelend en tijdrovend, waardoor ze het proces zouden kunnen overslaan. Sterke, goed gecontroleerde testgevallen kunnen ook de noodzaak van mutatietests omzeilen, omdat dit aantoont dat het team ijverig is en zich inzet voor nauwkeurige testprocedures.
3. Wie is betrokken bij mutatie-analyse?
Er zijn een aantal verschillende rollen betrokken bij mutatie-analyse, waaronder:
– Mutatie testers
Zij muteren de code door verschillende kleine defecten te introduceren om ervoor te zorgen dat het testproces werkt zoals verwacht. Deze testers zijn gewoonlijk reeds bestaande leden van het kwaliteitsborgingsteam.
– Applicatie testers
Zij controleren de code regelmatig op eventuele problemen en identificeren en corrigeren de gevonden mutaties. Zij voeren white-box tests uit om codeerfouten te vinden – maar gebruiken ook andere technieken.
– Applicatieontwikkelaars
Zij ontwerpen de functies van het programma en schrijven de initiële code. Ze lossen ook alle problemen op die testers vinden, zodat de software stabiel is voor de release.
– Projectmanagers
Zij geven richting aan de toepassing en werken eventueel samen met de mutatietesters om de doeltreffendheid van hun eigen teams te bekijken. Zij zorgen voor strenge normen in elk stadium van de ontwikkeling.
Wat testen we met mutatietests?
Mutatietesten richten zich meer op het testen van processen dan op de toepassing. Daartoe onderzoekt hij het volgende:
1. Testgevallen
Testgevallen zijn documenten die gedetailleerde informatie bevatten over elke test, inclusief de resultaten die testers verwachten van elke individuele controle. Consistente en nauwkeurige testcases geven de leden van het QA-team een idee van de gezondheid van de applicatie en hoe de prestaties ervan aansluiten bij de verwachtingen van het bedrijf.
De informatie in deze testgevallen kan bepalend zijn voor het vermogen van een tester om bepaalde gebreken te ontdekken – waaronder die welke mutatietests veroorzaken.
2. Testnormen
Bij mutatietests worden de huidige testprocedures onder de loep genomen om ervoor te zorgen dat de teamleden zelfs kleine problemen kunnen identificeren die de perceptie van de software door de gebruiker kunnen beïnvloeden.
De zorgvuldigheid en bekwaamheid van de testers kunnen zelfs de belangrijkste factoren zijn die een bedrijf bij deze controles beoordeelt. Zonder sterke aandacht voor details in elk stadium zouden testers ernstige mutaties in het programma kunnen missen.
3. Individuele code-eenheden
Mutatietesten zijn gebruikelijk tijdens het unit testen van de ontwikkeling. Hierbij wordt naar afzonderlijke componenten gekeken om een sterke focus op elke test te behouden, waardoor het hele proces aanzienlijk wordt geoptimaliseerd doordat testers alleen met de relevante regels code werken.
Aangezien mutatietests vaak vroeg in de kwaliteitsborgingsfase zitten en een voorloper kunnen zijn van volledige tests, kan deze aanpak de snelheid verhogen zonder afbreuk te doen aan de nauwkeurigheid.
4. Programma-updates
Software-updates houden meestal in dat het testproces opnieuw wordt opgestart om er zeker van te zijn dat er geen nieuwe fouten zijn en dat eerdere fouten niet opnieuw opduiken.
Het herhalen van mutatietesten is een belangrijk onderdeel hiervan en helpt bij het bevorderen van consistente testnormen na grote softwareveranderingen.
Het testteam vindt grondige controles na een update misschien onnodig, maar code-mutatie kan ervoor zorgen dat ze het belang inzien van testen in elk stadium van de ontwikkeling.
5. Automatiseringssoftware
Bedrijven voeren ook mutatietests uit om hun geautomatiseerde testsuites te controleren en ervoor te zorgen dat ze onder meer gemuteerde code kunnen opmerken.
Als een testtoepassing van derden externe wijzigingen in een programma kan identificeren en mogelijk zelfs repareren, betekent dit dat de organisatie de software kan vertrouwen om tests te automatiseren.
Het is essentieel dat bedrijven hun automatiseringsaanpak valideren; dit geeft elke tester gemoedsrust.
6. Automatiseringsstrategie
Hoe het bedrijf automatisering in zijn processen integreert is net zo belangrijk als de software die het gebruikt; het kan bijvoorbeeld besluiten hyperautomatisering toe te passen. Zo kan het bedrijf op intelligente wijze beslissen welke mutatie- en softwaretests het wil automatiseren.
Zonder een sterke automatiseringsstrategie die rekening houdt met de enorme variatie in de code van een applicatie, kunnen sommige tests niet compatibel zijn met automatisering – wat de mogelijkheden van het platform beperkt.
7. De toepassing
Hoewel mutatietests meer gericht zijn op het testteam dan op de applicatie, kunnen ze toch belangrijke informatie over dit programma aan het licht brengen.
Mutatietesten laten bijvoorbeeld zien hoe software reageert op veranderingen in de code, en of deze problemen signaleert op de manier die het team verwacht.
Deze aanpak is geen softwaretesttechniek, maar kan toch interessante gegevens opleveren over de interne werking ervan.
Levenscyclus van mutatietests
De gebruikelijke levenscyclus van mutatietests is als volgt:
1. Analyse van de behoeften
De eerste stap van elke levenscyclus van mutatietests is uit te zoeken wat precies gevalideerd moet worden en welke delen van de applicatiecode het meest gebaat zijn bij deze tests.
Het team kan met ontwikkelaars en leidinggevenden praten om hun zorgen vast te stellen en een begin te maken met de aanpak ervan.
2. Testplanning
De testers beginnen dan met het ontwikkelen van de precieze controles die zij willen uitvoeren – in dit geval de mutaties die het beste inzicht bieden.
Deze fase bepaalt de algemene strategie voor het testen van mutaties en hoe het team de voorgenomen code-mutaties effectief gaat uitvoeren.
3. Ontwikkeling van testcases
Bij mutatietesten hoort een aparte testdocumentatie, met informatie over de gemuteerde code en hoe ze verwachten dat testers het probleem oplossen.
Een goede administratie zorgt ervoor dat alle tests volgens plan verlopen en kan het team helpen zich te houden aan hoge testnormen.
4. Opzetten van de testomgeving
De testers zorgen ervoor dat de applicatie klaar is om te veranderen – en dat ze een procedure hebben om deze problemen aan te pakken als andere teamleden ze niet kunnen ontdekken.
Daarbij richten de mutatietesters een testserver op en gebruiken die als canvas voor hun mutaties.
5. Uitvoering van de test
Na hun voorbereidingen wijzigen de testers de code in verschillende onderdelen van de applicatie; ze wachten dan tot andere testers de problemen opmerken en oplossen.
Zowel de mutatietesters als de app-testers moeten dit uitgebreid documenteren om er zeker van te zijn dat hun verslagen robuust zijn.
6. Sluiten van de testcyclus
Als het testen is voltooid, controleren de mutatietesters dubbel of alle wijzigingen die zij hebben aangebracht, door de app-testers of door henzelf zijn hersteld.
Vervolgens sluiten ze de testcyclus af en analyseren ze de resultaten, waarbij ze bespreken hoe de testers reageerden op de verschillende fouten en hoe ze die konden corrigeren.
7. Herhaling van de test
Na het afsluiten van de testcyclus kan het nodig zijn deze na toekomstige software-updates opnieuw te activeren.
Elke wijziging van een applicatie verandert de functionaliteit ervan op de een of andere manier, wat leidt tot nieuwe mogelijkheden waarmee het team rekening moet houden om ervoor te zorgen dat hun testproces nauwgezet genoeg is.
Voordelen van mutatietesten
Het uitvoeren van mutatietests heeft vele voordelen, waaronder:
1. Valideert het testproces
Het belangrijkste voordeel van mutatietesten is de mogelijkheid om te laten zien hoe de testers van het bedrijf software benaderen – en hun vermogen om coderingsproblemen te herkennen. Dit zorgt er ook voor dat de testcases van het team uitgebreid genoeg zijn en alle noodzakelijke tests omvatten.
Mutatietests onderzoeken de algemene testprocedure van een organisatie om te garanderen dat deze werkt zoals verwacht.
2. Zorgt voor een sterke automatisering
Mutatietesten helpen een team te controleren of hun third-party testautomatiseringsplatform in staat is fouten binnen de code adequaat te identificeren en op de juiste manier aan te pakken.
Als deze software deze zelfs na de nodige kalibratie niet detecteert, kan het de moeite waard zijn het platform te vervangen door een dat deze tests gemakkelijk kan doorstaan.
3. Goede dekking
Elk softwaretestproces moet in staat zijn om de gehele applicatie breed te dekken, zodat elk aspect de nodige aandacht krijgt.
Mutatietesters kunnen elk deel van de code van een programma wijzigen; door een goede implementatie kunnen deze tests alle belangrijke functies omvatten. Dit leert testers te zoeken naar problemen in de gehele applicatie.
4. Onderzoekt de broncode
Aangezien bij mutatietests met de code wordt gewerkt en waar nodig direct wijzigingen worden aangebracht, zou deze methode ook de nadruk kunnen leggen op niet-geoptimaliseerde scripts in de applicatie.
Softwaretesters mogen het programma alleen autoriseren en hun normale testronde uitvoeren als de code van de software voldoet; deze controles stellen de testers in staat potentiële toekomstige problemen aan het licht te brengen.
5. Leidt tot betere software
Mutatietesten helpen ervoor te zorgen dat de testprocessen van de toepassing voldoen aan de eisen van het programma.
Als uit een mutatieanalyse blijkt dat het kwaliteitsteam niet de juiste procedures volgt of de testgevallen ontoereikend zijn, kunnen de testers eraan werken om dit te verbeteren. Zonder deze zorgvuldigheid kan de organisatie een gebrekkig product uitbrengen zonder het te beseffen.
6. Effectief voor verschillende talen
Welke taal een testteam ook gebruikt voor zijn toepassing, er is software beschikbaar die mutatieanalyses van hoge kwaliteit kan bieden.
Dit omvat een aantal kwaliteitskenmerken die specifiek zijn voor de taal, waardoor de controles worden gestroomlijnd voor een grotere betrouwbaarheid. Een aanpak op maat voor verschillende talen verhoogt de kwaliteit van elke afzonderlijke test.
7. Zeer toegankelijke instrumenten
Veel van de beste mutatieplatforms zijn volledig open source – wat betekent dat ze meer maatwerk en een uitgebreide reeks functies bieden, gratis of tegen drastisch lagere kosten.
Met minder barrières in vergelijking met veel andere vormen van testen, is code-mutatie een nuttige en handige manier voor bedrijven om hun aanpak van kwaliteitsborging te beoordelen of zelfs te verbeteren.
Uitdagingen van mutatietests
Dit proces gaat ook gepaard met tal van uitdagingen, zoals:
1. Vereist programmeerkennis
Om deze controles uit te voeren, moeten testers een uitgebreid begrip hebben van het programma en de code, waardoor het voor minder ervaren testers moeilijk wordt om een bijdrage te leveren.
Een bedrijf kan alleen software testen op een manier die past bij de bestaande vaardigheden van de testers; met name hun vermogen om een applicatie te bewerken en een herstelbare codeerfout te creëren.
2. Niet geschikt voor black-box testing
Bij black-box testing wordt voornamelijk gekeken naar de voorkant van een applicatie zonder de interne werking en code te inspecteren – dit is in feite onverenigbaar met mutatietesten.
Bijgevolg zijn deze controles slechts nuttig voor sommige tests in vergelijking met andere methoden; vele daarvan kunnen een veel grotere dekking van de gehele testfase bieden.
3. Het ontwerpen van mutatietests is tijdrovend
Code-mutatie kan een vervelend proces zijn, omdat het team individuele componenten moet vinden die de moeite van het muteren waard zijn. De beslissing welke mutaties moeten worden uitgevoerd, kan zelf veel tijd kosten; dit kan problematisch zijn wanneer andere soorten tests in feite wachten op deze controles om de testaanpak van het bedrijf volledig te valideren.
4. Kan veel code-mutaties vereisen
Op soortgelijke wijze rechtvaardigen complexe projecten natuurlijk een groter aantal mutanten om een alomvattende testaanpak te garanderen. Dit voegt meer tijd toe aan de mutatiefase en kan veel handmatige wijzigingen in de app-code met zich meebrengen.
Zonder hoogwaardige testautomatiseringssoftware met programmamutatiemogelijkheden kan dit voor de testers moeilijk zijn om met succes uit te voeren.
5. Testers merken misschien geen fouten op
De grootste zorg die mutatietesters en projectmanagers vaak hebben bij het uitvoeren van deze controles is de mogelijkheid dat softwaretesters (handmatig of geautomatiseerd) de problemen eenvoudigweg niet opmerken.
Dit kan een volledige herziening van de testprocedures van het bedrijf vereisen – hoewel dit de testers nog steeds vitale informatie kan opleveren over hun kwaliteitsborgingsnormen.
6. Kan geheugenintensief zijn
Mutatietesten vereisen doorgaans een grote hoeveelheid rekenkracht, hoewel dit kan afhangen van de toepassing die testers gebruiken.
Als de organisatie een beperkt aantal machines heeft of als deze apparaten lage specificaties hebben, kunnen ze moeite hebben om te veel gelijktijdige mutaties uit te voeren. Dit beïnvloedt hoeveel controles zij kunnen uitvoeren voordat de testfase eindigt.
7. De verslagen kunnen veel informatie bevatten
Hoewel dit voornamelijk afhangt van de interface van het mutatietestprogramma van een team, kunnen de rapporten die zij genereren moeilijk te ontleden zijn.
Dit betekent dat het tijd kost om ze handmatig te sorteren en de juiste testresultaten te vinden; sommige programma’s laten gebruikers het eigenlijke rapportageproces aanpassen; dit verschilt per toepassing.
Kenmerken van mutatietests
De belangrijkste kenmerken van effectieve mutatietests zijn:
1. Uitgebreide
Deze controles bestrijken elk belangrijk aspect van de software; bedrijven met voldoende middelen kunnen zelfs een mutatietest ontwerpen voor elke reguliere testcase.
Hoewel het exacte aantal afhangt van de mogelijkheden en voorkeuren van de organisatie, bestrijken effectieve mutatietests een breed scala aan gecodeerde kenmerken.
2. Strategisch
Programmamutaties moeten eveneens een duidelijke en goed geplande structuur volgen die de algemene testdoelstellingen van de organisatie vergemakkelijkt.
De fouten die zij produceren kunnen bijvoorbeeld realistische testfouten benaderen, waardoor de testers op deze problemen kunnen anticiperen als zij zich natuurlijk voordoen, waardoor het testproces van de onderneming aanzienlijk wordt verbeterd.
3. Constructief
Het doel van mutatietests is om tekortkomingen bij het testen aan het licht te brengen – en te laten zien hoe het team zijn controles zou kunnen verbeteren en kleine fouten zou kunnen herstellen wanneer die aan het licht komen.
Mutatietesters moeten voorrang geven aan “ongeldige” mutanten die de functionaliteit van de software beïnvloeden, waardoor het testen over het hele project duidelijker kan worden verbeterd.
4. Preëmptief
Deze controles bestaan om de algemene strategie van het team te valideren; dit betekent dat mutatietests beter werken in de vroege stadia van de ontwikkeling.
Als de testers belangrijke tekortkomingen in hun kwaliteitsborgingsaanpak opmerken, geeft dit hen de nodige tijd om hun testcases te wijzigen, zodat deze adequaat zijn.
5. Consistent
Mutatietests over verschillende iteraties van een applicatie moeten consistente resultaten opleveren, terwijl er ook meer controles worden toegevoegd om wijzigingen in de software op te vangen.
Latere controles moeten dezelfde aandacht voor details hebben om hun doeltreffendheid te behouden – zonder deze precisie kunnen de mutatietests minder nauwkeurig worden.
6. Subtiel
Mutatietests zijn bedoeld om na te gaan in hoeverre het kwaliteitsborgingsteam in staat is om via hun tests en platforms van derden fouten in de code op te sporen.
Dit betekent dat de tests niet onmiddellijk duidelijk moeten zijn voor iedereen die de software inspecteert; het doel is te onderzoeken hoe testers reageren op kleine problemen met de code.
7. Samenwerking
Zoals elke softwaretest is code-mutatie een proces dat doorgaans teamwerk en communicatie vereist om het succes ervan te verzekeren. Het handhaven van een collaboratieve sfeer helpt informatiesilo’s vermijden, die kunnen leiden tot miscommunicatie – dit garandeert ook dat elke tester gefocust blijft op de uit te voeren taken.
Soorten mutatietests
De drie belangrijkste soorten mutatietests zijn:
1. Waardeverandering
Waardemutaties wijzigen rechtstreeks de waarden binnen de code, waarbij een getal of letter wordt veranderd in een andere op een manier die de functionaliteit van de toepassing beïnvloedt.
De tester kan bijvoorbeeld de exacte parameters van het programma wijzigen, zoals de nummers waarop het reageert. Mutatietesters kunnen zich specifiek richten op de constante waarden van een software, omdat die bij normaal gebruik altijd hetzelfde blijven.
2. Beslissingsmutatie
Beslissingsmutaties wijzigen rekenkundige en logische operatoren, waardoor de reactie van de toepassing op specifieke situaties effectief wordt gewijzigd.
Zo heeft het verwisselen van een groter-dan operator (>) met een kleiner-dan operator (<) natuurlijk invloed op de uitvoer van het programma. Testers kunnen ook “of” verwisselen met “en” of omgekeerd, waardoor deze software en de manier waarop zij de informatie die andere testers en mogelijke gebruikers verstrekken, interpreteert, fundamenteel verandert.
3. Verklaring mutatie
Statement-mutaties wijzigen de eigenlijke statements van de code, waardoor de regels die een applicatie gebruikt om beslissingen te nemen, worden gewijzigd. Testers kunnen de inhoud van deze regels veranderen, dupliceren of zelfs verwijderen om na te gaan hoe het gemuteerde programma de functionaliteit van de software beïnvloedt.
Deze mutaties veranderen de bouwstenen van een programma, waardoor hele functies kunnen verdwijnen of anderszins niet meer werken.
Opheldering van enige verwarring
– Mutatietests vs. regressietests
Mutatie- en regressietests zijn beide nuttige benaderingen van softwaretests – inzicht in elk van deze technieken kan de algemene kwaliteitsborging van een bedrijf verbeteren.
1. Wat is regressietesten?
Bij regressietests onderzoeken testers software tussen verschillende iteraties om na te gaan of deze nog steeds functioneert ondanks wijzigingen in de code.
Zelfs kleine wijzigingen kunnen zonder deze controles tot ernstige problemen leiden, waardoor eerdere bugs mogelijk opnieuw opduiken. Dit vereist over het algemeen automatisering vanwege de complexe aard van het opnieuw testen van elk onderdeel; veel bedrijven zien daarom af van regressietests.
Testers kunnen deze controles uitvoeren op afzonderlijke eenheden, afzonderlijke onderdelen of het gehele product – de precieze tests die nodig zijn, hangen voornamelijk af van het project en de omvang ervan.
2. Wat is het verschil tussen mutatie- en regressietests?
Regressietests zijn vooral gericht op het controleren van het programma en de functionaliteit ervan, terwijl code-mutatie juist kijkt naar hoe de testers reageren op problemen.
De eerste vindt ook grotendeels plaats na meerdere iteraties van een programma, terwijl mutatiecontroles in elk stadium van de ontwikkeling kunnen plaatsvinden – hoewel meestal in het begin van de testfase.
Zowel regressie- als mutatietests kunnen betrekking hebben op individuele coderingseenheden en hoe kleine veranderingen kunnen leiden tot aanzienlijke problemen die testers moeten oplossen.
3. Conclusie: Mutatietesten versus geautomatiseerd testen
Automatisering is vaak een belangrijk onderdeel van mutatietests vanwege de enorme omvang van de controles en eenheden – dit maakt het soms essentieel voor een succesvol en uitgebreid testproces.
Bedrijven gebruiken vaak code-mutaties om hun automatiseringsplatform van derden te onderzoeken en hoe goed het problematische scripting identificeert.
De combinatie van een grondige catalogus van mutatiecontroles met geautomatiseerde software kan de dekking van het bedrijf aanzienlijk vergroten en zorgen voor sterkere resultaten.
Hoewel dit twee afzonderlijke testpraktijken zijn, hoeven ze niet tegenover elkaar te staan. De integratie van robotische procesautomatisering kan bijvoorbeeld de strategie voor mutatietests van een bedrijf versterken.
Wat heb je nodig om met Mutatietesten in software engineering te beginnen?
De gebruikelijke vereisten voor uitgebreide mutatietests omvatten:
1. Een duidelijke teststrategie
Het testteam moet een strategie vaststellen voor de mutatietests, inclusief de onderdelen en eenheden die het belangrijkst zijn om te onderzoeken.
Bepaalde aspecten van de code kunnen bijvoorbeeld integraler zijn voor het succes en de functionaliteit van een applicatie; de testers moeten ervoor zorgen dat er voldoende mutaties zijn om dit op te vangen.
Het testschema van het bedrijf is ook een belangrijke overweging, omdat dit ervoor zorgt dat de testers voldoende tijd hebben om de code te onderzoeken.
2. Geen scope creep
Zelfs met een grondige strategie waarin de aanpak van het bedrijf inzake mutatietests wordt uiteengezet, is het mogelijk dat het aantal tests aanzienlijk hoger ligt dan nodig.
Efficiëntie is van het grootste belang tijdens deze procedure, vooral omdat andere testfasen kunnen wachten tot het team de mutaties heeft gevonden en gedood. De testers moeten hun scope duidelijk definiëren voordat zij de code beginnen te muteren; dit zorgt ervoor dat alles beheersbaar is binnen een praktisch tijdsbestek.
3. Strenge documentatie
Elk testproces heeft baat bij volledige documentatie – vaak in de vorm van testgevallen die de afzonderlijke controles en eventuele relevante mutaties in detail beschrijven.
Dit illustreert de huidige vooruitgang van het team over de tests heen, wat vooral nuttig is voor managers en leidinggevenden. Het documenteren van elke codeverandering helpt testers ook om een duidelijke administratie bij te houden van de wijzigingen die zij aanbrengen.
Als het kwaliteitsteam tijdens het testen moeite heeft om deze mutaties te vinden, dienen deze documenten effectief als antwoordsleutel.
4. Bekwame testers
De testers die de code muteren moeten een goed begrip hebben van de software – inclusief de vele manieren waarop zij deze kunnen muteren of zelfs breken.
Mutatietesters weten ongeveer hoe hun wijzigingen de applicatie zullen beïnvloeden en hoe andere leden van het kwaliteitsteam de gemuteerde code zouden kunnen identificeren.
Dit vereist over het algemeen een goede programmeerkennis. Voor een effectieve mutatieanalyse moeten de testers van de software ook over goed ontwikkelde vaardigheden en testervaring beschikken.
5. Automatiseringssoftware
Automatiseringssoftware van derden kan een noodzaak zijn voor mutatietests, vanwege het aantal controles dat dit proces vaak vereist. Dit geldt vooral voor ingewikkelde toepassingen met meer code en functies die het kwaliteitsborgingsteam moet onderzoeken.
Bedrijven kunnen deze controles specifiek uitvoeren om te testen hoe automatiseringssoftware reageert op codeerfouten. Dit kan een kernonderdeel zijn van het proefproces van het bedrijf om te beslissen welke programma’s het nuttigst zijn.
Mutatie Testen
De gebruikelijke stappen die testers gewoonlijk volgen bij het uitvoeren van mutatieanalyses zijn:
1. Bereid de tests voor
Voorbereiding is de eerste stap van elk testproces. Dit omvat onderhandelingen over de exacte controles die moeten worden uitgevoerd en het verkrijgen van de nodige goedkeuring – zoals van bedrijfsleiders en belanghebbenden.
De testers moeten deze controles ontwikkelen op een manier die rekening houdt met het tijdschema van het project en toch alle belangrijke onderdelen omvat. De planning van het team kan bepalend zijn voor de doeltreffendheid van hun codemutaties.
2. Introductie van mutanten en fouten
Nadat de voorbereidingen zijn afgerond, begint het testteam de code te wijzigen en te muteren volgens hun plan om specifieke fouten te introduceren. Deze fouten moeten relatief klein zijn, omdat dit de testers in staat stelt het vermogen van de rest van het team om codeerproblemen op te sporen te meten.
Kleine fouten kunnen de organisatie ook helpen de gevoeligheid van haar automatiseringssoftware van derden te inspecteren.
3. De testgevallen toepassen
De testgevallen moeten rekening houden met elk mogelijk storingspunt in een toepassing – dit kan een herschrijving vereisen als het gemuteerde programma zonder fouten kan functioneren.
De testgevallen van een programma vertegenwoordigen de volledige breedte van de controles die testers uitvoeren; elk ervan moet de testers helpen eventuele verborgen mutaties aan het licht te brengen en moet integraal deel uitmaken van de bruikbaarheid van de toepassing.
4. Vergelijk de resultaten
Na het toevoegen van mutatiefouten aan het programma en het toepassen van de testgevallen van het team, moet het team de resultaten van zowel het oorspronkelijke als het gemuteerde programma vergelijken.
De hoop is dat voor elke succesvolle controle in het origineel, er ook een fout in de gemuteerde toepassing zit. Dit toont de capaciteiten van zowel de testers als de instrumenten die zij gebruiken.
5. Reageren op verschillende outputs
Als er verschillende outputs zijn tussen het oorspronkelijke en het gemuteerde programma zoals de testers verwachten, betekent dit dat het testgeval de mutant met succes kan doden door zijn aanwezigheid aan te tonen.
De testers kunnen dan doorgaan met vertrouwen in hun methodologie en hun vermogen om coderingsproblemen op te sporen. Voor deze specifieke tests zijn geen wijzigingen in de testcases nodig.
6. Verander de koffers indien nodig
Sommige codemutaties kunnen leiden tot identieke conclusies in de verschillende programma’s, hetgeen suggereert dat de testgevallen niet in staat zijn elke mogelijke fout in de toepassing met succes aan het licht te brengen.
In deze gevallen blijft de mutant “leven” en kan hij de software blijven beïnvloeden op manieren waar testers geen kader voor hebben – dit leidt tot het opstellen van betere testgevallen.
Hoe mutante programma’s maken
Mutante programma’s zijn in feite identiek aan de originele programma’s, op één kleine verandering na die de functionaliteit van een toepassing op kleine maar merkbare manieren kan beïnvloeden.
Uitgebreide en gedetailleerde testcases helpen een tester of softwaresuite deze veranderingen en de daaruit voortvloeiende fouten te lokaliseren. Voor elk geval dat het bedrijf controleert is zowel een origineel als een gemuteerd programma nodig, waarbij de effecten van elke verandering afzonderlijk worden getoond.
De programma’s bootsen meestal realistische fouten na, zoals typefouten in de codering. Het is ook belangrijk voor testers om “doodgeboren” mutanten te vermijden die verhinderen dat de toepassing wordt uitgevoerd – dit is te voor de hand liggend voor testers.
Wat te veranderen in een gemuteerd programma?
Zoals bij veel softwaretestvariabelen hangen de exacte wijzigingen die testers aanbrengen af van de toepassing en de code ervan.
Er zijn drie categorieën die de meeste mutatietests omvatten: operanden, uitdrukkingen en verklaringen. Door een van deze te veranderen kan een effectief gemuteerd programma ontstaan – dat laat zien hoe de verschillende waarden of regels de logica van een programma beïnvloeden.
Deze categorieën hebben betrekking op de drie hoofdtypen mutaties die testers onderzoeken; dit zijn respectievelijk beslissings-, waarde- en statementmutaties. De wijzigingen moeten gering zijn en mogen de uitvoering van een test niet volledig verhinderen.
Beste praktijken voor mutatietests
Bij het uitvoeren van mutatietests in het kader van softwaretests zijn er bepaalde praktijken die moeten worden gevolgd om sterke resultaten te garanderen, zoals:
1. Maximaliseer de mutatiescore
De mutatiescore van een programma is het percentage mutanten dat een team of toepassing met succes kan identificeren of “doden”.
Als een mutatietestronde bijvoorbeeld 40 mutanten heeft en de testers vinden er 36, dan is de mutatiescore 90% – het team streeft altijd naar een score van 100%.
2. Kies mutanten willekeurig
Hoewel het kan helpen om bepaalde onderdelen prioriteit te geven en ze grondiger te testen, is het ook nuttig voor testers om willekeurig te kiezen welke mutanten worden toegevoegd – vooral met een krappe deadline.
Zolang deze controles elk belangrijk type mutatie vertegenwoordigen, kan het kwaliteitsborgingsteam zijn algemene teststrategie voor software valideren.
3. Houd de veranderingen klein
De codemutaties moeten kleine afwijkingen van het oorspronkelijke programma weergeven, omdat dit illustreert hoe groot de kans is dat een tester bepaalde fouten ontdekt; kleine coderingsproblemen laten ook zien hoe gevoelig hun software is.
Het is van vitaal belang dat mutatietesters een evenwicht vinden waarbij deze kleine veranderingen toch merkbare fouten opleveren.
4. Eén mutatie per programma
Bij mutatietests worden individuele testgevallen afzonderlijk bekeken om na te gaan hoe volledig ze zijn. Om daarbij te helpen mag elk gemuteerd programma slechts één wijziging ten opzichte van het origineel hebben.
Programma’s met meerdere mutaties kunnen mogelijk niet effectief aan testgevallen worden gekoppeld; de mutaties kunnen elkaar tegenspreken.
5. Overweeg zorgvuldig automatiseringssoftware
Bedrijven gebruiken vaak code-mutatie om het gebruik van automatiseringssoftware door het team te valideren en ervoor te zorgen dat deze net zo effectief fouten kan opsporen als een menselijke tester.
Dit betekent dat de keuze van het juiste automatiseringsplatform een belangrijke overweging kan zijn, evenals de mogelijkheid om robotische procesautomatisering te integreren.
6. Gebruik testgestuurde ontwikkeling
Test-driven development (TDD) verwijst naar een specifieke techniek waarbij in elk stadium van de ontwikkeling rekening wordt gehouden met de testvereisten.
Dit helpt ervoor te zorgen dat de testgevallen volledig compatibel zijn met de software – zodat deze gemakkelijk mutatietests kan doorstaan en een beter programma kan maken dat synchroon loopt met kwaliteitsborgingsprocessen.
Soorten resultaten van een mutatietest
Er zijn verschillende outputs die mutatietests genereren, waaronder:
1. Mutant programma
De gemuteerde programma’s zijn een natuurlijke output van deze controles; de testers creëren deze om hun huidige testgevallen en de problemen die zij helpen opsporen weer te geven. De programma’s wijken meestal slechts op één kleine maar significante manier af van hun oorspronkelijke tegenhanger om een grotere betrouwbaarheid te garanderen.
2. Levende of dode mutant
Na de tests wordt een mutatie “gedood” of blijft ze “in leven” – dit verwijst gewoon naar het feit of de tester (of hun software) al dan niet met succes een coderingsprobleem vaststelt.
Als de mutant blijft leven, moeten de testgevallen misschien ernstig worden gewijzigd.
3. Mutatie testcase
Het kwaliteitsteam gebruikt afzonderlijke mutatiespecifieke testgevallen die informatie over hun muterende programma’s registreren.
Dit helpt om ervoor te zorgen dat het team voor elke controle over uitgebreide dossiers beschikt; deze documenten bevatten details over de mutaties en de gevolgen ervan voor het programma.
4. Mutatiescore
Het einddoel van elke mutatietest is het bereiken van een mutatiescore van 100%, waarbij de testprocedures van het bedrijf met succes elke mutant opsporen en doden. Alles wat minder is, wijst erop dat hun testgevallen en algemene processen moeten worden verbeterd om problematische code op te sporen.
Voorbeelden van mutatietesten
Hier zijn drie voorbeelden van mutatietests:
1. Voorbeeld van waardemutatie
Bij waardeveranderingen wordt een constante of parameter gewijzigd, waardoor de grenzen van het programma kunnen veranderen. De software van een geautomatiseerde kassa kan bijvoorbeeld het gewicht van een voedingsmiddel gebruiken om de prijs ervan te bepalen.
De testers zouden de code achter dit programma kunnen muteren om de gewichtsparameters te veranderen, waardoor voedsel veel duurder wordt per ons of pond. De tester of het testplatform moet de effecten van de verschillende waarden op dit programma kunnen identificeren.
Aangezien deze fout een van de belangrijkste functies van de software wijzigt, moeten de testgevallen deze fout opmerken en het team waarschuwen.
2. Voorbeeld van besluitmutatie
Beslissingsmutaties omvatten het wijzigen van een rekenkundige of logische operator, het omkeren of anderszins wijzigen van hoe deze toepassing op gebruikersinvoer reageert. Om terug te komen op het voorbeeld van een zelfkassa, deze machines kunnen een artikel met een onverwacht hoog gewicht signaleren, mogelijk als gevolg van een gebruikersfout.
De code van de machine zou dit kunnen doen via een “if (a>b)” beslissing – waarbij “b” het verwachte gewicht weergeeft, en “a” overeenkomt met het werkelijke gewicht. Het team kan dit muteren in “if (a≤b)”, waardoor de reactie van de kassa verandert; dan wordt het artikel zelfs bij het verwachte gewicht gemarkeerd.
3. Voorbeeld van mutatie
Statementmutaties houden in dat een regel of uitvoer wordt gewijzigd – dit kan zelfs inhouden dat statements helemaal uit de applicatie worden verwijderd. Deze mutaties kunnen meer opvallen dan andere, afhankelijk van de frequentie van de specifieke uitspraak; het is van vitaal belang dat testers de uitspraak verstandig kiezen.
Een self-checkout machine kan bijvoorbeeld een waarschuwing weergeven als een gebruiker probeert een leeftijdsbeperkt artikel te kopen. Zonder de bijbehorende verklaring kan de machine vastlopen of een klant toestaan een artikel te kopen.
Door de verklaring te muteren en aan het team duidelijk te maken, kunnen de testers nagaan of hun aanpak deze problemen ondervangt.
Soorten fouten en bugs die met mutatietests worden opgespoord
Mutatietests brengen vooral problemen in het testproces zelf aan het licht. Met dit in gedachten is hier een reeks problemen die deze controles kunnen helpen opsporen:
1. Onduidelijke testgevallen
Als de mutatieanalyse een lage mutatiescore laat zien (of zelfs een score onder de 100%), suggereert dit dat de testgevallen van het team niet in staat zijn om rekening te houden met alle mogelijke fouten die een toepassing kunnen treffen.
Ze zijn misschien niet specifiek of breed genoeg om aan de eisen van het team te voldoen. Deze documenten moeten alle mogelijkheden omvatten die het team tijdens het testen van de software kan tegenkomen om de betrouwbaarheid te garanderen.
2. Ongetraind testteam
Mutatietests kunnen ook een beeld geven van de capaciteiten van het team, zoals hoe goed zij persoonlijk mutaties en andere fouten kunnen opsporen. Indien zij ondanks duidelijke en gedetailleerde testgevallen de mutanten in de programma’s niet kunnen opsporen, is dit mogelijk te wijten aan het feit dat de testers deze gevallen niet correct hebben toegepast.
Mutante programma’s kunnen problemen vertonen tijdens het hele testproces – dit kan ook gelden voor ongeschoolde of ongetrainde testers.
3. Inadequate testsoftware
Als een bedrijf deze controles gebruikt om zijn eigen testplatform te inspecteren, kan het ontdekken dat de software gemuteerde code niet nauwkeurig kan identificeren of doden.
Het bedrijf kan reageren door andere keuzes te onderzoeken totdat het er een vindt die verenigbaar is met zijn testgevallen. Als de automatiseringssoftware er niet in slaagt problematische code te vinden, zal het waarschijnlijk moeite hebben andere problemen op te sporen die de software beïnvloeden.
4. Niet-geoptimaliseerde code
Mutatietests kunnen problemen aan het licht brengen die al in de software aanwezig zijn. Testers kunnen bijvoorbeeld proberen de code te muteren, maar zelf kritieke gebreken ontdekken.
Dit dient als een ander belangrijk perspectief van het programma, waaruit blijkt dat code-mutatie voordelen biedt die verder gaan dan het testproces. Hoe meer testers deze code onderzoeken, hoe meer problemen het team kan ontdekken en oplossen tijdens de testfase.
Gemeenschappelijke metriek van de mutatietest
De belangrijkste maatstaven die bij mutatietests worden gebruikt, zijn onder meer:
1. Gedode mutanten
Dit heeft betrekking op het aantal mutaties dat de testers of de software hebben kunnen vaststellen, waarbij het bestaan ervan wordt gemarkeerd zodat het personeel kleine fouten zoals deze kan opsporen.
Het aantal mutanten dat de testers doden hangt af van de sterkte van hun testcases.
2. Levende mutanten
Levende mutanten zijn die welke de tester of de software niet identificeert – waaruit blijkt dat er hiaten zijn in de kwaliteitsborgingsstrategie van het team. Als dit gebeurt, moeten de testers hun proces en testgevallen opnieuw afstemmen op deze mutanten en ze bij toekomstige controles uitschakelen.
3. Geldige mutanten
Deze metriek bepaalt het aantal mutaties dat het programma met succes kon opnemen zonder dat een runtime error de test en de effectiviteit ervan teniet deed.
Geldige mutaties zijn die welke de tester en de automatiseringssoftware kunnen onderzoeken; dit komt doordat de mutaties relatief klein zijn.
4. Ongeldige mutanten
Aanzienlijke mutaties kunnen de toepassing zodanig beïnvloeden dat testen onpraktisch of zelfs onmogelijk wordt – daarom helpt het om bij te houden hoeveel “ongeldige” mutaties er in het gemuteerde programma aanwezig zijn.
Door deze te identificeren kunnen testers ze bewerken of zelfs verwijderen, zodat de controles alleen geldige mutaties omvatten.
5. Totaal aantal mutanten
Het aantal mutaties ongeacht hun geldigheid is een andere metriek die testers bijhouden; zo kunnen zij de mutaties volgen en hun status registreren.
Aangezien elke mutatie gewoonlijk een afzonderlijke test omvat, dient het totaal ook als telling voor het aantal totale codemutaties.
6. Mutatiescore
De nuttigste metriek voor mutatieanalyse is meestal de mutatiescore, die in feite het percentage geldige mutaties is dat de tester of automatiseringssuite heeft kunnen detecteren.
Een detectie van minder dan 100% kan wijzen op onjuiste testprocedures.
7 fouten en valkuilen bij het uitvoeren van mutante tests
Mutatietests zijn een complex proces dat bedrijven verstandig moeten uitvoeren om ernstige problemen of fouten te voorkomen. Hier zijn zeven valkuilen die testers moeten vermijden bij het uitvoeren van mutatietests:
1. Onjuiste mutatieschaal
Schaal is een belangrijke overweging bij mutatieanalyse, aangezien dit proces bestaat om ervoor te zorgen dat testers kleine fouten binnen een toepassing identificeren. Als de mutatie te duidelijk is voor testers, is dit wellicht geen effectieve manier om te controleren of zij in staat zijn softwareproblemen op te merken of tegen te gaan.
2. Ongeldige of levende mutaties
Zelfs op de juiste schaal zijn veel mutaties slechts beperkt effectief – bijvoorbeeld als ze niet leiden tot een fout, of als ze leiden tot een probleem waardoor de toepassing niet meer werkt.
Testers moeten er rekening mee houden hoe elke wijziging in de codering de hele software kan beïnvloeden.
3. Onverenigbare testgevallen
De testgevallen en mutaties moeten perfect op elkaar aansluiten om consistent en harmonieus te kunnen testen. Bij de beslissing welke mutaties moeten worden toegevoegd of zelfs bij het ontwerpen van de eerste testgevallen, kan het kwaliteitsborgingsteam ervoor zorgen dat deze op elkaar aansluiten en leiden tot soepeler testen in het algemeen.
4. Termijnen en tijdschema’s
De testfasen variëren in lengte, maar moeten altijd binnen de interne bedrijfstermijnen blijven. Bedrijven die hun mutatietests niet goed plannen, kunnen het proces wellicht niet op tijd afronden.
Voordat een project de testfase bereikt, moet het team ervoor zorgen dat het testschema voldoende uitgebreid is.
5. Ontoereikende testdekking
Bedrijven kunnen ervoor kiezen hun code-mutaties willekeurig te implementeren – maar het is nog steeds belangrijk dat ze een breed scala aan onderwerpen bestrijken.
Om ervoor te zorgen dat zowel de testers als de software elk type mutant kunnen detecteren, moeten de controles minimaal verschillende waarde-, beslissings- en statementmutaties omvatten.
6. Mutanten gebruiken om de software te testen
Hoewel mutatietesten een nieuwe kijk op een toepassing bieden, moeten teams deze methode alleen gebruiken om hun eigen testproces te controleren. Het bedrijf moet de precieze mogelijkheden en beperkingen van mutatietests begrijpen; deze techniek kan alleen slagen naast andere softwarecontroles.
7. Te veel mutanten
Het is van het grootste belang dat bedrijven zorgen voor een brede testdekking, maar ze zouden daarbij te veel mutanten kunnen implementeren. Elk mutatieprogramma vergt een aanzienlijke hoeveelheid rekenkracht, waardoor het aantal dat een organisatie tegelijkertijd kan uitvoeren, beperkt is.
Te veel mutaties uitvoeren kan het ook moeilijker maken om testdeadlines te halen.
Checklist, tips en trucs voor mutatietests
Er zijn een aantal aanvullende tips die elk team kunnen helpen het succes van hun mutatietestproces te verbeteren, zoals:
1. Controleer de compatibiliteit van de programmeertaal
Zowel gratis als betaalde tools voor mutatietests zijn doorgaans gespecialiseerd in één coderingstaal – waardoor het belangrijk is dat de testers een tool kiezen die compatibel is met de applicatie en het softwaretestplatform.
Het testteam moet vele opties onderzoeken om ervoor te zorgen dat zij een programma gebruiken dat zowel bij hun budget als bij de coderingstaal van hun voorkeur past.
2. Tests verstandig verdelen
Verschillende leden van het testteam zullen waarschijnlijk naar verschillende aspecten van de toepassing kijken, meestal in overeenstemming met hun specifieke sterke en zwakke punten en hun algemene ervaring.
Wanneer het team mutatietesten toewijst aan elke tester, moeten ze dit in gedachten houden om een idee te krijgen van hun vaardigheid; dit laat zien hoe goed verdere testen waarschijnlijk zullen gaan.
3. Kies fouten zorgvuldig
Als een recente iteratie van de software een bug had in een waarde of verklaring, kan het helpen dit te repliceren en te onderzoeken hoe het team of het programma reageert.
Dit helpt de levensduur van de applicatie te garanderen en illustreert het vermogen van het team om eerdere fouten op te merken als deze zich opnieuw voordoen – dit is een belangrijk onderdeel van regressietests.
4. Maximale rekenkracht
Aangezien mutatiecontroles veel rekenkracht vergen, helpt het om de hardware van het bedrijf optimaal te benutten.
Als bepaalde machines bijvoorbeeld sterkere specificaties hebben, kan het nuttig zijn de mutanten op deze apparaten te laten draaien. Hierdoor kan de onderneming aanzienlijke vertragingen vermijden waartoe tragere machines zouden kunnen leiden.
5. Verwerp geen levende mutaties
Zelfs met een strikt schema moeten testers hun testcases aanpassen en uitbreiden om eventuele mutanten die het proces overleven te bestrijden.
Hoewel deze fouten misschien niet significant lijken als de software of de tester ze niet ontdekt, vormen ze toch een falen van de testgevallen om alle coderingsproblemen op te sporen.
6. Onderzoek naar nieuwe automatiseringssoftware
Als de testgevallen van het team voldoende gedetailleerd zijn, maar hun geautomatiseerde testsuite niet in staat is elke mutatie met succes te identificeren, kunnen ze baat hebben bij andere software.
Er zijn veel gratis en betaalde platforms beschikbaar, en bedrijven zouden elke optie moeten controleren om er zeker van te zijn dat ze de software hebben die op lange termijn het beste bij hun testgevallen past.
7. Synchroniseer elk testproces
Samenwerking is een kernonderdeel van elke teststrategie – dit helpt ervoor te zorgen dat elk proces gemakkelijk in elkaar past zoals het team het wil.
Zo zou het testteam zijn testcases kunnen ontwikkelen met het oog op mutatie, om een grotere mate van compatibiliteit te garanderen.
8. Eenheidstests gebruiken
Unit testing laat het kwaliteitsborgingsteam stukken code afzonderlijk inspecteren, waardoor de tests enorm worden gestroomlijnd en de teams gemakkelijker problemen kunnen opsporen.
Deze combinatie kan vooral nuttig zijn als de testers zich zorgen maken over deadlines, zodat ze hun controles kunnen vereenvoudigen en de totale dekking kunnen verbeteren – wat leidt tot veel sterkere softwaretests.
9. Gedetailleerde testgevallen schrijven
Mutatietestgevallen moeten voldoende informatie bevatten over de mutant en het effect daarvan op het programma, alsmede over de wijze waarop het testteam of het platform deze fouten heeft gelokaliseerd.
Door zoveel mogelijk details te verstrekken, kan een tester de testcase persoonlijk valideren en ervoor zorgen dat het team precies weet hoe het testen soepel moet verlopen.
5 beste tools voor mutatietesten
Er is een breed scala aan hulpmiddelen beschikbaar die bedrijven kunnen helpen met hun eisen op het gebied van mutatietests. Zoals vaak het geval is met software test applicaties, variëren de prijzen en mogelijkheden van het ene platform tot het andere, waardoor het van vitaal belang is dat organisaties het platform kiezen dat het beste past bij hun behoeften.
Sommige van deze programma’s kunnen gratis tegenhangers bieden of volledig open source zijn; hoewel betalen voor meer gemak meestal noodzakelijk is.
Met dit in gedachten zijn hier de vijf beste hulpmiddelen voor mutatietests.
1. Stryker
Stryker is gespecialiseerd in JavaScript-mutatie, en stroomlijnt dit proces aanzienlijk om geen fout-positieven te garanderen en de totale hoeveelheid inspanning te verlagen die testers anders zouden moeten toepassen voor alle mutatiecontroles.
Het Stryker-platform beoordeelt de software op intelligente wijze en gebruikt de verzamelde informatie om uit te zoeken welke strings of segmenten van de code baat zouden hebben bij mutatie. Deze toepassing komt met een clear-text reporter die een samenvatting geeft van de mutant, inclusief of Stryker hem heeft kunnen doden.
2. PITest
PITest is wereldwijd zeer populair vanwege zijn vermogen om Java byte-code te veranderen en duizenden mutaties per seconde uit te voeren. Deze toepassing gebruikt testcase coverage gegevens om direct te leren welke tests een mutant zouden kunnen doden.
Hij voert alleen tests uit waarvan hij weet dat ze relevant zijn, waardoor de rekenkracht die deze procedure gewoonlijk kost, wordt beperkt. PITest is ook compatibel met de meeste vormen van de Surefire eenheidstest-plugin, maar kan worstelen met het effectief beheren van testorderafhankelijkheden.
3. Verzekeren++
Insure++ heeft vele testmogelijkheden, waaronder mutatieanalyse, waardoor het platform dubbelzinnigheden in een programma kan opsporen. In tegenstelling tot conventionele mutatietests genereert Insure++ geen foutieve mutanten, maar functioneel gelijkwaardige mutaties die overeenkomen met de broncode van het project.
Dit is om impliciete aannames te vermijden die het testproces onbedoeld kunnen beperken en mogelijk geen realistische testomgevingen weerspiegelen. Zoals de naam doet vermoeden, is het platform hoofdzakelijk compatibel met C++ programma’s, en elke functie is op deze taal afgestemd.
4. Jumble
Deze toepassing is gespecialiseerd in het JUnit JavaScript framework, met uitgebreide visuele indicatoren van hoe de code reageert op mutatie-analyse. Jumble is een open source platform en werkt binnen de byte-code van Java-toepassingen om de tijd van elke testcyclus te verkorten.
Soortgelijke toepassingen die uitsluitend de broncode van een programma gebruiken, kunnen er soms langer over doen om deze controles uit te voeren vanwege hun hercompileringsproces.
Jumble maakt ook gebruik van heuristieken om de mutatietests nog verder te optimaliseren, waardoor latere testruns eenvoudiger worden.
5. MutPy
MutPy ondersteunt mutatietests voor Python-gebaseerde toepassingen en biedt volledige ondersteuning voor mutaties van hoge orde en uitgebreide dekkingsanalyse. De interface van dit programma is gemakkelijk te gebruiken tijdens de uitvoerfase, waarbij de gebruikers duidelijk elk essentieel detail van de mutatietests van het team te zien krijgen.
MutPy biedt testers veel keuzemogelijkheden op maat, zodat zij deze software specifiek op hun behoeften kunnen afstemmen. Het platform gebruikt Abstract Syntax Trees die een duidelijke structuur geven van de broncode van de applicatie, waardoor testers meer vertrouwen krijgen in hun mutaties.
Conclusie
Code mutatie heeft toepassingen voor bijna elk software testproces en biedt een aantal duidelijke voordelen voor bedrijven die deze techniek toepassen – vooral eerder in de kwaliteitsborgingsfase.
Geen enkele methode is zonder uitdagingen; dit betekent dat het noodzakelijk is dat organisaties de voordelen van mutatieanalyse verstandig overwegen en er tegelijkertijd voor zorgen dat het past in hun gebruikelijke tijdschema voor softwareontwikkeling.
Deze mutaties geven testteams een kans om hun eigen aanpak te onderzoeken en te bepalen hoe effectief deze is bij het opsporen en herstellen van fouten in de broncode. Deze techniek is bijzonder compatibel met automatiseringsprocedures, zodat bedrijven de software kunnen valideren die zij vertrouwen om hun controles uit te voeren.
Mutatietests bieden een uitgebreide manier voor kwaliteitsborgingsteams om meer inzicht te krijgen in hun eigen processen en software, inclusief de problemen die zij anders niet zouden ontdekken.
Het is dan ook van vitaal belang dat testteams deze techniek nauwkeurig onderzoeken om na te gaan of hij aansluit bij de behoeften van de organisatie – onder meer of het gekozen mutatiehulpmiddel volledig compatibel is met hun programmeertaal. De geautomatiseerde testsoftware ZAPTEST heeft vele functies waarmee het mutatietests kan doorstaan, zodat teams het volste vertrouwen hebben in zijn capaciteiten.
Zowel de Free- als de Enterprise-versie bieden een hoogwaardig testproces dat gemakkelijk codewijzigingen kan verwerken.
FAQ’s en hulpmiddelen
1. Beste cursussen over mutatietesten
Online cursussen kunnen beginnende testers helpen de basisbeginselen van code mutatie te leren of de reeds bestaande vaardigheden van ervaren kwaliteitsmedewerkers versterken. Algemene softwaretestlessen kunnen testers ook veel voordelen bieden. De beste online cursussen voor mutatietesters zijn onder andere:
– PluralSight’s ‘Mutatietesten in Java met PITest’ gaat specifiek in op het wijzigen van Java-code en de manieren waarop deze aanpak praktische softwaretestprocessen ten goede kan komen.
– Udemy’s ‘The Complete 2023 Software Testing Bootcamp’ is een bijzonder actuele cursus die elk belangrijk onderdeel van softwaretests illustreert, inclusief white-box testing.
– Alison’s ‘Software Testing – Condition Coverage and Mutation Testing Strategies’ is gratis en onderzoekt nauwkeurig hoe mutatietests verstandig kunnen worden uitgevoerd.
– PluralSight’s ‘Unit Testing Fundamentals’ verkent de voordelen en kenmerken van unit testing, en helpt studenten het exacte proces te begrijpen voor het schrijven van sterke unit tests.
– Udemy’s ‘Introduction to Unit Testing’ is een andere gratis cursus die een duidelijk beeld geeft van unit testing en het belang van testgestuurde ontwikkelingsstrategieën.
2. Wat zijn de top 5 interviewvragen over Mutatietesten?
Bedrijven kunnen kandidaten tijdens een sollicitatiegesprek een aantal vragen stellen om hun ervaring met of begrip van mutatietests en de kernbeginselen ervan na te gaan. Zo kan een bedrijf ervoor zorgen dat het een gekwalificeerde tester inhuurt die verschillende mutatiescenario’s met gemak kan benaderen.
De precieze vragen variëren, maar ze kunnen bijvoorbeeld vragen naar hun eigen mening of naar voorbeelden van hun vaardigheden op het gebied van codemutatie.
De top vijf mutatietest interview vragen zijn:
– Met welke tools voor mutatietests heeft u al ervaring? Wat waren de belangrijkste kenmerken van deze software?
– Hoe zou u bij het uitvoeren van codemutatie zorgen voor een gezond evenwicht tussen testsnelheid en diepgang?
– In welke situaties zou mutatie-analyse onmogelijk zijn? Hoe zou u de testprocedure in deze scenario’s controleren?
– Als een waardeverandering het testproces weet te overleven, wat doet u dan om herhaling te voorkomen?
– Welke informatie zou u in een mutatietestcase opnemen om te garanderen dat uw collega’s over de gegevens beschikken die zij nodig hebben?
3. Beste YouTube-tutorials over mutatietesten
Op YouTube zijn gratis tutorials, webinars en andere video’s beschikbaar om een tester meer inzicht te geven in mutatietests. Enkele van de nuttigste video’s en series over dit onderwerp zijn:
– ‘Mutation Testing for Programs’ van Software Testing, dat praktische voorbeelden geeft van hoe code-mutatie programma’s helpt, naast hoe je gedegen testgevallen schrijft.
– Devoxx’s ‘Mutatie testen: Heeft mijn test mijn code gebroken?’, waarin wordt bekeken hoe mutatieanalyse de algemene testprocedures voor allerlei soorten softwareprojecten verbetert.
– NDC Conferences’ ‘Kill All Mutants! Intro to Mutation Testing’, waarin wordt onderzocht hoe testsuites kunnen profiteren van code-mutatie en de fouten die daardoor ontstaan.
– GOTO Conferences’ “Mutation Testing in Python”, waarin specifiek wordt onderzocht hoe op Python gebaseerde toepassingen mutatieanalyse kunnen toepassen om specifieke testdoelstellingen te bereiken.
– Diego Pacheco’s “Java Mutation Testing With PITest”, waarin op vergelijkbare wijze wordt geïllustreerd hoe JavaScript software code mutatie gebruikt – met de nadruk op het PITest mutatieprogramma.
4. Hoe mutatietests onderhouden?
Door mutatieanalyse te combineren met regressietests en andere langetermijnstrategieën kunnen bedrijven ook na de release een sterke kwaliteitsborging waarborgen.
Latere updates kunnen leiden tot codewijzigingen die verdere controles vereisen. Mutatietesten tonen aan dat de automatiseringssoftware en de testers consistent zijn in verschillende versies van dezelfde software, waardoor hun specifieke aanpak opnieuw wordt geauthenticeerd.
Nieuwe functies vereisen nieuwere testgevallen, vooral als deze functies interageren met reeds bestaande.
Bovendien stelt het gebruik van testgestuurde ontwikkeling de teamleden in staat de levensduur van de software te plannen en de compatibiliteit te testen als onderdeel van de eigen ontwikkelingscyclus.
