Mutationstest eller programmutation er en white-box testteknik, der hjælper virksomheder med at udvikle en række nye softwarekontroller og samtidig auditere et projekts nuværende processer. Dette er en relativt ny tilgang, som sikrer, at både udviklere og testere arbejder efter en høj standard.
En applikation er kun så vellykket eller god som dens egne kvalitetssikringsprocedurer – hvilket betyder, at det er vigtigt, at organisationer anvender mere end én type testteknik.
Ved at lære om mutationstestning kan testteams få hjælp til at øge deres færdigheder og generelle repertoire, så de kan forbedre pålideligheden af disse kontroller. Mutationstestning er en kompleks og følsom proces, så det er afgørende, at testerne undersøger fordelene, udfordringerne og programmerne fra tredjeparter, som kan garantere en vellykket implementering, grundigt.
I denne artikel ser vi på mutationstestning og hvordan den forbedrer kvalitetssikringen samt andre vigtige overvejelser for softwaretestteams.
Hvad er mutationstest i softwaretestning?
I forbindelse med software betyder mutationstest, at et kvalitetssikringsteam bevidst indfører fejl – eller “mutationer” – i et programs kode for at se, hvordan teamet reagerer. Målet er at skabe en fejl og sikre, at testpakken er i stand til at identificere alle ændringer i programmet.
Når en mutationstester redigerer programmets kode, kan han skifte et sandt/falsk udtryk, slette et udsagn eller blot ændre en værdi. Disse fejl kan manifestere sig på en række forskellige måder under andre softwarekontroller, som alle let kan opdages af et dygtigt og erfarent testteam.
Selve ændringerne er ofte meget små, hvilket giver den tester, der ændrer koden, mulighed for at observere, hvordan teamet opdager disse ændringer. Betydelige ændringer vil være indlysende ved selv et overfladisk blik – så mindre fejl er typisk den bedste måde at sikre, at virksomheden anvender robuste testmetoder.
Denne teknik undersøger specifikt effektiviteten af et teams testcases, dvs. de dokumenter, der indeholder testinformationerne. Teamet kan også bruge tredjeparts automatiseringssoftware til at udføre disse kontroller, og i så fald undersøger mutationstest, hvor godt denne platform kan opdage fejl i programmets kode.
1. Hvornår skal du lave mutationstest?
Da formålet med mutationstestning er at validere og forbedre de nuværende kvalitetssikringskontroller, er det vigtigt for teams at udføre dette tidligt i testfasen. Det betyder, at hvis testpakken ikke er i stand til at identificere og “dræbe” mutanterne, er der tid nok til at foretage gennemgribende ændringer af enhver størrelsesorden i organisationens testprocedurer.
Da der er tale om en meget alsidig metode, kan mutationstestning anvendes til stort set alle typer software, herunder web-, mobil- og desktopprogrammer. Dette fungerer bedst i enhedsafprøvningsfasen – hvor man undersøger applikationens mindste komponenter.
2. Når du ikke har brug for at lave mutationstest
Der er stadig nogle scenarier, hvor mutation og generel white-box-testning ikke er passende for et program; dette kan skyldes forskellige årsager.
Hvis testerne f.eks. kun har til formål at kontrollere med black-box-testning – i så fald vil de i stedet fokusere på front-end for den pågældende session eller endog den overordnede testfase.
Der er nogle virksomheder, der mener, at white-box-testning er besværligt og tidskrævende, hvilket kan resultere i, at de springer processen over. Stærke, velkontrollerede testcases kan også omgå behovet for mutationstestning, da det viser teamets flid og engagement i præcise testprocedurer.
3. Hvem er involveret i mutationsanalyse?
Der er en række forskellige roller involveret i mutationsanalyser, herunder:
– Mutationstestere
De ændrer koden ved at indføre forskellige mindre fejl for at sikre, at testprocessen fungerer som forventet. Disse testere er normalt allerede eksisterende medlemmer af kvalitetssikringsteamet.
– Applikationstestere
De kontrollerer koden regelmæssigt for eventuelle problemer og identificerer og korrigerer eventuelle mutationer, som de finder. De udfører white-box-test for at finde kodningsfejl – men bruger også andre teknikker.
– Applikationsudviklere
De designer programmets funktioner og skriver den oprindelige kode. De løser også eventuelle problemer, som testerne finder, og sikrer, at softwaren er i en stabil tilstand, inden den frigives.
– Projektledere
De giver vejledning om ansøgningen og kan arbejde sammen med mutationstesterne for at se, om deres egne hold er effektive. De sikrer stærke standarder i alle udviklingstrin.
Hvad tester vi med mutationstest?
Ved mutationstestning fokuseres der mere på testprocesser end på applikationen. Med henblik herpå undersøger den følgende:
1. Testcases
Testcases er dokumenter, der indeholder detaljerede oplysninger om hver enkelt test, herunder de resultater, som testerne forventer af hver enkelt kontrol. Konsistente og præcise testcases giver medlemmerne af QA-teamet en idé om applikationens tilstand og om, hvordan dens ydeevne svarer til virksomhedens forventninger.
Oplysningerne i disse testcases kan være afgørende for testerens evne til at opdage visse fejl – herunder dem, som mutationstestning giver anledning til.
2. Prøvningsstandarder
Mutationstests undersøger nøje de nuværende testprocedurer for at sikre, at teammedlemmerne kan identificere selv mindre problemer, der kan påvirke brugerens opfattelse af softwaren.
Testernes flid og kompetence kan endda være de vigtigste faktorer, som en virksomhed vurderer ved disse kontroller. Uden stor opmærksomhed på detaljerne i alle faser kan testerne overse alvorlige mutationer, der findes i programmet.
3. Individuelle enheder af kode
Mutationstests er almindelige i forbindelse med enhedstest i udviklingsprocessen. Dette ser på individuelle komponenter for at bevare et stærkt fokus på hver enkelt test, hvilket optimerer hele processen betydeligt ved at sikre, at testerne kun arbejder med de relevante kodelinjer.
Da mutationstest ofte er tidligt i kvalitetssikringsfasen og kan være en forløber for testning i fuld skala, kan denne fremgangsmåde øge hastigheden uden at gå på kompromis med nøjagtigheden.
4. Programopdateringer
Softwareopdateringer indebærer normalt en genstart af testprocessen for at sikre, at der ikke er nye fejl, og at tidligere fejl ikke dukker op igen.
Gentagelse af mutationstest er en vigtig del af dette og bidrager til at fremme konsekvente teststandarder efter større softwareændringer.
Testteamet vil måske anse grundige kontroller efter opdatering for unødvendige, men ved hjælp af kodemutation kan man sikre, at de forstår vigtigheden af at teste i alle udviklingsfaser.
5. Automationssoftware
Virksomheder udfører også mutationstest for at inspicere deres automatiserede testsuiter og sikre, at de er i stand til at opdage muteret kode, blandt andre problemer.
Hvis et testprogram fra en tredjepart kan identificere eksterne ændringer i et program og potentielt endda rette det, betyder det, at organisationen kan stole på softwaren til at automatisere testene.
Det er vigtigt, at virksomheder validerer deres automatiseringstilgang; det giver alle testere ro i sindet.
6. Automatiseringsstrategi
Hvordan virksomheden integrerer automatisering i sine processer er lige så vigtigt som den software, den anvender; den kan f.eks. beslutte sig for at implementere hyperautomatisering. Dette giver virksomheden mulighed for at beslutte, hvilke mutationer og softwaretests der skal automatiseres.
Uden en stærk automatiseringsstrategi, der tager højde for den store variation i en applikations kode, kan nogle tests være uforenelige med automatisering – hvilket begrænser platformens muligheder.
7. Ansøgningen
Selv om mutationstestning fokuserer mere på testteamet end på programmet, kan den stadig fremhæve vigtige oplysninger om programmet.
For eksempel viser mutationstestning, hvordan software reagerer på ændringer i koden, herunder om den signalerer problemerne på den måde, som teamet forventer.
Denne fremgangsmåde er ikke en softwaretestteknik, men kan alligevel give interessante data om dens interne drift.
Livscyklus for mutationstest
Den sædvanlige livscyklus for mutationstest er som følger:
1. Analyse af krav
Det første skridt i enhver livscyklus for mutationstestning er at finde ud af præcis, hvad der kræver validering, og hvilke dele af applikationens kode der har størst gavn af disse tests.
Teamet kan tale med udviklere og ledere for at finde frem til deres bekymringer og begynde at tage fat på dem.
2. Planlægning af test
Testerne begynder derefter at udvikle de nøjagtige kontroller, som de har til hensigt at gennemføre – i dette tilfælde de mutationer, der vil give den bedste indsigt.
I denne fase fastlægges den overordnede strategi for test af mutationer, og hvordan teamet effektivt vil gennemføre de planlagte kodemutationer.
3. Udvikling af testcases
Mutationstestning indebærer sin egen separate testdokumentation, herunder oplysninger om den muterede kode, og hvordan testerne forventes at løse problemet.
God registrering sikrer, at alle testene forløber som planlagt, og kan hjælpe teamet med at opretholde sit engagement i høje teststandarder.
4. Opsætning af testmiljø
Testerne sørger for, at programmet er klar til at blive ændret – og at de har en procedure til at løse disse problemer, hvis andre teammedlemmer ikke kan opdage dem.
Som en del af dette etablerer mutationstesterne en testserver og bruger denne som lærred for deres mutationer.
5. Udførelse af test
Når testerne er færdige med deres forberedelser, ændrer de koden i flere komponenter af applikationen; de venter derefter på, at andre testere opdager og retter problemerne.
Både mutationstesterne og app-testerne skal dokumentere dette grundigt for at sikre, at deres registreringer er robuste.
6. Lukning af testcyklus
Når testen er afsluttet, dobbelttjekker mutationstesterne, at alle de ændringer, de har foretaget, er rettet enten af app-testerne eller af dem selv.
Derefter lukker de testcyklussen og analyserer resultaterne, idet de diskuterer, hvordan testerne reagerede på de forskellige fejl og deres evne til at rette dem.
7. Gentagelse af test
Når testcyklussen er lukket, kan det være nødvendigt at genaktivere den efter fremtidige softwareopdateringer.
Enhver ændring af en applikation ændrer dens funktionalitet på en eller anden måde, hvilket resulterer i nye muligheder, som teamet skal tage højde for for at sikre, at deres testproces er omhyggelig nok.
Fordele ved mutationsundersøgelser
Der er mange fordele ved at udføre mutationstest, bl.a.:
1. Validerer testprocessen
Den største fordel ved mutationstestning er dens evne til at vise, hvordan virksomhedens testere griber software an – og deres evne til at genkende kodningsproblemer. Dette sikrer også, at teamets testcases er omfattende nok og dækker alle nødvendige tests.
Ved mutationstest undersøges en organisations samlede testprocedure for at sikre, at den fungerer som forventet.
2. Sikrer en stærk automatisering
Mutationstest hjælper et team med at kontrollere, om deres tredjepartsplatform til automatisering af test er i stand til at identificere fejl i koden og løse dem på den korrekte måde.
Hvis denne software ikke kan registrere disse selv efter den nødvendige kalibrering, kan det være værd at udskifte platformen til en platform, der nemt kan klare disse tests.
3. God dækning
Enhver softwaretestproces skal kunne dække hele applikationen bredt for at sikre, at alle aspekter får den nødvendige opmærksomhed.
Mutationstestere kan ændre enhver del af et programs kode; en god implementering gør det muligt for disse tests at omfatte alle vigtige funktioner. Dette lærer testerne at søge efter problemer i hele applikationen.
4. Undersøger kildekoden
Da mutationstestning indebærer, at man arbejder med koden og foretager direkte ændringer, hvor det er relevant, kan denne metode også fremhæve uoptimeret scripting i applikationen.
Softwaretestere kan kun godkende programmet og udføre deres normale testrunde, hvis softwarens kode er tilstrækkelig; disse kontroller giver testerne mulighed for at fremhæve potentielle fremtidige problemer.
5. Fører til bedre software
Mutationsafprøvning hjælper med at sikre, at applikationens afprøvningsprocesser passer til programmets krav.
Hvis en mutationsanalyse afslører, at kvalitetssikringsteamet ikke følger de rigtige procedurer, eller at testcases er utilstrækkelige, kan testerne arbejde på at forbedre dette. Uden denne due diligence kan organisationen frigive et defekt produkt uden at være klar over det.
6. Effektivt for forskellige sprog
Uanset hvilket sprog et testteam bruger til deres applikation, er der software til rådighed, som kan tilbyde mutationsanalyser af høj kvalitet.
Dette omfatter en række livskvalitetsfunktioner, der er specifikke for sproget, og som strømliner kontrollen for at opnå større pålidelighed. En skræddersyet tilgang til forskellige sprog forbedrer kvaliteten af hver enkelt test.
7. Meget tilgængelige værktøjer
Mange af de bedste mutationsplatforme er helt open source – hvilket betyder, at de tilbyder mere tilpasning og et omfattende udvalg af funktioner gratis eller til drastisk lavere omkostninger.
Med færre barrierer sammenlignet med mange andre former for testning er kodemutation en nyttig og praktisk måde for virksomheder at vurdere eller endda forbedre deres kvalitetssikringstilgang på.
Udfordringer ved mutationsundersøgelser
Denne proces er også forbundet med mange udfordringer, f.eks:
1. Kræver kendskab til programmering
For at testerne kan udføre disse kontroller, skal de have en omfattende forståelse af programmet og koden, hvilket gør det svært for mindre erfarne testere at bidrage.
En virksomhed kan kun teste software på måder, der passer til testernes eksisterende færdigheder, især deres evne til at redigere et program og skabe en fejl, der kan rettes.
2. Ikke egnet til black-box-testning
Black-box-testning indebærer hovedsagelig at se på en applikations front-end uden at inspicere dens indre funktioner og kode – dette er i praksis uforeneligt med mutationstestning.
Derfor er disse kontroller kun nyttige for nogle tests i forhold til andre metoder, hvoraf mange kan give en langt større dækning af hele testfasen.
3. Udarbejdelse af mutationstest er tidskrævende
Kodemutation kan være en kedelig proces, fordi teamet skal finde de enkelte komponenter, der er værd at mutere. Beslutningen om, hvilke mutationer der skal gennemføres, kan i sig selv tage lang tid; dette kan være problematisk, når andre testtyper faktisk venter på, at disse kontroller fuldt ud skal validere virksomhedens testtilgang.
4. Kan kræve mange kodemutationer
På samme måde er det naturligt, at komplekse projekter kræver et større antal mutanter for at sikre en omfattende testmetode. Dette forlænger mutationsprocessen og kan medføre mange manuelle ændringer i app-koden.
Uden testautomatiseringssoftware af høj kvalitet med mulighed for programmutation kan det være svært for testerne at gennemføre dette med succes.
5. Testerne bemærker måske ikke fejl
Den største bekymring, som mutationstestere og projektledere ofte har, når de implementerer disse kontroller, er muligheden for, at softwaretestere (manuelle eller automatiserede) simpelthen ikke bemærker problemerne.
Dette kan kræve en fuldstændig revision af virksomhedens testprocedurer – selv om dette stadig kan give testerne vigtige oplysninger om deres kvalitetssikringsstandarder.
6. Kan være hukommelseskrævende
Mutationstestning kræver generelt en stor mængde processorkraft, men det kan afhænge af den applikation, som testerne bruger.
Hvis organisationen har et begrænset antal maskiner, eller hvis disse enheder har lave specifikationer, kan de have svært ved at køre for mange samtidige mutationer. Dette påvirker, hvor mange kontroller de kan udføre, inden testfasen afsluttes.
7. Rapporterne kan være meget informationstætte
Selv om dette hovedsageligt afhænger af grænsefladen i et teams mutationstestværktøj, kan de rapporter, de genererer, være vanskelige at analysere.
Det betyder, at det tager tid at sortere dem manuelt og finde de rigtige testresultater; nogle programmer giver brugerne mulighed for at tilpasse selve rapporteringsprocessen; dette varierer fra program til program.
Karakteristika ved mutationstest
De vigtigste kendetegn ved effektive mutationstest er:
1. Omfattende
Disse kontroller dækker alle vigtige aspekter af softwaren; virksomheder med tilstrækkelige ressourcer kan endda designe en mutationstest for hver almindelig testcase.
Det nøjagtige antal afhænger af organisationens muligheder og præferencer, men effektive mutationstests dækker en bred vifte af kodede funktioner.
2. Strategisk
Programmutationer bør ligeledes følge en klar og velplanlagt struktur, der fremmer organisationens overordnede testmål.
F.eks. kan de fejl, de producerer, tilnærme sig realistiske testfejl, hvilket gør det muligt for testerne at forudse disse problemer, hvis de naturligt opstår, hvilket forbedrer virksomhedens testproces betydeligt.
3. Konstruktivt
Formålet med mutationstestning er at identificere mangler i testningen – at vise, hvordan teamet kan forbedre deres kontroller og rette mindre fejl, efterhånden som de opstår.
Mutationstestere skal prioritere “ugyldige” mutanter, som påvirker softwarens funktionalitet, hvilket giver mulighed for tydeligere testforbedringer på tværs af projektet.
4. Forebyggende
Disse kontroller er til for at validere teamets overordnede strategi; det betyder, at mutationstestning fungerer bedre i de tidlige faser af udviklingen.
Hvis testerne opdager væsentlige mangler i deres kvalitetssikringstilgang, giver det dem den nødvendige tid til at ændre deres testcases, så de er tilstrækkelige.
5. Konsekvent
Mutationstest på tværs af forskellige iterationer af et program bør give ensartede resultater, samtidig med at der tilføjes flere kontroller for at imødekomme softwareændringer.
De efterfølgende kontroller skal være lige så detaljerede for at bevare deres effektivitet – uden denne præcision kan mutationstestene blive mindre nøjagtige.
6. Subtilt
Mutationstests har til formål at undersøge kvalitetssikringsteamets evne til at identificere kodefejl gennem deres tests og tredjepartsplatforme.
Det betyder, at testene ikke skal være umiddelbart synlige for alle, der inspicerer softwaren; målet er at undersøge, hvordan testere reagerer på mindre kodeproblemer.
7. Samarbejde
Som med enhver anden softwaretest er kodemutation en proces, der almindeligvis kræver teamwork og kommunikation for at sikre, at den lykkes. Ved at opretholde en samarbejdsatmosfære kan man undgå informationssiloer, som kan resultere i misforståelser – det sikrer også, at alle testere forbliver fokuseret på de opgaver, de skal løse.
Typer af mutationstest
De tre hovedtyper af mutationstest er:
1. Værdimutation
Værdimutationer ændrer direkte værdierne i koden og ændrer et tal eller et bogstav til et andet på en måde, der påvirker programmets funktionalitet.
Testeren kan f.eks. ændre programmets nøjagtige parametre, f.eks. de tal, som det reagerer på. Mutationstestere kan specifikt sigte mod en softwares konstante værdier, da disse altid forbliver de samme under normal drift.
2. Beslutning Mutation
Beslutningsmutationer ændrer aritmetiske og logiske operatorer og ændrer effektivt, hvordan programmet reagerer på specifikke situationer.
Hvis man f.eks. skifter en større end-operator (>) ud med en mindre end-operator (<), påvirker det naturligvis programmets output. Testerne kan også bytte “eller” ud med “og” eller omvendt, hvilket grundlæggende ændrer denne software, og hvordan den fortolker de oplysninger, som andre testere og mulige brugere giver, grundlæggende.
3. Erklæring Mutation
Statement-mutationer ændrer kodens faktiske statements og ændrer de regler, som programmet bruger til at træffe sine beslutninger. Testerne kan ændre indholdet af disse linjer, duplikere dem eller endda slette dem for at kontrollere, hvordan det muterede program påvirker softwarens funktionalitet.
Disse mutationer ændrer et programs byggesten og kan potentielt fjerne hele funktioner eller på anden måde forhindre dem i at fungere.
Opklaring af en vis forvirring
– Mutationstest vs. regressionstest
Mutations- og regressionstest er begge nyttige metoder til softwaretestning – hvis du forstår hver af disse teknikker, kan du forbedre virksomhedens samlede kvalitetssikring.
1. Hvad er regressionstest?
Ved regressionstest undersøger testere software mellem forskellige iterationer for at sikre, at den stadig fungerer på trods af ændringer i koden.
Selv mindre ændringer kan resultere i alvorlige problemer uden disse kontroller, hvilket kan få tidligere fejl til at dukke op igen. Dette kræver generelt automatisering på grund af den komplekse karakter af at genteste hver enkelt komponent; mange virksomheder giver af denne grund afkald på regressionstest.
Testerne kan udføre disse kontroller på individuelle enheder, enkelte komponenter eller hele produktet – de nøjagtige test, der kræves, afhænger hovedsageligt af projektet og dets omfang.
2. Hvad er forskellen mellem mutations- og regressionstest?
Regressionstestning fokuserer primært på at kontrollere programmet og dets funktionalitet, mens kodemutation i stedet ser på, hvordan testerne reagerer på problemer.
Førstnævnte finder også i vid udstrækning sted efter flere iterationer af et program, mens mutationskontrol kan finde sted på et hvilket som helst tidspunkt i udviklingen – dog normalt i den tidlige del af testfasen.
Både regressions- og mutationstest kan omhandle individuelle kodningsenheder og hvordan mindre ændringer kan resultere i betydelige problemer, som testerne skal arbejde på at rette op på.
3. Konklusion: Mutationsafprøvning vs. automatiseret afprøvning
Automatisering er ofte en vigtig del af mutationstestning på grund af det store omfang af kontroller og enheder – det gør det til tider afgørende for en vellykket og omfattende testproces.
Virksomheder bruger ofte kodemutationer til at undersøge deres tredjeparts automatiseringsplatform og hvor godt den identificerer problematisk scripting.
Ved at kombinere et grundigt katalog over mutationskontroller med automatiseret software kan firmaets dækning øges betydeligt og sikre stærkere resultater.
Selv om der er tale om to forskellige testmetoder, behøver de ikke at være i modstrid med hinanden. Integrering af automatisering af robotprocesser kan f.eks. styrke en virksomheds strategi for mutationstestning.
Hvad skal du bruge for at begynde at lave mutationstest inden for softwareudvikling?
De sædvanlige krav til omfattende mutationstest omfatter:
1. En klar teststrategi
Testteamet skal fastlægge en strategi for mutationstestning, herunder hvilke komponenter og enheder der er vigtigst at undersøge.
Visse aspekter af koden kan f.eks. være mere afgørende for en applikations succes og funktionalitet; testerne skal sikre, at der er nok mutationer til at tage højde for dette.
Virksomhedens tidsplan for mutationstestning er også en vigtig faktor, da dette sikrer, at testerne har tid nok til at undersøge koden.
2. Intet omfangsforskydning
Selv med en grundig strategi, der beskriver virksomhedens tilgang til mutationstestning, er det muligt, at der er et betydeligt større antal test end nødvendigt.
Effektivitet er altafgørende i hele denne procedure, især fordi andre testfaser kan vente på, at holdet finder og dræber mutationerne. Testerne skal klart definere deres omfang, før de begynder at ændre koden; dette sikrer, at alt kan håndteres inden for en praktisk tidsramme.
3. Streng dokumentation
Enhver testproces har fordel af fuldstændig dokumentation – ofte i form af testcases, der beskriver de enkelte kontroller og eventuelle relevante mutanter.
Dette illustrerer teamets aktuelle fremskridt i alle testene, hvilket er særligt nyttigt for ledere og chefer. Ved at dokumentere hver enkelt kodemutation kan testerne også holde klare optegnelser over de ændringer, de foretager.
Hvis kvalitetssikringsteamet har svært ved at finde disse mutationer under testningen, fungerer disse dokumenter effektivt som en svarnøgle.
4. Dygtige testere
De testere, der ændrer koden, skal have en stærk forståelse af softwaren – herunder de mange måder, de kan ændre eller endda ødelægge den på.
Mutationstestere ved nogenlunde, hvordan deres ændringer vil påvirke applikationen, og hvordan andre medlemmer af kvalitetssikringsteamet kan identificere den muterede kode.
Dette kræver generelt et godt kendskab til programmering. For at mutationsanalysen kan være effektiv, skal testerne i softwaren også have veludviklede færdigheder og erfaring med testning.
5. Automationssoftware
Automatiseringssoftware fra en tredjepart kan være en nødvendighed før mutationstestning på grund af det antal kontroller, som denne proces ofte kræver. Dette gælder især for komplicerede applikationer med mere kode og flere funktioner, som kvalitetssikringsteamet skal undersøge.
Virksomhederne kan indføre disse kontroller specifikt for at teste, hvordan automatiseringssoftware reagerer på kodningsfejl. Dette kan være en central del af virksomhedens forsøgsproces for at afgøre, hvilke programmer der er de mest nyttige.
Processen for mutationstestning
De sædvanlige trin, som testere normalt følger, når de udfører mutationsanalyser, er:
1. Forbered prøverne
Forberedelse er det første skridt i enhver testproces. Dette omfatter forhandling af de nøjagtige kontroller, der skal gennemføres, og indhentning af den nødvendige godkendelse – f.eks. fra virksomhedens ledere og interessenter.
Testerne skal udvikle disse kontroller på en måde, der passer til projektets tidsplan, samtidig med at de dækker alle vigtige komponenter. Holdets planlægning kan være afgørende for effektiviteten af deres kodemutationer.
2. Introduktion af mutanter og fejl
Når forberedelserne er færdige, begynder testteamet at ændre koden og mutere den i overensstemmelse med deres plan for at indføre specifikke fejl. Disse fejl bør være relativt små, da dette giver testerne mulighed for at måle resten af teamets evne til at identificere kodningsproblemer.
Mindre fejl kan også hjælpe organisationen med at inspicere følsomheden af dens automatiseringssoftware fra tredjepart.
3. Anvend testcases
Testcases skal tage højde for alle mulige fejlpunkter i et program – dette kan kræve en omskrivning, hvis det muterede program kan fungere uden fejl.
Et programs testcases repræsenterer hele bredden af de kontroller, som testerne udfører; hver enkelt testcase skal hjælpe testerne med at afdække skjulte mutationer og være en integreret del af programmets anvendelighed.
4. Sammenlign resultaterne
Efter at have tilføjet mutationsfejl til programmet og anvendt teamets testcases skal teamet sammenligne resultaterne fra både det oprindelige og det muterede program.
Håbet er, at der for hver gang den oprindelige kontrol er lykkedes, vil der også være en fejl i den muterede ansøgning. Dette viser både testernes evner og de værktøjer, de bruger.
5. Handle på grundlag af forskellige output
Hvis der er forskellige output mellem det originale og det muterede program, som testerne forventer, betyder det, at testcasen kan dræbe mutanten ved at påvise dens tilstedeværelse.
Testerne kan derefter gå videre med tillid til deres metodologi og deres evne til at identificere kodningsproblemer. Det er ikke nødvendigt at ændre testcases for disse særlige test.
6. Skift om nødvendigt sagerne
Nogle kodemutationer kan resultere i identiske konklusioner på tværs af de forskellige programmer, hvilket tyder på, at testcases ikke er i stand til at fremhæve alle mulige fejl i programmet.
I disse tilfælde forbliver mutanten “i live” og kan fortsætte med at påvirke softwaren på måder, som testerne ikke har nogen rammer til at håndtere – dette fører til oprettelse af bedre testcases.
Sådan oprettes mutantprogrammer
Mutante programmer er reelt identiske med de oprindelige programmer, bortset fra en mindre ændring, som kan påvirke et programs funktionalitet på små, men mærkbare måder.
Omfattende og detaljerede testcases hjælper en tester eller softwaresuite med at identificere disse ændringer og de deraf følgende fejl. Hver sag, som virksomheden kontrollerer, kræver både et originalt og et muteret program, som viser virkningerne af hver enkelt ændring isoleret set.
Programmerne gengiver typisk realistiske fejl, f.eks. kodningsfejl. Det er også vigtigt for testere at undgå “dødfødte” mutanter, som forhindrer programmet i at køre – det er for indlysende for testere.
Hvad skal man ændre i et mutantprogram?
Som med mange andre variabler til softwaretestning afhænger de nøjagtige ændringer, som testerne foretager, af programmet og dets kode.
Der er tre kategorier, som omfatter de fleste mutationstest: operander, udtryk og udsagn. Ændring af en af disse kan skabe et effektivt mutantprogram – og vise, hvordan de forskellige værdier eller regler påvirker selve den logik, som et program bruger.
Disse kategorier relaterer sig til de tre hovedtyper af mutationer, som testere undersøger; det drejer sig om henholdsvis beslutnings-, værdi- og statement-mutationer. Ændringerne skal være mindre og må ikke helt forhindre udførelsen af en test.
Bedste praksis for mutationsundersøgelser
Når man udfører mutationstest i forbindelse med softwaretestning, er der visse metoder, der er værd at følge, som sikrer gode resultater, f.eks:
1. Maksimer mutationsscoren
Et programs mutationsscore er den procentdel af mutanterne, som et team eller program kan identificere eller “dræbe” med succes.
Hvis en runde af mutationstestning f.eks. har 40 mutanter, og testerne finder 36, er mutationsscoren 90 % – teamets mål er altid at sikre en score på 100 %.
2. Vælg mutanter tilfældigt
Selv om det kan hjælpe med at prioritere visse komponenter og teste dem mere grundigt, er det også nyttigt for testere at vælge tilfældigt, hvilke mutanter der skal tilføjes – især med en stram deadline.
Så længe disse kontroller repræsenterer alle væsentlige typer mutationer, kan kvalitetssikringsteamet validere deres overordnede softwareteststrategi.
3. Hold ændringerne små
Kodemutationerne bør repræsentere mindre afvigelser fra det oprindelige program, da dette illustrerer, hvor sandsynligt det er, at en tester kan identificere visse fejl; mindre kodningsproblemer viser også, hvor følsom deres software er.
Det er vigtigt, at mutationstestere finder en balance, der gør det muligt for disse mindre ændringer stadig at producere mærkbare fejl.
4. En mutation pr. program
Ved mutationstestning undersøges de enkelte testcases isoleret for at undersøge, hvor omfattende de er. For at hjælpe med dette bør alle muterede programmer kun have én ændring i forhold til det oprindelige program.
Programmer med flere mutationer kan muligvis ikke effektivt parres med testcases; mutationerne kan være i konflikt med hinanden.
5. Overvej omhyggeligt automatiseringssoftware
Virksomheder bruger ofte kodemutation til at validere teamets brug af automatiseringssoftware og sikre, at den er i stand til at identificere fejl lige så effektivt som en menneskelig tester.
Det betyder, at det kan være vigtigt at vælge den rigtige automatiseringsplatform og muligheden for at integrere automatisering af robotprocesser.
6. Brug testdreven udvikling
Testdreven udvikling (TDD) henviser til en specifik teknik, der tager hensyn til testkrav i alle udviklingsfaser.
Dette hjælper med at sikre, at testcases er fuldt kompatible med softwaren, så den nemt kan bestå mutationstests og skabe et bedre program, der er synkroniseret med kvalitetssikringsprocesser.
Typer af output fra en mutationstest
Der er flere output, som mutationstest genererer, herunder:
1. Mutant-program
De muterede programmer er et naturligt resultat af disse kontroller; testerne opretter dem for at afspejle deres aktuelle testcases og de problemer, de hjælper med at opdage. Programmerne afviger normalt kun på én mindre, men væsentlig måde fra deres oprindelige modstykke for at sikre større pålidelighed.
2. Levende eller død mutant
Efter testene er en mutation enten “dræbt” eller forbliver “levende” – dette henviser simpelthen til, om testeren (eller deres software) identificerer et kodningsproblem eller ej.
Hvis mutanten forbliver i live, kan det være nødvendigt at foretage alvorlige ændringer i testcases.
3. Mutationstest case
Kvalitetssikringsteamet bruger separate mutationsspecifikke testcases, der logger oplysninger om deres mutantprogrammer.
Dette er med til at sikre, at teamet har omfattende optegnelser for hver kontrol; disse dokumenter indeholder oplysninger om ændringerne og deres indvirkning på programmet.
4. Mutationsresultat
Slutmålet for enhver mutationstest er at opnå en mutationsscore på 100 %, idet virksomhedens testprocedurer skal lykkes med at finde og dræbe alle mutanter. Alt andet tyder på, at deres testcases og generelle processer skal forbedres for at identificere problematisk kode.
Eksempler på mutationstestning
Her er tre eksempler på mutationstest:
1. Eksempel på værdimutation
Værdimutationer indebærer ændring af en konstant eller parameter, som potentielt kan ændre programmets grænser. F.eks. kan softwaren i en automatisk kasseapparat bruge en fødevares vægt til at bestemme prisen.
Testerne kan mutere koden bag dette program for at ændre vægtparametrene og gøre maden meget dyrere pr. gram eller pund. Testeren eller testplatformen skal være i stand til at identificere de forskellige værdiers indvirkning på programmet.
Da denne fejl ændrer en af softwarens vigtigste funktioner, skal testcases bemærke denne fejl og advare teamet.
2. Eksempel på en beslutningsmutation
Beslutningsmutationer indebærer ændring af en aritmetisk eller logisk operatør, omvendt eller på anden måde ændring af, hvordan programmet reagerer på brugerinput. Hvis vi vender tilbage til eksemplet med en selvbetjeningskasse, kan disse maskiner markere en vare med en uventet høj vægt, muligvis på grund af en brugerfejl.
Maskinens kode kunne gøre dette ved hjælp af en “if (a>b)”-beslutning – hvor “b” afspejler den forventede vægt og “a” svarer til den faktiske vægt. Holdet kan ændre dette til “if (a≤b)”, hvilket ændrer kassen, så den markerer varen selv ved den forventede vægt.
3. Eksempel på en erklæring om mutation
Ændringer af erklæringer indebærer ændring af en regel eller et output – dette kan endda omfatte sletning af erklæringer fra programmet. Disse mutationer kan være mere mærkbare end andre, afhængigt af hyppigheden af den specifikke erklæring; det er vigtigt, at testerne vælger erklæringen med omtanke.
F.eks. kan en selvbetjeningsautomat vise en advarsel, hvis en bruger forsøger at købe en vare med aldersbegrænsning. Uden den tilsvarende erklæring kan maskinen gå ned eller tillade en kunde at købe en vare.
Ved at ændre erklæringen og fremhæve den for teamet kan testerne kontrollere, at deres fremgangsmåde tager højde for disse problemer.
Typer af fejl og fejl, der opdages ved hjælp af mutationstest
Mutationstests afdækker primært problemer i selve testprocessen. Med dette i tankerne er her en række problemer, som disse kontroller kan hjælpe med at identificere:
1. Uklare testcases
Hvis mutationsanalysen afslører en lav mutationsscore (eller endda en score under 100 %), tyder det på, at teamets testcases ikke kan tage højde for alle mulige fejl, der kan påvirke en applikation.
De er måske ikke specifikke eller brede nok til at opfylde teamets krav. Disse dokumenter skal omfatte alle de muligheder, som teamet kan støde på under test af softwaren for at sikre pålidelighed.
2. Utrænet testteam
Mutationstest kan også illustrere holdets evner, herunder hvor godt de personligt kan identificere mutationer og andre fejl. Hvis de ikke kan finde mutanterne i alle programmerne på trods af klare og detaljerede testcases, skyldes det muligvis, at testerne ikke har anvendt disse cases korrekt.
Muterede programmer kan vise problemer under hele testprocessen – dette kan også omfatte ufaglærte eller uuddannede testere.
3. Utilstrækkelig test-software
Hvis en virksomhed bruger disse kontroller til at inspicere sin egen testplatform, kan den finde ud af, at softwaren ikke præcist kan identificere eller dræbe mutantkode.
Virksomheden kan reagere ved at undersøge andre valgmuligheder, indtil den finder en, der er forenelig med dens testcases. Hvis automatiseringssoftwaren ikke kan finde problematisk kode, vil den sandsynligvis have svært ved at identificere andre problemer, der påvirker softwaren.
4. Ikke-optimeret kode
Mutationstest kan afsløre problemer, der allerede findes i softwaren. Testerne kan f.eks. forsøge at ændre koden, men selv opdage kritiske fejl.
Dette er endnu et vigtigt perspektiv på programmet, som viser, at kodemutation giver fordele, der rækker ud over testprocessen. Jo flere testere undersøger denne kode i enhver form, jo flere problemer kan teamet afdække og rette i løbet af testfasen.
Fælles mutationstestmetrikker
De vigtigste målinger, som mutationstest anvender, omfatter:
1. Dræbte mutanter
Dette refererer til antallet af mutanter, som testerne eller softwaren kunne identificere, og som markerer deres eksistens for at sikre, at personalet kan finde mindre fejl som disse.
Antallet af mutanter, som testerne dræber, afhænger af styrken af deres testcases.
2. Levende mutanter
Levende mutanter er dem, som testeren eller softwaren ikke kan identificere – og som viser eventuelle huller i teamets kvalitetssikringsstrategi. Hvis dette sker, bør testerne omkalibrere deres proces og testcases for at tage højde for disse mutanter og dræbe dem i fremtidige kontroller.
3. Gyldige mutanter
Denne måleenhed bestemmer mængden af mutationer, som programmet var i stand til at inkludere uden at en køretidsfejl annullerede testen og dens effektivitet.
Gyldige mutanter er dem, som testeren og automatiseringssoftwaren kan undersøge; dette skyldes, at mutationerne er relativt små.
4. Ugyldige mutanter
Betydelige mutationer kan påvirke programmet så meget, at det er upraktisk eller endog umuligt at teste – derfor er det nyttigt at spore, hvor mange “ugyldige” mutanter der er i det muterede program.
Ved at identificere disse kan testerne redigere eller endda fjerne dem, så det sikres, at kontrollen kun omfatter gyldige mutationer.
5. Samlet antal mutanter
Antallet af mutationer uanset deres gyldighed er et andet mål, som testerne holder øje med; dette giver dem mulighed for at overvåge mutanterne og registrere deres status.
Da hver mutation normalt indebærer en separat test, tjener det samlede antal også som en optælling af antallet af samlede kodemutationer.
6. Mutationsresultat
Det mest nyttige mål for mutationsanalyse er normalt mutationsscoren, som reelt er procentdelen af gyldige mutanter, som testeren eller automatiseringspakken kunne registrere.
Alt mindre end 100 % detektion kan være et tegn på ukorrekte testprocedurer.
7 fejl og faldgruber ved implementering af mutanttests
Mutationstestning er en kompleks proces, som virksomheder skal implementere klogt for at undgå alvorlige problemer eller fejltagelser. Her er syv faldgruber, som testere bør forsøge at undgå, når de udfører mutationstest:
1. Forkert skalering af mutationer
Skalaen er en vigtig faktor i forbindelse med mutationsanalysen, da denne proces skal sikre, at testerne identificerer mindre fejl i et program. Hvis mutationen er for åbenlys for testerne, er dette måske ikke en effektiv måde at kontrollere deres evne til at opdage eller imødegå softwareproblemer på.
2. Ugyldige eller levende mutationer
Selv i den rigtige skala er mange mutationer kun begrænset effektive – f.eks. hvis de ikke fører til en fejl, eller hvis de resulterer i et problem, der forhindrer programmet i at fungere.
Testerne skal være opmærksomme på, hvordan enhver ændring i kodningen kan påvirke hele softwaren.
3. Ukompatible testcases
Testcases og mutationer skal passe perfekt sammen for at sikre konsekvent og harmonisk testning. Når kvalitetssikringsteamet beslutter, hvilke mutationer der skal tilføjes, eller endda når de første testcases udformes, kan de arbejde for at sikre, at disse mutationer passer sammen og fører til mere flydende testning generelt.
4. Frister og tidsplaner
Testfaserne varierer i længde, men bør altid overholde virksomhedens interne tidsfrister. Virksomheder, der ikke planlægger deres mutationstest korrekt, kan være ude af stand til at afslutte processen i tide.
Før et projekt når testfasen, skal teamet sikre, at testplanen er tilstrækkeligt omfattende.
5. Utilstrækkelig testdækning
Virksomhederne kan vælge at implementere deres kodeksændringer tilfældigt – men det er stadig vigtigt, at de dækker en bred vifte af emner.
For at sikre, at både testerne og softwaren kan opdage alle typer mutanter, bør kontrollen mindst omfatte flere værdi-, beslutnings- og statement-mutationer.
6. Brug af mutanter til at teste softwaren
Selv om mutationstest giver et nyt perspektiv på en applikation, må teams kun bruge denne metode til at kontrollere deres egen testproces. Virksomheden skal forstå de nøjagtige muligheder og begrænsninger ved mutationstest; denne teknik kan kun fungere sammen med andre softwarekontroller.
7. For mange mutanter
Det er vigtigt, at virksomhederne sikrer en bred testdækning, men de kan implementere for mange mutanter i processen. Hvert mutationsprogram kræver en betydelig mængde computerkraft, hvilket begrænser, hvor mange en organisation kan gennemføre samtidigt.
Hvis du kører for mange mutationer, kan det også gøre det sværere at overholde testfristerne.
Tjekliste, tips og tricks til mutationstestning
Der er en række yderligere tips, som kan hjælpe ethvert team med at forbedre succesen af deres mutationstestproces, f.eks:
1. Kontroller kompatibilitet med programmeringssprog
Både gratis og betalte værktøjer til mutationstestning er typisk specialiseret i ét kodningssprog – det er derfor vigtigt, at testerne vælger et værktøj, der er kompatibelt med applikationen og platformen til softwaretestning.
Testteamet bør undersøge mange muligheder for at sikre, at de bruger et program, der passer til både deres budget og deres foretrukne programmeringssprog.
2. Fordel testene fornuftigt
Forskellige medlemmer af testteamet vil sandsynligvis se på forskellige aspekter af applikationen, hvilket normalt hænger sammen med deres specifikke styrker, svagheder og generelle erfaring.
Når teamet tildeler mutationstests til hver tester, bør de huske dette for at få en idé om deres færdigheder; det viser, hvor godt yderligere testning sandsynligvis vil gå.
3. Vælg fejl omhyggeligt
Hvis en nylig iteration af softwaren havde en fejl, der involverede en værdi eller en erklæring, kan det være nyttigt at gentage dette og undersøge, hvordan teamet eller programmet reagerer.
Dette er med til at sikre applikationens levetid og illustrerer teamets evne til at opdage tidligere fejl, hvis de gentager sig – dette er en vigtig del af regressionstest.
4. Maksimering af regnekraft
Da mutationskontroller kan kræve meget computerkraft at køre, er det nyttigt at få mest muligt ud af virksomhedens hardware.
Hvis visse maskiner f.eks. har stærkere specifikationer, kan det være nyttigt at køre mutanterne på disse enheder. Dette gør det muligt for virksomheden at undgå betydelige forsinkelser, som langsommere maskiner kan medføre.
5. Afvis ikke levende mutationer
Selv med en stram tidsplan bør testerne arbejde på at ændre og udvide deres testcases for at bekæmpe eventuelle mutanter, der overlever processen.
Selv om disse fejl måske ikke synes væsentlige, hvis softwaren eller testeren ikke opdager dem, er de stadig et tegn på, at testcases ikke har identificeret alle kodningsproblemer.
6. Undersøgelse af ny automatiseringssoftware
Hvis teamets testcases er tilstrækkeligt detaljerede, men deres automatiserede testsuite ikke kan bruge dem til at identificere hver enkelt mutation, kan de måske have gavn af anden software.
Der findes mange gratis og betalte platforme, og virksomheder bør undersøge alle muligheder for at sikre sig, at de har den software, der passer bedst til deres testcases på lang sigt.
7. Synkroniser alle testprocesser
Samarbejde er en central del af enhver teststrategi – det er med til at sikre, at hver proces nemt kan passe sammen, som teamet ønsker det.
Testteamet kan f.eks. udvikle deres testcases med mutation i tankerne for at sikre en større grad af kompatibilitet, hvilket gør det lettere for testerne at validere deres strategi.
8. Brug enhedstest
Enhedstest giver kvalitetssikringsteamet mulighed for at inspicere isolerede kodestykker, hvilket strømliner testene betydeligt og gør det lettere for teamene at identificere problemer.
Denne kombination kan især være nyttig, hvis testerne er bekymrede for deadlines, hvilket giver dem mulighed for at forenkle deres kontroller og forbedre den samlede dækning – hvilket fører til meget stærkere softwaretests.
9. Skriv detaljerede testcases
Mutationstestcases bør indeholde tilstrækkelige oplysninger om mutanten og dens virkning på programmet samt om, hvordan testteamet eller platformen har fundet disse fejl.
Ved at give så mange detaljer som muligt kan en tester personligt validere testcasen og sikre sig, at teamet ved præcis, hvordan de skal sikre en problemfri testning.
5 bedste værktøjer til mutationstestning
Der findes en lang række værktøjer, som kan hjælpe virksomheder med deres krav til mutationstestning. Som det ofte er tilfældet med programmer til softwaretestning, varierer priserne og funktionerne fra den ene platform til den anden, hvilket gør det vigtigt, at organisationer vælger den platform, der passer bedst til deres behov.
Nogle af disse programmer kan tilbyde gratis modstykker eller være helt åbne, men det er normalt nødvendigt at betale for større bekvemmelighed.
Med dette in mente er her de fem bedste værktøjer til mutationstest.
1. Stryker
Stryker har specialiseret sig i JavaScript-mutationer og strømliner denne proces betydeligt for at garantere, at der ikke forekommer falske positive resultater, og for at reducere den samlede indsats, som testerne ellers ville skulle bruge på alle mutationskontroller.
Stryker-platformen vurderer softwaren intelligent og bruger de indsamlede oplysninger til at finde ud af, hvilke strenge eller segmenter af kode der ville have gavn af mutation. Denne applikation leveres med en klartekstrapport, der giver et resumé af mutanten, herunder om Stryker var i stand til at dræbe den.
2. PITest
PITest er et meget populært valg i hele verden på grund af dets evne til at ændre Java-byte-kode og foretage tusindvis af mutationer i sekundet. Denne applikation bruger test case coverage-data til øjeblikkeligt at lære, hvilke tests der kan dræbe en mutant.
Den kører kun de tests, som den ved er relevante, hvilket begrænser den beregningskraft, som denne procedure normalt bruger. PITest er også kompatibel med de fleste former for Surefire-plugin til enhedstest, men kan have svært ved effektivt at håndtere testordningsafhængigheder.
3. Forsikre++
Insure++ har mange testfunktioner, herunder mutationsanalyse, som gør det muligt for platformen at finde tvetydigheder i et program. Insure++ adskiller sig fra konventionel mutationstest ved at undlade at generere fejlbehæftede mutanter og i stedet skabe funktionelt tilsvarende mutationer, der matcher projektets kildekode.
Dette er for at undgå implicitte antagelser, som utilsigtet kan begrænse testprocessen og måske ikke afspejler realistiske testmiljøer. Som navnet antyder, er platformen primært kompatibel med C++-programmer, og alle funktioner er kalibreret til dette sprog.
4. Jumble
Denne applikation er specialiseret i JUnit JavaScript-rammen med omfattende visuelle indikatorer for, hvordan koden reagerer på mutationsanalyse. Jumble er en open source-platform og fungerer i byte-koden i Java-applikationer for at reducere tiden for hver testcyklus.
Lignende programmer, som udelukkende anvender et programs kildekode, kan undertiden tage længere tid at udføre disse kontroller på grund af deres genkompileringsproces.
Jumble gør også brug af heuristik til at optimere mutationstestning yderligere, hvilket gør efterfølgende testkørsler enklere.
5. MutPy
MutPy understøtter mutationstest for Python-baserede applikationer og tilbyder fuld understøttelse af mutationer af høj orden samt omfattende dækningsanalyse. Programmets brugerflade er let at bruge i outputfasen, som tydeligt viser brugeren alle væsentlige detaljer i holdets mutationstest.
MutPy tilbyder mange skræddersyede valgmuligheder for testere, så de kan kalibrere denne software specifikt til deres behov. Platformen anvender Abstract Syntax Trees, som giver en klar struktur af applikationens kildekode, hvilket giver testerne større tillid til deres mutationer.
Konklusion
Kodemutation kan anvendes i næsten alle softwaretestprocesser og giver en række klare fordele for virksomheder, der implementerer denne teknik – især tidligere i kvalitetssikringsfasen.
Ingen metode er uden udfordringer; det betyder, at det er vigtigt, at organisationer overvejer fordelene ved mutationsanalyse med omtanke og samtidig sikrer, at den passer til deres sædvanlige tidsplan for softwareudvikling.
Disse mutationer giver testteams mulighed for at undersøge deres egen tilgang og afgøre dens effektivitet med hensyn til at finde og rette op på fejl i kildekoden. Denne teknik er særlig kompatibel med automatiseringsprocedurer og giver virksomhederne mulighed for at validere den software, de har tillid til til at håndtere deres kontroller.
Mutationstestning er en omfattende måde for kvalitetssikringsteams at udvikle en bedre forståelse af deres egne processer og software på, herunder de problemer, som de ellers ikke ville opdage.
Derfor er det vigtigt, at testteams undersøger denne teknik nøje for at vurdere, om den passer til organisationens behov – herunder om det valgte mutationsværktøj er fuldt ud kompatibelt med deres programmeringssprog. ZAPTEST-softwaren til automatiseret testning har mange funktioner, der gør det muligt at bestå mutationstests, hvilket sikrer, at teams har fuld tillid til dens evner.
Både Free- og Enterprise-versionen tilbyder en testproces af høj kvalitet, der nemt kan håndtere ændringer i koden.
Ofte stillede spørgsmål og ressourcer
1. Bedste kurser om mutationstest
Online-kurser kan hjælpe førstegangs-testere med at lære det grundlæggende om kodemutation eller styrke de allerede eksisterende færdigheder hos erfarne kvalitetssikringsmedarbejdere. Generelle lektioner i softwaretestning kan også give mange fordele for testere. De bedste online-kurser for mutationstestere omfatter:
– PluralSight’s ‘Mutation Testing in Java with PITest’ ser specifikt på, hvordan man ændrer Java-kode, og hvordan denne tilgang kan gavne praktiske softwaretestprocesser.
– Udemy’s “The Complete 2023 Software Testing Bootcamp” er et særligt opdateret kursus, der illustrerer alle nøglekomponenterne i softwaretests, herunder white-box-testning.
– Alison’s ‘Software Testing – Condition Coverage and Mutation Testing Strategies’ er gratis og undersøger nøje, hvordan man på en fornuftig måde implementerer mutationstest.
– PluralSight’s ‘Unit Testing Fundamentals’ udforsker fordelene og funktionerne ved unit testing og hjælper med at sikre, at eleverne forstår den nøjagtige proces for at skrive stærke unit tests.
– Udemy’s “Introduction to Unit Testing” er et andet gratis kursus, der giver en klar opdeling af unit testing samt vigtigheden af testdrevne udviklingsstrategier.
2. Hvad er de 5 vigtigste interviewspørgsmål om mutationstest?
Der er en række spørgsmål, som firmaer kan stille kandidater under en samtale for at kontrollere deres erfaring eller forståelse af mutationstestning og de grundlæggende principper. Dette giver en virksomhed mulighed for at sikre sig, at de ansætter en kvalificeret tester, der kan håndtere forskellige mutationsrelaterede scenarier uden problemer.
De præcise spørgsmål varierer, men kan omfatte spørgsmål om deres egne holdninger eller eksempler på deres færdigheder inden for kodemutation.
De fem bedste spørgsmål til interview om mutationstest er:
– Hvilke værktøjer til mutationstest har du tidligere erfaring med, hvis nogen? Hvad var de vigtigste funktioner i denne software?
– Hvordan vil du arbejde for at sikre en sund balance mellem testhastighed og dybde, når du foretager kodemutation?
– I hvilke situationer ville mutationsanalyse være umulig? Hvordan vil du inspicere testproceduren i disse scenarier?
– Hvis det lykkes en værdimutation at overleve testprocessen, hvad vil du så gøre for at forhindre, at det sker igen?
– Hvilke oplysninger ville du medtage i en mutationstestcase for at sikre, at dine kolleger har de data, de har brug for?
3. Bedste YouTube tutorials om mutationstest
Der findes gratis vejledninger, webinarer og andre videoer på YouTube, som kan hjælpe med at forbedre testerens forståelse af mutationstestning. Nogle af de mest nyttige videoer og serier om emnet omfatter:
– Software Testing’s ‘Mutation Testing for Programs’, som giver praktiske eksempler på, hvordan kodemutation hjælper programmer, og hvordan man skriver grundige testcases.
– Devoxx’s ‘Mutation Testing: Did my test break my code?”, der ser på, hvordan mutationsanalyse forbedrer de overordnede testprocedurer for alle former for softwareprojekter.
– NDC Conferences’ “Dræb alle mutanter! Intro to Mutation Testing’, som undersøger, hvordan testsuiter kan drage fordel af kodemutation og de fejl, som den er med til at skabe.
– GOTO Conferences’ “Mutation Testing in Python”, som specifikt undersøger, hvordan Python-baserede applikationer kan anvende mutationsanalyse til at nå specifikke testmål.
– Diego Pachecos ‘Java Mutation Testing With PITest’, som på samme måde illustrerer hvordan JavaScript-software anvender kodemutation – med fokus på mutationsprogrammet PITest.
4. Hvordan vedligeholdes mutationstest?
Ved at kombinere mutationsanalyse med regressionstest og andre langsigtede strategier kan virksomheder sikre en stærk standard for kvalitetssikring, selv efter frigivelse.
Senere opdateringer kan føre til kodeændringer, som kræver yderligere kontrol. Mutationstestning viser, at automatiseringssoftware og testere er konsistente på tværs af forskellige versioner af den samme software, hvilket bekræfter deres særlige tilgang.
Nye funktioner kræver nyere testcases, især hvis disse funktioner interagerer med allerede eksisterende funktioner.
Derudover giver brugen af testdreven udvikling teammedlemmerne mulighed for at planlægge softwarens levetid og teste kompatibilitet som en del af deres egen udviklingscyklus.
