Incrementeel testen bij het testen van software is een methodologie waarmee teams individuele modules kunnen opsplitsen, afzonderlijk kunnen testen en stapsgewijs kunnen integreren. Het helpt om defecten in een vroeg stadium te vinden, vermindert de complexiteit en verhoogt de testdekking.
Dit artikel neemt een diepe duik in incrementeel testen, legt uit wat het is en verkent de verschillende soorten, processen, benaderingen, tools en meer die geassocieerd worden met deze nuttige methodologie.
Wat is incrementeel testen?
Testen is een van de belangrijkste fasen van de levenscyclus van softwareontwikkeling (SDLC). Net als bij de SDLC wordt het testen opgedeeld in verschillende logische stappen. Incrementeel testen is een van deze fasen en komt meestal voor tijdens
integratietesten
en direct na
unit testen
.
Incrementeel testen is een pragmatische aanpak voor het testen van software waarbij grote of complexe programma’s worden opgedeeld in hanteerbare, hapklare brokken. In plaats van een heel softwaresysteem in één keer te integreren en te testen, kijkt incrementeel testen naar modules en implementeert het een gefaseerd verificatieproces.
Softwaremodules zijn meestal zelfstandige eenheden van code die specifieke taken of functies uitvoeren. Hoe granulair deze modules zijn, hangt af van verschillende factoren, zoals codeerpraktijken, ontwikkelmethodologieën of zelfs de programmeertaal die u gebruikt.
Modules worden onafhankelijk getest tijdens unit testen. Vervolgens wordt tijdens integratietesten elke module stukje bij beetje geïntegreerd – of in stappen. Dit proces zorgt ervoor dat elke module goed samenwerkt. Om elke module volledig te verifiëren, moeten testers echter componenten die nog geïmplementeerd moeten worden of externe systemen simuleren. Hiervoor hebben ze de hulp nodig van stubs en drivers.
Wat zijn stubs en drivers bij incrementeel testen?
Stubs en stuurprogramma’s zijn essentiële hulpmiddelen voor het testen van software. Deze tijdelijke stukjes code worden gebruikt tijdens integratietesten omdat ze teams de mogelijkheid bieden om het gedrag en de interfaces van verschillende modules of componenten na te bootsen.
1. Stubs:
Stubs bootsen modules na die nog ontwikkeld moeten worden en zijn daarom niet beschikbaar om te testen. Hiermee kan de geteste module (MUT) een beroep doen op onvolledige modules. Het resultaat is dat de MUT geïsoleerd getest kan worden, zelfs als gerelateerde modules niet beschikbaar zijn.
2. Bestuurders:
Stuurprogramma’s simuleren daarentegen het gedrag van modules die de MUT aanroepen. Binnen de testomgeving kunnen deze stuurprogramma’s de MUT-testgegevens verzenden. Ook dit maakt het mogelijk om modules geïsoleerd te testen zonder externe afhankelijkheden.
Het gebruik van stubs of drivers vermindert de ontwikkeltijd, verbetert de kwaliteit van de code en verhoogt de productiviteit van het team. De keuze hangt echter af van welke testmethode het meest geschikt is. We zullen hier dieper op ingaan in een paragraaf hieronder die de verschillende soorten incrementele integratietesten behandelt.
Verschillende soorten incrementele
integratietesten
Incrementele testtypes kunnen grofweg worden opgedeeld in drie categorieën. Laten we ze stuk voor stuk bekijken.
1. Top-down incrementele integratie
Top-down incrementele integratie begint met het testen van de modules van de hoogste orde binnen een systeem. Van daaruit worden geleidelijk modules van een lagere orde geïntegreerd en getest.Er zijn twee hoofdscenario’s waarin top-down incrementele integratie wordt gebruikt. Dat zijn ze:
- Wanneer een systeem erg groot of erg complex is
- Als het ontwikkelteam aan veel modules tegelijk werkt.
Stappen voor top-down incrementele integraties
- Kritieke modules identificeren
- Stubs maken om modules van lagere orde na te bootsen
- Stuurprogramma’s ontwikkelen voor interactie met modules van een hogere orde om ze gegevens te sturen en de uitvoer van de module te interpreteren
- Unit testen van kritieke modules met drivers en stubs
- Modules van lagere orde integreren en stubs geleidelijk vervangen door echte implementaties
- Stuurprogramma’s herformuleren voor de nieuwe modules
- Herhaal dit totdat alle modules van een lagere orde geïntegreerd en getest zijn.
2. Bottom-up incrementele integratie
Bottom-up incrementele integraties gaan in de tegenovergestelde richting. Bij deze aanpak worden de modules van de lagere orde (of de minst kritieke modules) van het systeem getest en worden de modules van de hogere orde geleidelijk toegevoegd. Deze aanpak is geschikt voor verschillende scenario’s, zoals:
- Wanneer je te maken hebt met kleinere systemen
- Wanneer een systeem gemodulariseerd is
- Als je je zorgen maakt over de nauwkeurigheid of de volledigheid van stubs.
Stappen voor bottom-up incrementele integraties
- Modules van lagere orde identificeren
- Unit testen van lagere orde modules om hun individuele functionaliteit te verifiëren
- Stuurprogramma’s ontwikkelen om als tussenpersoon te fungeren met modules van een lagere orde
- Stubs maken om het gedrag van modules van een hogere orde te simuleren
- Integreer de volgende modules, van lagere naar hogere orde, en vervang stubs geleidelijk door echte implementaties
- Stuurprogramma’s herformuleren voor de nieuwe modules
- Herhaal dit totdat alle modules van een hogere orde geïntegreerd en getest zijn.
3. Functionele incrementele integratie
Functie incrementele integratietesten is de volgende veel voorkomende vorm van incrementeel testen bij het testen van software. Terwijl de vorige twee soorten zich richtten op modules van hogere en lagere orde, is functioneel incrementeel testen gebaseerd op de functionaliteit van een bepaalde module.
Functionele incrementele integratie wordt gebruikt in
Agile/DevOps methodologieën
en het is een uitstekende keuze voor applicaties met complexe afhankelijkheden tussen modules of componenten.
Stappen voor functionele incrementele integratie
- Individuele modules en componenten identificeren met goed gedefinieerde interfaces
- De functionaliteit van elke module verifiëren via unit testen
- De meest minimale kernmodules van het systeem integreren en ervoor zorgen dat het functioneert
- Geleidelijk losse modules toevoegen en bij elke stap de functionaliteit testen
- De code herformuleren wanneer elke module wordt toegevoegd
- Wanneer alle modules zijn toegevoegd, de functionaliteit en prestaties testen
Voor- en nadelen van een incrementele testaanpak
Je zou nu een idee moeten hebben waarom incrementeel testen een populaire aanpak is. Maar zoals alle software testmethodologieën heeft het zijn voor- en nadelen. Laten we eens een paar van deze voor- en nadelen bekijken.
Voordelen van een incrementele testaanpak
1. Flexibiliteit
Zoals alle softwareontwikkelaars en -testers maar al te goed weten, kunnen vereisten tijdens de SDLC veranderen en evolueren, soms behoorlijk ingrijpend. Incrementeel testen is dynamisch genoeg om teams in staat te stellen zich tijdens het testproces aan te passen en nieuwe plannen en richtingen op te nemen.
2. Vroegtijdige bugdetectie
Het beste moment om een bug of defect op te sporen is zo vroeg mogelijk. Wanneer ontwikkelaars hapklare modules afzonderlijk verifiëren, is het veel eenvoudiger om problemen te identificeren en op te lossen. Bovendien verkleint het de kans op grote problemen in een laat stadium van de ontwikkeling.
3. Eenvoud
Het testen van software kan een zeer complex proces zijn. Een van de meest overtuigende aspecten van incrementeel testen is de manier waarop het de teststad opdeelt in werkbare delen. In plaats van te worden geconfronteerd met een overweldigende complexiteit, kunnen testers zich richten op bepaalde modules en daar zelfs prioriteit aan geven. Dit voordeel is een uitkomst voor grote en complexe applicaties.
4. Lager risico op regressie
Regressie is een tijdrovende en complexe kwestie binnen softwareontwikkeling. Incrementeel testen kan de frequentie en risico’s veroorzaakt door regressie verminderen omdat het teams in staat stelt modules individueel te testen en problemen aan te pakken wanneer ze zich voordoen. Bij gebruik met vaste
regressietesten
kunnen teams veel tijd en hartzeer besparen.
5. Feedbackmogelijkheden
Een vaak over het hoofd gezien voordeel van incrementeel testen is dat het teams de ruimte geeft om prototypes en MVP’s samen te stellen. Van daaruit kunnen belanghebbenden en investeerders de basisfunctionaliteit van het proces beoordelen en waardevolle feedback geven. Deze situatie kan veel tijd en geld besparen en leiden tot robuustere producten.
Nadelen van een incrementele testaanpak
1. Integratiekwesties
Het apart testen van modules is wenselijk omdat het een complexe applicatie opdeelt in hanteerbare brokken. De integratie van deze modules kan echter leiden tot nieuwe en onverwachte fouten. Daarom moet een incrementele testaanpak zorgvuldig en weloverwogen worden gepland.
2. Complexiteit testsuite
Met meerdere testgevallen voor elke module en hun interactie met elkaar, kunnen testsuites complex worden om bij te houden en te beheren. Voor grote en gecompliceerde apps maakt dit grondige documentatie of testmanagementtools noodzakelijk.
3. Meer werk
Monolithisch testen is weliswaar complexer, maar vereist minder testen. Door veel modules afzonderlijk te testen, vergt incrementeel testen meer werk. De voordelen van incrementeel testen, zoals het vroeg ontdekken van bugs, betekenen echter dat extra inspanning een tijdbesparende investering is. Natuurlijk,
automatisering van softwaretests
kan deze inspanningen helpen verminderen.
4. Hogere managementeisen
Incrementeel testen vereist dat meerdere teams samenwerken. Ontwikkel-, test- en DevOps-teams moeten bijvoorbeeld samenwerken. Deze situatie creëert extra managementbehoeften en vereist goede communicatie tussen deze teams om ervoor te zorgen dat ze gefocust zijn en dezelfde doelen nastreven.
Voorbeeld van incrementeel testen
Misschien is de makkelijkste manier om een incrementele testaanpak te begrijpen, te denken aan een voorbeeld. Hier is een eenvoudige situatie om het proces te visualiseren.
1. Voorbeeld van incrementeel testen voor een app voor mobiel bankieren
Scenario: Een team bouwt een app voor mobiel bankieren. De app bestaat uit verschillende modules die het mogelijk maken:
- 2FA en biometrische gebruikersverificatie
- Verwerking van transacties
- Dashboard voor financieel gegevensbeheer
Doel: Het team wil de integratie van elke module testen en bepalen of ze goed samenwerken. Als resultaat bouwen ze drie testcases.
Testgeval 1
In de eerste testcase wil het team ervoor zorgen dat de gebruiker door het invoeren van biometrische of wachtwoordgegevens toegang krijgt tot zowel de transactieverwerking als het dashboard voor het beheer van financiële gegevens.
De app doorstaat de test als de gebruiker zijn gegevens kan invoeren en toegang krijgt tot transacties.
Testgeval 2
De volgende testcase is ontworpen om te zien hoe de app omgaat met ongeautoriseerde transacties.
De app slaagt voor de test als een poging om een ongeautoriseerde transactie uit te voeren wordt geblokkeerd en de app een foutmelding geeft.
Testgeval 3
De laatste integratietest bestaat uit het valideren of de app gelijktijdig transacties kan uitvoeren.
De app doorstaat de test als de gebruiker tegelijkertijd een transactie kan starten en toegang heeft tot zijn financiële informatie zonder inconsistenties of problemen.
Is een incrementele testaanpak de
hetzelfde als incrementeel testen?
Nee. Incrementaliteitstesten verwijzen naar een statistische marketingmethode die misschien het best bekend is als attributiemodellering. Kortom, het helpt marketingteams inzicht te krijgen in de impact van reclamecampagnes, marketingkanalen of bepaalde strategieën.
Hoewel de interesse in dit soort modellering de laatste jaren is gegroeid dankzij de “dood” van cookies en gegevens van derden, is de enige relatie met incrementeel testen een gedeeld woord.
Top 3 tools voor incrementeel testen
#1. ZAPTEST
Naast het leveren van eersteklas
RPA
mogelijkheden biedt ZAPTEST een reeks softwaretestautomatiseringstools die perfect zijn voor incrementeel testen. Enkele van de functies zijn:
Beheer van testgegevens
: Verkort de tijd en moeite die gemoeid zijn met incrementeel testen door teams in staat te stellen testgegevens te hergebruiken- Script opnemen en afspelen: Met deze no-code tool kunnen teams scripts opnemen en uitvoeren en veel tijd besparen tijdens incrementeel testen.
- Herbruikbare testmodules: ZAPTEST is zeer modulair en stelt teams in staat om testmodules te maken en hergebruiken en zo veel tijd te besparen op het testproces.
Al met al biedt ZAPTEST een krachtige en gevarieerde testautomatiseringssuite die geschikt is voor elk type test, inclusief incrementele tests.
#2. Selenium
Selenium is een open-source testautomatiseringsplatform dat is gebouwd om het testen van mobiele applicaties te vergemakkelijken. De tools ondersteunen verschillende mobiele platformen (Android, iOS, Windows) en gebruiken stubs en stuurprogramma’s om modules te simuleren.
#3. Testsigma
Testsigma is een cloudgebaseerd testautomatiseringsplatform. Het kan worden gebruikt voor het testen van web- en mobiele applicaties en is geschikt voor incrementeel testen dankzij de codeloze testcreatie en integratie met CI/CD-pijplijnen.
Laatste gedachten
Incrementeel testen bij het testen van software is een belangrijk onderdeel van integratietesten. Het stelt teams in staat om modules op te splitsen in makkelijk te testen onderdelen voordat ze ze langzaam integreren. De voordelen hiervan zijn dat elke module geverifieerd kan worden op bugs en vervolgens op hoe deze integreert met de aangesloten onderdelen.
Naast onze best-in-class
RPA
ZAPTEST biedt no-code software testautomatisering die zowel platform- als applicatieoverschrijdend is. Bovendien zit onze testsuite boordevol functies zoals CI/CD-integratie, robuuste rapportage en analyses, en eersteklas ondersteuning en klantenservice.
