Systeemtests zijn een soort softwaretests die het systeem als geheel controleren.
Hierbij worden alle afzonderlijke modules en componenten van de door u ontwikkelde software geïntegreerd, om te testen of het systeem samenwerkt zoals verwacht.
Systeemtests zijn een essentiële stap bij het testen van software, waarmee testteams de kwaliteit van de build kunnen controleren, voordat deze wordt vrijgegeven aan eindgebruikers.
In dit artikel gaan we dieper in op systeemtests: wat het is, hoe het werkt, wie systeemtests uitvoert en welke benaderingen en hulpmiddelen testteams kunnen gebruiken om systeemtests sneller en betrouwbaarder te maken.
Kortom, hier vindt u alles wat u moet weten over systeemtesten.
Wat is een systeemtest?
Systeemtests zijn een soort softwaretests die altijd op een volledig systeem worden uitgevoerd. Het controleert of het systeem voldoet aan zijn eisen, wat die ook mogen zijn.
Testers voeren systeemtests uit om zowel de functionele als de niet-functionele eisen van het systeem te evalueren nadat de afzonderlijke modules en componenten met elkaar zijn geïntegreerd.
Systeemtests zijn een categorie van Black Box tests, wat betekent dat ze alleen externe werkende functies van de software testen, in tegenstelling tot het testen van het interne ontwerp van de applicatie.
Testers hebben geen kennis nodig van de programmering en de structuur van de softwarecode om een software-build tijdens systeemtests volledig te evalueren. In plaats daarvan beoordelen testers gewoon de prestaties van de software vanuit het perspectief van een gebruiker.
1. Wanneer moeten we systeemtests uitvoeren?
Systeemtests worden uitgevoerd na integratietests en vóór acceptatietests. Het softwaretestteam voert regelmatig systeemtests uit om ervoor te zorgen dat het systeem in belangrijke fasen van de ontwikkeling naar behoren functioneert.
Enkele voorbeelden van gevallen waarin systeemtests worden uitgevoerd zijn:
Tijdens de ontwikkeling van nieuwe softwareversies.
Tijdens de lancering van de toepassing, wanneer alfa- en bètatests plaatsvinden.
Nadat de eenheids- en integratietests zijn afgerond.
● Wanneer de vereisten van de systeembouw compleet zijn.
Wanneer aan andere testvoorwaarden is voldaan.
Net als andere vormen van softwaretests is het aan te bevelen regelmatig systeemtests uit te voeren om ervoor te zorgen dat de software naar behoren functioneert.
De frequentie waarmee systeemtests kunnen worden uitgevoerd, hangt af van de middelen van uw team en de aanpak en instrumenten die u gebruikt om systeemsoftware te testen.
2. Wanneer je geen systeemtests nodig hebt
Als u nog geen voorafgaande tests hebt uitgevoerd, zoals rooktests, eenheidstests en integratietests, dan bent u nog niet klaar om te beginnen met systeemtests.
Het is altijd belangrijk om systeemtests uit te voeren nadat de integratietest is voltooid, maar als u bugs en problemen tegenkomt waardoor de systeemtest mislukt, kunt u de systeemtests stoppen en terugkeren naar de ontwikkeling en het oplossen van bugs voordat u verder gaat.
3. Wie is betrokken bij het testen van het systeem?
Systeemtests worden uitgevoerd door testers en QA-teams, en niet door ontwikkelaars. Systeemtests houden alleen rekening met de externe elementen van software, of met andere woorden, de ervaring van gebruikers die proberen toegang te krijgen tot de functies van de software.
Dit betekent dat testers die systeemtests uitvoeren geen technische kennis nodig hebben van computercodering, programmering en andere aspecten van softwareontwikkeling waarvoor de inbreng van ontwikkelaars nodig is.
De enige uitzondering hierop is in het geval van geautomatiseerde systeemtests, waarvoor enige inbreng van ontwikkelaars nodig kan zijn, afhankelijk van hoe u dit aanpakt.
Wat testen we bij systeemtests?
Systeemtests zijn een soort softwaretests waarbij zowel functionele als niet-functionele aspecten van de software worden getest.
Het kan worden gebruikt om een grote verscheidenheid aan functionaliteiten en functies te testen, waarvan er vele nader worden besproken onder soorten systeemtests.
Enkele van de softwareaspecten die door systeemtests worden geverifieerd, worden hieronder beschreven.
1. Functionaliteit
Testers gebruiken systeemtests om na te gaan of verschillende aspecten van het voltooide systeem functioneren zoals het hoort.
Voorafgaande tests kunnen worden gebruikt om de structuur en logica van de interne code en de integratie van verschillende modules met elkaar te beoordelen, maar systeemtests zijn de eerste stap die de softwarefunctionaliteit als geheel op deze manier testen.
2. Integratie
Systeemtests testen hoe verschillende softwarecomponenten samenwerken en of ze soepel met elkaar integreren.
Testers kunnen ook externe randapparatuur testen om te beoordelen hoe deze samenwerkt met de software en of deze goed functioneert.
3. Verwachte output
Testers gebruiken de software zoals een gebruiker dat zou doen tijdens systeemtests om de output van de software bij normaal gebruik te verifiëren. Zij controleren of de output voor elk functioneel en niet-functioneel kenmerk van de software is zoals verwacht.
Als de software zich niet gedraagt zoals het hoort, is de voor de hand liggende conclusie dat verdere ontwikkeling nodig is.
4. Bugs en fouten
Systeemtests worden gebruikt om de functionaliteit en betrouwbaarheid van software op meerdere platforms en besturingssystemen te beoordelen.
Systeemtesters controleren of de software vrij is van bugs, prestatieproblemen en compatibiliteitsproblemen op alle platforms waarop de software naar verwachting zal draaien.
In- en uitstapcriteria
Ingangs- en uitgangscriteria worden bij systeemtests gebruikt om vast te stellen of het systeem al dan niet gereed is voor systeemtests en of aan de eisen voor systeemtests is voldaan.
Met andere woorden, ingangs- en uitgangscriteria helpen testers te beoordelen wanneer zij moeten beginnen met systeemtests en wanneer zij deze moeten beëindigen.
Toelatingscriteria
Ingangscriteria bepalen wanneer testers moeten beginnen met het testen van het systeem.
De toetredingscriteria kunnen per project verschillen, afhankelijk van het doel van het testen en de gevolgde teststrategie.
Ingangscriteria specificeren de voorwaarden waaraan moet worden voldaan voordat het testen van het systeem begint.
1. Testfase
In de meeste gevallen is het belangrijk dat het te testen systeem al klaar is met integratietesten en voldoet aan de uitgangseisen voor integratietesten voordat de systeemtesten beginnen.
De integratietests mogen geen grote bugs of problemen met de integratie van componenten aan het licht hebben gebracht.
2. Plannen en draaiboeken
Voordat het testen van het systeem kan beginnen, moet het testplan zijn geschreven, afgetekend en goedgekeurd.
U moet ook van tevoren testgevallen hebben voorbereid en testscripts klaar hebben liggen voor uitvoering.
3. Gereedheid
Controleer of de testomgeving gereed is en of alle niet-functionele eisen van de test beschikbaar zijn.
De gereedheidscriteria kunnen per project verschillen.
Uitgangscriteria
Afsluitingscriteria bepalen de eindfase van de systeemtest en stellen de eisen vast waaraan moet worden voldaan om de systeemtest als voltooid te beschouwen.
Exitcriteria worden vaak gepresenteerd als een enkel document waarin alleen de deliverables van deze testfase worden genoemd.
1. Uitvoering
De meest fundamentele exit-criteria voor het voltooien van systeemtests is dat alle testgevallen die in de plannen voor systeemtests en de entry-criteria zijn geschetst, naar behoren zijn uitgevoerd.
2. Bugs
Alvorens de systeemtest af te sluiten, controleren of er geen kritieke of prioritaire bugs openstaan.
Bugs van gemiddelde en lage prioriteit kunnen in een open toestand worden gelaten, mits zij met instemming van de klant of eindgebruiker worden uitgevoerd.
3. Rapportage
Voordat het testen van het systeem eindigt, moet een afsluitingsverslag worden ingediend. In dit verslag worden de resultaten van de systeemtests vastgelegd en wordt aangetoond dat het testen aan de vereiste afsluitingscriteria heeft voldaan.
Levenscyclus van systeemtesten
De levenscyclus van systeemtesten beschrijft elke fase van systeemtesten, van de planningsfasen tot en met de rapportage en voltooiing.
Inzicht in elke fase van de levenscyclus van systeemtesten zal u helpen begrijpen hoe systeemtesten moeten worden uitgevoerd, en hoe het werkt.
Fase 1: Maak een testplan
De eerste fase van het testen van een systeem is het opstellen van een systeemtestplan.
Het doel van een testplan is het schetsen van de verwachtingen van de testgevallen en de teststrategie.
Het testplan definieert gewoonlijk de testdoelstellingen, de reikwijdte, de gebieden, de te leveren prestaties, de planning, de in- en uitstapcriteria, de testomgeving en de rollen en verantwoordelijkheden van de mensen die betrokken zijn bij het testen van het softwaresysteem.
Fase 2: Testgevallen maken
De volgende fase van het testen van een systeem is het maken van testgevallen.
Testgevallen definiëren de precieze functies, kenmerken en metrieken die u gaat testen tijdens het testen van het systeem. U kunt bijvoorbeeld testen hoe een bepaalde functie werkt of hoe lang een bepaalde laadtijd is.
Geef voor elk testgeval een testgeval-ID en naam op, samen met informatie over hoe dit scenario moet worden getest en wat het verwachte resultaat van het testgeval is.
U kunt hier ook de pass/fail criteria voor elk testgeval schetsen.
Fase 3: testgegevens creëren
Zodra u testgevallen hebt gemaakt, kunt u de testgegevens creëren die u nodig hebt om de tests uit te voeren.
Testgegevens beschrijven de input die het testteam nodig heeft om te testen of hun acties tot de verwachte resultaten leiden.
Fase 4: Testgevallen uitvoeren
Bij systeemtesten denken de meeste mensen aan deze fase: de uitvoering van de testgevallen of het testen zelf.
Het testteam voert elke testcase afzonderlijk uit, controleert de resultaten van elke test en registreert eventuele bugs of fouten die ze tegenkomen.
Fase 5: Rapporteren en oplossen van bugs
Na het uitvoeren van de testcases schrijven de testers een systeemtestrapport waarin alle problemen en bugs die tijdens het testen naar voren zijn gekomen gedetailleerd worden beschreven.
Sommige van de bugs die de test aan het licht brengt, kunnen klein en gemakkelijk te verhelpen zijn, terwijl andere de bouw kunnen vertragen. Los deze bugs op wanneer ze zich voordoen en herhaal de testcyclus (die ook andere soorten softwaretests omvat, zoals “smoke testing”) opnieuw totdat er geen grote bugs meer in zitten.
Opheldering van de verwarring: Systeemtesten vs. integratietesten vs. gebruikersacceptatietesten
Veel mensen verwarren systeemtests met andere soorten softwaretests, zoals integratietests en gebruikersacceptatietests.
Hoewel systeemtests, integratietests en gebruikersacceptatietests enkele kenmerken gemeen hebben, zijn het verschillende soorten tests die verschillende doelen dienen en elk type test moet onafhankelijk van de andere worden uitgevoerd.
Wat zijn integratietests?
Integratietesten zijn een soort softwaretesten waarbij softwaremodules en componenten als groep worden getest om te beoordelen hoe goed zij met elkaar integreren.
Integratie testen is het eerste type software testen dat wordt gebruikt om te testen of individuele modules samenwerken.
Integratietesten worden uitgevoerd door testers in een QA-omgeving, en zijn essentieel omdat ze gebreken blootleggen die kunnen ontstaan wanneer individueel gecodeerde componenten met elkaar samenwerken.
Wat zijn de verschillen tussen systeemtests en integratietests?
Hoewel zowel systeemtests als integratietests de software als geheel testen, zijn het verschillende soorten softwaretests die verschillend werken.
Integratie testen gebeurt eerst, en systeem testen gebeurt na de integratie testen. Andere belangrijke verschillen tussen systeemtesten en integratietesten zijn:
1. Doel:
Het doel van integratietesten is te beoordelen of individuele modules goed samenwerken wanneer ze geïntegreerd zijn. Het doel van systeemtesten is te testen hoe het systeem als geheel werkt.
2. Type:
Integratietesten testen puur de functionaliteit, en zijn geen soort acceptatietesten.
Systeemtests daarentegen testen zowel functionele als niet-functionele functies, en vallen onder de categorie acceptatietests (maar niet onder gebruikersacceptatietests).
3. Techniek:
Bij integratietests worden zowel black box als white box tests gebruikt om de gebouwde software vanuit het perspectief van zowel een gebruiker als een ontwikkelaar te beoordelen, terwijl bij systeemtests uitsluitend black box testmethoden worden gebruikt om software vanuit het perspectief van de gebruiker te testen.
4. Waarde:
Integratietests worden gebruikt om interfacefouten op te sporen, terwijl systeemtests worden gebruikt om systeemfouten op te sporen.
Wat is gebruikersacceptatie testen?
User acceptance testing, of UAT, is een soort softwaretest die wordt uitgevoerd door de eindgebruiker of de klant om na te gaan of de software aan de gewenste eisen voldoet.
Gebruikersacceptatietesten zijn de laatste vorm van testen die plaatsvinden voordat de software naar de productieomgeving gaat.
Dit gebeurt nadat functionele tests, integratietests en systeemtests al zijn afgerond.
Wat zijn de verschillen tussen systeemtests en gebruikersacceptatietests?
Gebruikersacceptatietests en integratietests valideren beide of een software-build werkt zoals het hoort, en beide soorten tests richten zich op hoe de software als geheel werkt.
Er zijn echter veel verschillen tussen systeemtests en gebruikersacceptatietests:
1. Testers:
Terwijl systeemtests worden uitgevoerd door testers (en soms ontwikkelaars), worden gebruikersacceptatietests uitgevoerd door eindgebruikers.
2. Doel:
Het doel van gebruikersacceptatietesten is te beoordelen of een softwarebouwwerk voldoet aan de eisen van de eindgebruiker, en het doel van systeemtesten is te testen of het systeem voldoet aan de eisen van de tester.
3. Methode:
Tijdens systeemtests worden de afzonderlijke eenheden van de softwarebouw geïntegreerd en als geheel getest. Bij gebruikersacceptatietesten wordt het systeem in zijn geheel getest door de eindgebruiker.
4. Stadium:
Systeemtests worden uitgevoerd zodra de integratietests zijn afgerond en voordat de gebruikersacceptatietests plaatsvinden. Gebruikersacceptatietests vinden plaats vlak voordat het product wordt vrijgegeven te early adopters.
Soorten systeemtests
Er zijn meer dan 50 verschillende soorten systeemtests die u kunt toepassen als u wilt testen hoe uw software build in zijn geheel werkt.
In de praktijk worden echter slechts enkele van deze soorten systeemtests daadwerkelijk gebruikt door de meeste testteams.
Het type systeemtest dat u gebruikt hangt af van veel verschillende factoren, waaronder uw budget, tijdsdruk, prioriteiten en middelen.
1. Functionaliteitstesten
Functionaliteitstesten zijn een soort systeemtesten die bedoeld zijn om de afzonderlijke kenmerken en functies van de software te controleren en te beoordelen of ze werken zoals het hoort.
Dit type systeemtest kan handmatig of automatisch worden uitgevoerd, en het is een van de belangrijkste typen systeemtests die testteams uitvoeren.
2. Prestatietesten
Performance testing is een type systeemtest waarbij wordt getest hoe goed de applicatie presteert bij regelmatig gebruik.
Het wordt ook wel compliance testing genoemd, en het betekent meestal het testen van de prestaties van een applicatie wanneer meerdere gebruikers tegelijk er gebruik van maken.
Bij prestatietests kijken testers naar laadtijden, bugs en andere problemen.
3. Belasting testen
Belastingtests zijn een soort systeemtests die testers uitvoeren om te beoordelen hoe goed een applicatie omgaat met zware belastingen.
Testers kunnen bijvoorbeeld testen hoe goed de applicatie werkt wanneer heel veel gebruikers tegelijkertijd dezelfde taak proberen uit te voeren, of hoe goed de applicatie meerdere taken tegelijk uitvoert.
4. Testen van de schaalbaarheid
Schaalbaarheidstesten zijn een soort softwaresysteemtesten die testen hoe goed de software schaalt om te voldoen aan de behoeften van verschillende projecten en teams.
Dit is een type niet-functionele test waarbij wordt beoordeeld hoe de software presteert voor verschillende aantallen gebruikers of bij gebruik op verschillende locaties en met verschillende middelen.
5. Bruikbaarheidstesten
Bruikbaarheidstests zijn een soort systeemtests waarbij wordt getest hoe bruikbaar de toepassing is.
Dit betekent dat testers beoordelen en evalueren hoe gemakkelijk de applicatie te navigeren en te gebruiken is, hoe intuïtief de functies zijn, en of er bugs of problemen zijn die bruikbaarheidsproblemen kunnen veroorzaken.
6. Betrouwbaarheidstests
Betrouwbaarheidstesten zijn een soort systeemintegratietesten die nagaan hoe betrouwbaar de software is.
Daarbij moeten de functies en prestaties van de software in een gecontroleerde omgeving worden getest om na te gaan of de resultaten van eenmalige tests betrouwbaar en repliceerbaar zijn.
7. Testen van de configuratie
Configuratietests zijn een soort systeemtests die beoordelen hoe goed het systeem presteert wanneer het samenwerkt met verschillende soorten software en hardware.
Het doel van configuratietests is de beste configuratie van software en hardware te bepalen om de prestaties van het systeem als geheel te maximaliseren.
8. Veiligheidstests
Beveiligingstests zijn een soort systeemtests die evalueren hoe de software presteert met betrekking tot veiligheid en vertrouwelijkheid.
Het doel van beveiligingstests is het opsporen van mogelijke kwetsbaarheden en gevaren die de bron kunnen zijn van datalekken en schendingen die kunnen leiden tot het verlies van geld, vertrouwelijke gegevens en andere belangrijke activa.
9. Migratietests
Migratietesten zijn een soort systeemtesten die worden uitgevoerd op softwaresystemen om na te gaan hoe deze kunnen samenwerken met oudere of nieuwere infrastructuren.
Testers kunnen bijvoorbeeld beoordelen of oudere software-elementen naar een nieuwe infrastructuur kunnen migreren zonder dat er bugs en fouten optreden.
Wat u nodig hebt om systeemtests uit te voeren
Voordat het testen van het systeem kan beginnen, is het belangrijk dat u een duidelijk plan hebt om de middelen en instrumenten bijeen te brengen die nodig zijn voor een succesvol en soepel systeemtestproces.
Het is een relatief ingewikkeld proces, of u nu handmatig, automatisch of op beide manieren test, dus weten wat u nodig hebt voordat u begint is de beste manier om het risico van vertragingen en verstoringen tijdens het testen te beperken.
1. Een stabiele build die bijna klaar is om te lanceren
Systeemtests zijn een van de laatste stadia van softwaretests die vóór de vrijgave plaatsvinden: het enige type tests dat na de systeemtests plaatsvindt, is de gebruikersacceptatietest.
Het is belangrijk dat u, voordat u begint met systeemtests, al andere soorten softwaretests hebt uitgevoerd, waaronder functionele tests, regressietests en integratietests, en dat uw softwareproductie heeft voldaan aan de afsluitingscriteria voor elk van deze soorten softwaretests.
2. Plannen voor het testen van het systeem
Voordat u begint met testen, moet u formele documentatie opstellen met het doel en de doelstellingen van de tests die u gaat uitvoeren en waarin de begin- en eindcriteria van de systeemtests worden gedefinieerd.
U kunt dit plan gebruiken om individuele testscenario’s te schetsen die u gaat testen of om uw verwachtingen te bepalen over hoe het systeem zal presteren.
Het systeemtestplan moet het testers gemakkelijk maken systeemtests te ontwerpen en uit te voeren door het plan te volgen.
3. Testgevallen
Het is belangrijk om de testgevallen die je gaat testen tijdens het testen van het systeem te schetsen voordat het testen van het systeem begint.
Testgevallen mogen niet volledig zijn, maar ze moeten volledig genoeg zijn om de belangrijkste functionele en niet-functionele kenmerken van het systeem te testen en een nauwkeurig overzicht te geven van de werking van het systeem als geheel.
4. Vaardigheden en tijd
Zorg ervoor dat u voldoende middelen uittrekt voor systeemtests voordat u ermee begint.
Systeemtesten kunnen relatief veel tijd in beslag nemen, vooral in vergelijking met andere soorten testen zoals rooktesten.
U moet bepalen welke mensen in uw team de tests gaan uitvoeren en hoeveel tijd zij moeten reserveren voordat het testen begint.
5. Instrumenten voor systeemtests
Systeemtests kunnen handmatig of geautomatiseerd worden uitgevoerd, maar ongeacht de testaanpak is het mogelijk uw systeemtestworkflows te stroomlijnen en te optimaliseren door hulpmiddelen en technologie te gebruiken die helpen bij verschillende aspecten van het testen.
U kunt bijvoorbeeld AI-tools gebruiken om sommige van uw systeemtests te automatiseren, of u kunt software voor documentbeheer gebruiken om de voortgang en de resultaten van uw tests bij te houden.
Het testproces van het systeem
Voordat u begint, is het belangrijk het systeemtestproces en de uitvoering van elk van de stappen ervan te begrijpen.
Dit stappenplan volgt de eerder beschreven levenscyclus van de systeemtest, maar gaat verder in op de afzonderlijke stappen van de systeemtest.
Stap 1: Maak een testplan voor het systeem
Maak uw systeemtestplan voordat u begint met systeemtesten. Elk systeemtestplan zal anders zijn, maar uw plan moet ten minste een overzicht bevatten van het doel van het testen en de relevante ingangs- en uitgangscriteria die bepalen wanneer het testen moet beginnen en wanneer het testen is afgelopen.
Stap 2: Genereer testscenario’s en testgevallen
De volgende fase is het genereren van testscenario’s en testgevallen die precies aangeven wat je gaat testen en hoe je dat gaat doen.
Neem realistische testscenario’s op die testen hoe de software werkt bij normaal gebruik, en geef voor elk testgeval dat u opschrijft details over de criteria voor slagen en falen van de test en wat het verwachte resultaat is.
Stap 3: De vereiste testgegevens creëren
Maak de vereiste testgegevens voor elk uit te voeren testscenario.
De testgegevens die u nodig hebt voor elk testscenario dat u wilt uitvoeren, zijn alle testgegevens die van invloed zijn op of beïnvloed worden door elke specifieke test.
Het is mogelijk om handmatig testgegevens te genereren of u kunt deze fase automatiseren als u tijd wilt besparen en de middelen hebt om dat te doen.
Stap 4: De testomgeving opzetten
De volgende stap is het opzetten van de testomgeving die klaar is om uw systeemtests uit te voeren. U krijgt betere resultaten van uw systeemtests als u een productie-achtige testomgeving opzet.
Zorg ervoor dat uw testomgeving alle software en hardware bevat die u wilt testen tijdens configuratie- en integratietests.
Stap 5: De testgevallen uitvoeren
Zodra u de testomgeving hebt opgezet, kunt u de testgevallen uitvoeren die u in de tweede stap hebt gemaakt.
U kunt deze testgevallen handmatig uitvoeren, of u kunt de uitvoering van de testgevallen automatiseren met behulp van een script.
Noteer bij elk testgeval de resultaten.
Stap 6: bugrapporten opstellen
Zodra u alle geschetste testgevallen hebt uitgevoerd, kunt u de resultaten van elke test gebruiken om bugrapporten op te stellen waarin alle bugs en defecten die u tijdens de systeemtests hebt vastgesteld, gedetailleerd worden belicht.
Geef dit rapport door aan de ontwikkelaars voor reparatie en reparatie van bugs. Het repareren van bugs kan enige tijd in beslag nemen, afhankelijk van de complexiteit en de ernst van de bugs die u vaststelt.
Stap 7: Opnieuw testen na reparatie van bugs
Zodra de softwareontwikkelaars de software hebben teruggestuurd voor verdere tests na het oplossen van bugs, is het belangrijk om de software build opnieuw te testen.
Cruciaal is dat het testen van het systeem niet als voltooid mag worden beschouwd totdat deze stap is doorlopen en er geen bugs of defecten meer te zien zijn.
Het is niet voldoende om aan te nemen dat alle bugs zijn opgelost en dat de build nu klaar is om over te gaan naar gebruikersacceptatietests.
Stap 8: Herhaal de cyclus
De laatste stap is deze cyclus zo vaak te herhalen als nodig is om stap zeven te halen zonder bugs of gebreken te ontdekken.
Zodra de systeemtest slaagt en u aan alle exitcriteria van het systeemtestplan hebt voldaan, is het tijd om over te gaan tot gebruikersacceptatietests en uiteindelijk tot de vrijgave van het product.
Handmatige vs. geautomatiseerde systeemtests
Net als andere soorten softwaretests kunnen systeemtests ofwel handmatig worden uitgevoerd door menselijke testers, ofwel ten minste gedeeltelijk worden geautomatiseerd door software. Automatisering van softwaretests stroomlijnt het testproces en bespaart tijd en geld, maar soms is het belangrijk om ook handmatige systeemtests uit te voeren.
Er zijn voor- en nadelen aan zowel handmatige als geautomatiseerde systeemtests, en het is belangrijk deze te begrijpen voordat u beslist welk type systeemtest u wilt uitvoeren.
Handmatig systeem testen
Handmatig systeemtesten betekent het handmatig uitvoeren van systeemtesten, zonder een deel van het testproces te automatiseren.
Het handmatig testen van systemen duurt langer dan het geautomatiseerd testen, maar het betekent ook dat het testproces profiteert van menselijk inzicht en oordeel.
Handmatige tests worden vaak gecombineerd met geautomatiseerde tests om de doeltreffendheid en nauwkeurigheid van systeemtests en andere soorten softwaretests te maximaliseren.
1. De voordelen van handmatige systeemtests
Er zijn veel voordelen verbonden aan het handmatig testen van systemen, en deze voordelen verklaren waarom veel testteams ervoor kiezen om zowel handmatig als geautomatiseerd te blijven testen, zelfs na het automatiseren van testscripts.
Complexiteit
Handmatig testen is geschikt voor het testen van complexe testscenario’s die niet altijd gemakkelijk te automatiseren zijn.
Als de vereisten voor uw systeemtests ingewikkeld of gedetailleerd zijn, kan het gemakkelijker zijn deze scenario’s handmatig te testen dan er geautomatiseerde testscripts voor te schrijven.
Verkennende tests
Wanneer u een softwaretest automatiseert, volgt de test zijn script en test alleen precies die functies die u hebt geprogrammeerd om te beoordelen.
Wanneer u daarentegen handmatig test, kunt u ervoor kiezen om verschillende functies te verkennen wanneer ze uw interesse wekken, bijvoorbeeld wanneer u iets opmerkt dat er niet uitziet zoals het hoort in de interface van de software.
Eenvoud
Zodra u uw geautomatiseerde testscripts hebt geschreven, is geautomatiseerd testen eenvoudig. Maar meestal is er ontwikkelingskennis nodig om testscripts te schrijven, en kleinere testteams hebben misschien niet de middelen om dit te doen.
Handmatig testen vereist geen technische expertise of kennis van codering.
2. De uitdagingen van handmatige systeemtests
Handmatig testen brengt ook zijn eigen uitdagingen met zich mee. Softwaretestteams die alleen handmatige systeemtests uitvoeren zonder elementen van geautomatiseerd testen op te nemen, kunnen in het nadeel zijn vergeleken met teams die beide benaderingen gebruiken.
Tijdrovend
Zoals u kunt verwachten, is het uitvoeren van handmatige systeemtests tijdrovender dan geautomatiseerde systeemtests. Dit is vooral een zwak punt wanneer er agile getest moet worden.
Dit betekent dat het minder praktisch is om regelmatig of zeer grondig systeemtests uit te voeren, en dat kan weer van invloed zijn op de betrouwbaarheid en de reikwijdte van de resultaten.
Menselijke fout
Wanneer mensen handmatig testen, is er altijd ruimte voor menselijke fouten. Mensen maken fouten en raken verveeld of afgeleid, en dit is vooral waarschijnlijk bij repetitieve, tijdrovende tests die testers eerder vermoeien.
Testdekking
Handmatige tests bieden niet dezelfde dekking als geautomatiseerde tests.
Omdat testers zelf handmatige tests moeten uitvoeren, is het onmogelijk om bij handmatig testen evenveel terrein te bestrijken als bij geautomatiseerd testen, en dat kan leiden tot minder uitgebreide testresultaten.
Wanneer handmatig software testen
Handmatig testen van software is niet vervangen door geautomatiseerd testen, en handmatig testen is nog steeds een belangrijke fase in het testproces van een systeem.
Handmatig testen is geschikt voor kleinere softwareteams die misschien niet de middelen hebben om zelfstandig systeemtesten te automatiseren, en zelfs teams die geautomatiseerd testen hebben ingevoerd, zouden handmatig testen moeten gebruiken om complexere testscenario’s of testgevallen te beoordelen waarbij verkennende tests waardevol zijn.
Automatisering van systeemtesten
Het is mogelijk systeemtests te automatiseren, hetzij door zelf testscripts te schrijven, hetzij door gebruik te maken van hyperautomatiseringstools en -processen om het systeemtestproces gedeeltelijk of volledig te automatiseren.
Meestal worden geautomatiseerde systeemtests gecombineerd met handmatige systeemtests om de beste balans te vinden tussen dekking, efficiëntie en nauwkeurigheid.
1. De voordelen van automatisering van systeemtesten
Geautomatiseerde systeemtests worden steeds populairder, deels vanwege de ruime beschikbaarheid van geautomatiseerde testhulpmiddelen waarmee het testen van softwaresystemen gemakkelijk kan worden geautomatiseerd.
Geautomatiseerde systeemtests hebben veel voordelen, vooral in combinatie met handmatige tests.
Efficiëntie
Geautomatiseerd testen is efficiënter dan handmatig testen, omdat het mogelijk is geautomatiseerde tests op de achtergrond uit te voeren terwijl testers en ontwikkelaars andere taken uitvoeren.
Dit maakt het praktischer om op meer regelmatige basis geautomatiseerde tests uit te voeren en vermindert de noodzaak om een groot aantal middelen te delegeren om te testen nadat de geautomatiseerde tests zijn opgezet.
Grotere testdekking
Geautomatiseerde tests kunnen vaak een groter gebied van de te bouwen software bestrijken dan handmatige tests, grotendeels vanwege hun grotere efficiëntie.
Wanneer testers handmatig systeemtests uitvoeren, moeten ze de belangrijkste testcases kiezen om te beoordelen, terwijl geautomatiseerde tests softwareteams de flexibiliteit geven om meer scenario’s in minder tijd te testen.
Menselijke fouten verwijderen
Geautomatiseerde tests zijn niet zo gevoelig voor menselijke fouten als handmatige tests.
Bij het uitvoeren van repetitieve, tijdrovende tests die handmatige testers kunnen vermoeien, blijven geautomatiseerde tests software testen met dezelfde snelheid en nauwkeurigheid.
Mensen zijn ook eerder geneigd zich te concentreren op het vinden van gemakkelijke bugs dan op moeilijke bugs, waardoor sommige belangrijke maar minder voor de hand liggende bugs kunnen worden gemist.
Testen standaardiseren
Wanneer u een script schrijft om systeemtests te automatiseren, maakt u een reeks instructies die uw softwaretestprogramma moet volgen.
Dit standaardiseert effectief de softwaretests die u uitvoert en zorgt ervoor dat elke keer dat u een test uitvoert, u dezelfde test uitvoert en software test volgens dezelfde normen.
2. De uitdagingen van automatisering van systeemtests
Geautomatiseerde systeemtests zijn niet perfect, daarom worden ze vaak samen met handmatige tests uitgevoerd voor de beste resultaten. Het is efficiënter dan handmatig testen, maar biedt wellicht minder diepgang of kwalitatieve gegevens.
Flexibiliteit
Omdat geautomatiseerde tests altijd een script volgen, is er geen flexibiliteit om mechanismen of functies te testen buiten die welke in het testscript zijn geschreven.
Hoewel dit resulteert in consistentie, betekent het wel dat bugs en fouten kunnen worden gemist als daar tijdens de planning geen rekening mee is gehouden.
Middelen
Het opzetten van geautomatiseerde tests kost tijd en middelen.
Hoewel het mogelijk is systeemtests te automatiseren met behulp van kant-en-klare software en hulpmiddelen, moeten deze meestal nog worden aangepast aan uw software-eisen.
Traditioneel betekende geautomatiseerd testen het inzetten van technische middelen om geautomatiseerde tests te schrijven en goed uit te voeren, hoewel steeds meer tools zoals ZAPTEST geavanceerde computer vision software automatisering bieden in een codeloze interface.
Complexe testgevallen
In de meeste gevallen is het niet mogelijk om systeemtests 100% te automatiseren zonder gebruik te maken van handmatige tests.
Dit geldt met name wanneer u complexe testscenario’s moet testen die de meeste automatiseringstools niet aankunnen.
3. Wanneer geautomatiseerde systeemtests uitvoeren?
Als uw testteam de middelen heeft om geautomatiseerd testen te implementeren, hetzij door zelf testscripts te schrijven, hetzij door automatiseringstools te gebruiken om ze te schrijven, kan geautomatiseerd testen het testen van systemen zowel efficiënter als betrouwbaarder maken.
Het is echter altijd belangrijk om handmatig te blijven testen, zelfs als u vertrouwen hebt in de kwaliteit en de dekking van uw geautomatiseerde tests, omdat geautomatiseerde tests niet de diepgang en het inzicht kunnen repliceren die alleen handmatige tests kunnen bieden.
Conclusie: Geautomatiseerde systeemtests vs. handmatige systeemtests
Geautomatiseerde systeemtests en handmatige systeemtests zijn beide belangrijk tijdens de testfase van softwareontwikkeling.
Hoewel kleinere bedrijven misschien beginnen met alleen handmatige systeemtests vanwege de extra investering of middelen die geautomatiseerd testen vereist, kiezen de meeste testteams voor een gecombineerde aanpak waarbij geautomatiseerd testen wordt toegepast zodra dat praktisch mogelijk is.
Door geautomatiseerd testen te combineren met handmatig testen, kunnen testteams de efficiëntie, nauwkeurigheid en flexibiliteit maximaliseren zonder afbreuk te doen aan de resultaten van systeemtesten.
Beste praktijken voor systeemtests
Als u uw workflows voor systeemtests wilt optimaliseren voor maximale efficiëntie en nauwkeurigheid, is het volgen van best practices voor systeemtests de beste manier om dit te doen.
Best practices kunnen u helpen om tijdens de systeemtestfase niets over het hoofd te zien en zorgen ervoor dat uw systeemtests altijd van een consistent hoog niveau zijn.
1. De systeemtests adequaat plannen
Alle systeemtests moeten beginnen met een formeel testplan dat duidelijk de testgevallen en benaderingen schetst die tijdens het testen zullen worden gebruikt.
Beginnen met een formeel plan vermindert het risico van vertragingen tijdens het testen en voorkomt verstoringen die kunnen voortvloeien uit onduidelijkheden.
Het zorgt ervoor dat alle betrokken partijen weten wat hun rol is en waarvoor zij verantwoordelijk zijn.
2. Schrijf altijd gedetailleerde, nauwkeurige verslagen
Het is belangrijk dat systeemtests altijd goed gedocumenteerd zijn, anders vinden testers en softwareontwikkelaars het misschien niet gemakkelijk om naar de resultaten van uw tests te handelen.
Schrijf duidelijke, grondige rapporten voor elke test die u uitvoert, met details over de bugs die u vindt, laat precies zien hoe u ze kunt repliceren, en geef aan hoe de software zich zou moeten gedragen als ze eenmaal gerepareerd is.
Zorg ervoor dat uw bugrapporten ondubbelzinnig en gemakkelijk te volgen zijn.
3. Testen op echte apparaten
Vaak kiezen testteams ervoor om verschillende apparaten binnen de testomgeving te repliceren, zonder software daadwerkelijk op verschillende apparaten te testen.
Als je software bouwt voor gebruik op verschillende platforms zoals mobiele telefoons, d.w.z. Android, iOS enz. tablets, web en desktops d.w.z. Windows, Linux, enz, zorg ervoor dat u ze test op deze apparaten om te beoordelen hoe ze presteren bij verschillende belastingen en of problemen met de netwerkverbinding problemen kunnen veroorzaken op bepaalde platforms.
4. Het testen waar mogelijk automatiseren
Voor de beste resultaten is het meestal het beste om handmatige systeemtests te combineren met geautomatiseerde systeemtests.
Als u nog niet hebt geëxperimenteerd met geautomatiseerde systeemintegratietests, kunt u door RPA + Software Testing tools uit te proberen die u kunnen helpen om ten minste enkele van uw systeemtests te automatiseren, uw dekking en efficiëntie vergroten zonder de nauwkeurigheid van uw resultaten in gevaar te brengen.
5. Eén kenmerk per geval testen
Wanneer u testgevallen opstelt, richt u dan waar mogelijk op het testen van slechts één functie per geval.
Dit maakt het gemakkelijker om deze testgevallen te hergebruiken in toekomstige tests en het stelt ontwikkelaars in staat om beter te begrijpen hoe bugs ontstaan en door welke functies ze worden veroorzaakt.
Soorten outputs van systeemtests
Wanneer u systeemtests uitvoert, is het belangrijk om te weten welk type output u van uw tests kunt verwachten en hoe u deze output kunt gebruiken voor toekomstige ontwikkeling en tests.
De testresultaten zijn in feite de middelen en informatie die u verkrijgt door het uitvoeren van de systeemtests.
1. Testresultaten
Uw testresultaten bevatten gegevens over hoe de software presteerde in elke testcase die u uitvoerde, naast een vergelijking van hoe u verwachtte dat de software zou presteren.
Deze resultaten helpen bepalen of elke testcase slaagt of faalt, want als de software presteert op een manier die u niet verwachtte, betekent dit meestal dat hij gefaald heeft.
2. Logboek van gebreken
Defectlogs zijn logboeken van alle bugs en defecten die tijdens het testen van het systeem zijn gevonden.
In een defectenlogboek worden alle gevonden bugs vermeld, samen met andere belangrijke informatie zoals de prioriteit van elke bug, de ernst van elke bug en de symptomen en beschrijving van de bug.
U moet ook de datum waarop de bug werd ontdekt noteren en andere informatie die de ontwikkelaars zal helpen om de bug opnieuw te repliceren.
3. Testrapport
Het testrapport maakt gewoonlijk deel uit van de afsluitingscriteria voor het beëindigen van systeemtests, en bevat gewoonlijk een samenvatting van de uitgevoerde tests, GO/No-Go aanbevelingen, fase- en iteratie-informatie, en de datum van de tests.
U kunt ook andere belangrijke informatie over de testresultaten opnemen of een kopie van de defectenlijst bij dit rapport voegen.
Voorbeelden van systeemtests
Systeemtests zijn ontworpen om het systeem als geheel te testen, wat betekent dat ze alle verschillende software-eenheden testen die als systeem samenwerken.
Voorbeelden van systeemtests kunnen u helpen beter te begrijpen wat een systeemtest is en wat hij test.
1. Testen van de functionaliteit
Een team van software-ingenieurs werkt aan een nieuwe winkel-app die kruideniers helpt om online bestellingen efficiënter te verzamelen en in te pakken.
De app is samengesteld uit meerdere verschillende modules, die elk al onafhankelijk zijn getest in unit tests en samen met andere modules zijn getest in integratie tests.
Systeemtests zijn de eerste keer dat alle modules samen worden getest, en testers ontwerpen testcases om elke afzonderlijke functie van de applicatie te beoordelen en na te gaan of ze functioneren zoals verwacht wanneer alle modules samen draaien.
2. Testen van laadtijden
Een team van softwaretesters test hoe snel een applicatie laadt op verschillende punten onder verschillende stressniveaus.
Zij maken testcases die beschrijven onder welk soort stress de applicatie wordt gezet (bijvoorbeeld hoeveel gebruikers er tegelijkertijd gebruik van maken) en welke functies en mogelijkheden de gebruiker probeert te laden.
Tijdens het testen van het systeem worden de laadtijden geregistreerd in het testrapport, en laadtijden die te traag worden geacht zullen een andere ontwikkelingsfase in gang zetten.
3. Testen van de configuratie
Wanneer een videospel wordt gebouwd dat met veel verschillende randapparatuur kan worden gebruikt, waaronder een computermuis, een VR-headset en een gamingpad, voeren softwaretesters configuratietests uit om te testen hoe goed elk van deze randapparatuur met het spel werkt.
Ze doorlopen elk testscenario en testen elk randapparaat afzonderlijk en samen, waarbij ze noteren hoe elk randapparaat presteert op verschillende momenten in het spel en of de prestaties nog slechter zijn dan verwacht.
Soorten fouten en bugs die bij het testen van het systeem worden ontdekt
Wanneer u systeemtests uitvoert, kunt u met de tests die u uitvoert fouten en bugs in de software opsporen die niet zijn gevonden bij unit- en integratietests.
Tijdens het testen van een systeem kunnen vele soorten bugs worden ontdekt, soms omdat ze eerder zijn gemist of meestal omdat ze pas opduiken wanneer het systeem in zijn geheel functioneert.
1. Prestatiefouten
Systeemtests kunnen prestatiefouten in de snelheid, consistentie en reactietijden van een softwarebouwwerk aan het licht brengen.
Testers kunnen beoordelen hoe de software presteert bij het uitvoeren van verschillende taken en eventuele fouten of vertragingen tijdens het gebruik noteren. Dit zijn prestatiegebreken, die al dan niet als ernstig genoeg kunnen worden beschouwd om verdere ontwikkeling te vereisen.
2. Veiligheidsfouten
Het is mogelijk om tijdens het testen van het systeem beveiligingsfouten te ontdekken die kwetsbaarheden in de beveiligingslaag van het systeem aan het licht brengen.
Beveiligingstests vinden plaats tijdens de testfase van het systeem, en kunnen worden gebruikt om encryptiefouten, logische fouten en XSS-kwetsbaarheden in de software op te sporen.
3. Gebruiksfouten
Gebruiksfouten zijn fouten die het moeilijk maken om de app te gebruiken zoals hij bedoeld is. Ze kunnen ongemak veroorzaken voor gebruikers, wat er weer toe kan leiden dat gebruikers de app verlaten.
Enkele voorbeelden van gebruiksfouten zijn een ingewikkeld navigatiesysteem of een lay-out die niet gemakkelijk te navigeren is over alle aspecten van het platform.
Met bruikbaarheidstools kunnen fouten eerder in het testproces worden opgespoord, maar ze kunnen ook opduiken tijdens het testen van het systeem.
4. Communicatiefouten
Communicatiefouten ontstaan wanneer een deel van de software probeert te communiceren met een andere module en deze communicatie door een fout mislukt.
Als de software de gebruiker bijvoorbeeld vraagt om een nieuwe update te downloaden, maar wanneer de gebruiker op de knop voor het downloaden van de update klikt, kan de update niet worden gevonden.
5. Foutenbehandeling
Er treden soms fouten op, zelfs wanneer de software naar behoren werkt. Misschien omdat een onderdeel niet goed is geïnstalleerd of omdat de gebruiker het niet goed bedient.
Het systeem moet echter in staat zijn deze fouten correct af te handelen op een manier die de gebruikers helpt het probleem te identificeren en op te lossen.
Als foutmeldingen onvoldoende informatie bevatten over de optredende fout, kunnen gebruikers de fout niet herstellen.
Gemeenschappelijke statistieken bij het testen van systemen
Wanneer u systeemtests uitvoert, kunt u bepaalde testgegevens bijhouden om uw testteam te helpen controleren hoe effectief systeemtests zijn, hoe vaak bugs worden gevonden en of systeemtests in het juiste stadium van de testcyclus plaatsvinden.
Als u bijvoorbeeld het aantal tests bijhoudt dat slaagt en het aantal dat niet slaagt en constateert dat een groot deel van de systeemtests niet slaagt, kunt u concluderen dat er eerder in de testcyclus grondiger moet worden getest om bugs en fouten op te sporen voordat de systeemtests beginnen.
1. Absolute statistieken
Absolute getallen zijn die getallen die gewoon een absoluut getal geven in plaats van een verhouding of ratio.
Absolute statistieken kunnen nuttig zijn, maar omdat het absolute cijfers zijn, is het niet altijd gemakkelijk te interpreteren wat ze betekenen.
Enkele voorbeelden van absolute maatstaven zijn de duur van systeemtests, de tijd die het kost om een systeemtest uit te voeren, en het totale aantal defecten dat tijdens systeemtests wordt gevonden.
2. Efficiëntie van de test
Testefficiëntiemaatstaven helpen testteams begrijpen hoe efficiënt hun huidige systeemtestprocedures zijn, maar geven geen informatie over de kwaliteit van systeemtests.
Enkele voorbeelden van efficiëntiemetingen zijn het percentage geslaagde tests en het percentage opgeloste defecten.
Goedgekeurde tests kunnen u vertellen of u te veel tests goedkeurt en daardoor bugs mist, vooral als u een hoge metriek van goedkeurtests ziet naast een hoge defect-ontsnappingsratio.
3. Metriek van de doeltreffendheid van de test
Metriek van de effectiviteit van tests vertelt testers iets over de kwaliteit van de systeemtests die ze uitvoeren.
Zij meten hoe doeltreffend de systeemtests zijn in het opsporen en evalueren van bugs en defecten in het systeem.
De totale defect containment efficiency is een voorbeeld van een metriek van de testdoeltreffendheid die de verhouding van insecten toont die tijdens de testfase worden gevonden in vergelijking met insecten die na versie worden gevonden.
4. Metriek van de testdekking
Testdekkingscijfers helpen testers te begrijpen hoe volledig hun dekking is over het hele systeem dat ze proberen te testen.
U kunt bijvoorbeeld meten welk percentage van uw systeemtests is geautomatiseerd of hoeveel van de vereiste tests tot nu toe zijn uitgevoerd.
Een requirement coverage metric helpt testers ook bijhouden welk deel van de vereiste functies door het testen is gedekt.
5. Tekortkomingen
Defectenmetrieken zijn metrieken die de aanwezigheid van defecten op verschillende manieren meten. Sommige defectmetingen kunnen gericht zijn op de ernst van de defecten, terwijl andere zich kunnen richten op het type of de hoofdoorzaak van de defecten.
Een voorbeeld van een gebruikelijke defectmetriek is defectdichtheid, die het totale aantal defecten over de hele release meet.
De defectdichtheid wordt gewoonlijk weergegeven als het aantal defecten per 1000 regels code.
Systeemtestgevallen
Systeemtestgevallen zijn de testscenario’s die bij systeemtests worden gebruikt om te testen hoe de software functioneert en of deze voldoet aan de verwachtingen van ontwikkelaars, testers, gebruikers en belanghebbenden.
1. Wat zijn testgevallen in systeemtests?
Testgevallen zijn in wezen instructies die bepalen wat moet worden getest en welke stappen de tester moet uitvoeren om elk individueel geval te testen.
Bij het schrijven van testgevallen voor systeemtests is het belangrijk om alle informatie op te nemen die testers nodig hebben om elke test uit te voeren. Vermeld voor elk testgeval een testgeval-ID en informatie over hoe de test moet worden uitgevoerd en welke resultaten u verwacht, alsmede de criteria voor slagen en falen voor elk testgeval, indien relevant.
2. Hoe systeemtestgevallen te schrijven
Als u nieuw bent in het schrijven van testgevallen, kunt u de onderstaande stappen volgen om testgevallen te schrijven voor systeemtests. Het schrijven van testgevallen voor andere soorten softwaretests is een vergelijkbaar proces.
- Bepaal het gebied dat uw testcase moet bestrijken.
- Zorg ervoor dat de testcase gemakkelijk te testen is.
- Toepassen van relevante testontwerpen op elk testgeval.
- Geef elk testgeval een uniek testgeval-ID.
- Neem een duidelijke beschrijving op van hoe elk testgeval moet worden uitgevoerd.
- Voeg precondities en postcondities toe voor elk testgeval.
- Specificeer het resultaat dat u van elk testgeval verwacht.
- Schets de te gebruiken testtechnieken.
- Vraag een collega om elke testcase te beoordelen alvorens verder te gaan.
3. Voorbeelden van systeemtestgevallen
Het gebruik van voorbeeldtestgevallen kan u helpen bij het schrijven van uw eigen testgevallen. Hieronder staan twee voorbeelden van systeemtestgevallen die testers kunnen gebruiken om de werking van een applicatie of software te testen.
Prijsvalidatie voor scannen van boodschappenapps
Test ID: 0788
Testgeval: Valideer artikelprijs
Testcase beschrijving: Scan een item en controleer de prijs ervan.
Verwachte resultaten: De gescande prijs moet in overeenstemming zijn met de huidige aandelenkoers.
Resultaat: Het item is gescand op $1, wat overeenkomt met de huidige aandelenprijs.
slagen/zakken: Geslaagd.
Management software end-to-end transactieresponstijd
Test ID: 0321
Test geval: Laadtijden startscherm
Test case beschrijving: Zorg ervoor dat het laadscherm van de app binnen een goede tijd wordt geladen.
Verwachte resultaten: Het scherm zou binnen vier seconden of minder moeten laden.
Resultaat: Het scherm is binnen 6 seconden geladen.
slagen/zakken: Niet geslaagd.
Beste hulpmiddelen voor systeemtests
Het gebruik van tools voor systeemtests is een van de eenvoudigste manieren om het testproces te stroomlijnen en de tijd die testteams besteden aan tijdrovende handmatige taken te verminderen.
Tools voor systeemtests kunnen elementen van het systeemtestproces voor u automatiseren, of ze kunnen het schrijven van testgevallen en het bijhouden van de testvoortgang vergemakkelijken.
Vijf beste gratis systeemtestprogramma’s
Als u niet klaar bent om een flinke hap van uw budget uit te geven aan tools voor systeemtests, maar u wilt onderzoeken wat er is en misschien tegelijkertijd de efficiëntie van uw systeemtestprocessen verbeteren, dan is het goede nieuws dat er veel gratis testtools online beschikbaar zijn.
Gratis testtools bieden niet dezelfde functionaliteit als betaalde testtools, maar ze kunnen kleinere bedrijven een kosteneffectieve manier bieden om softwareautomatisering en RPA te verkennen.
1. ZAPTEST GRATIS Editie
ZAPTEST is een suite van software test tools die kunnen worden gebruikt voor systeem testen en andere soorten software testen.
ZAPTEST is beschikbaar als een gratis en een betaalde enterprise editie, maar de gratis editie is de perfecte introductie tot geautomatiseerd systeem testen voor kleinere bedrijven en bedrijven die de eerste stappen willen zetten in de richting van het testen van automatisering.
ZAPTEST kan systeemtests automatiseren voor zowel desktop als handheld apparaten en stelt testers in staat tests te automatiseren zonder codering.
2. Selenium
Selenium is een van de bekendste open-source testtools op de markt.
De gratis versie van Selenium biedt automatiseringstools die kunnen worden gebruikt bij systeemtests, regressietests en het reproduceren van bugs, en u kunt er uw eigen testscripts mee maken voor veel verschillende testscenario’s.
Het gaat echter ten koste van de eenvoud en het gebruiksgemak en kan voor niet-technische gebruikers vrij moeilijk te leren zijn.
3. Appium
Appium is een gratis systeemtestprogramma dat specifiek geschikt is voor gebruik met mobiele toepassingen.
U kunt Appium gebruiken om systeemtests te automatiseren voor apps die zijn ontworpen voor gebruik met iOS- en Android-smartphones en -tablets.
Deze gratis tool is niet geschikt voor gebruik met desktop toepassingen, wat een van zijn grootste zwakheden is.
3. Testlink
Als u het plannen, voorbereiden en documenteren van systeemtesten eenvoudiger wilt maken, is Testlink een geweldig gratis hulpmiddel dat het beheer van testdocumentatie eenvoudig maakt.
Met Testlink kunt u rapporten gemakkelijk in secties sorteren om de informatie te vinden die u nodig hebt wanneer u die nodig hebt.
Testlink is een waardevol testhulpmiddel of u nu systeemtests, rooktests of andere soorten softwaretests uitvoert.
5. Loadium
Loadium is een gratis testprogramma dat speciaal is ontworpen voor het testen van prestaties en belasting.
De focus op prestatie- en belastingstesten is echter een belangrijke zwakte voor gebruikers die een heel spectrum van end-to-end tests willen automatiseren.
4 beste testprogramma’s voor bedrijfssystemen
Naarmate uw bedrijf groeit, zult u merken dat gratis testtools niet langer aan uw eisen voldoen. Veel gratis tools zoals ZAPTEST bieden zowel bedrijfsversies als gratis versies.
1. ZAPTEST Enterprise-editie
ZAPTEST biedt een bedrijfsversie van hun testtool, met dezelfde gebruiksvriendelijke functies en intuïtieve interface als de gratis tool, maar met een betere schaal voor grotere teams die intensievere tests nodig hebben of die complexere software willen testen.
De ondernemingsversie van ZAPTEST biedt onbeperkte prestatietests en onbeperkte iteraties, evenals een toegewezen ZAP-gecertificeerde expert op afroep voor ondersteuning, werkend als onderdeel van het klantenteam (dit is op zichzelf al een belangrijk voordeel in vergelijking met andere beschikbare automatiseringstools).
Het Unlimited Licenses-model is ook een toonaangevende propositie in de markt, waardoor bedrijven altijd vaste kosten hebben, ongeacht hoe snel ze groeien.
2. SoapUI
SoapUI is een testtool die het mogelijk maakt om systeemtests te beheren en uit te voeren op verschillende webservice platformen en API’s.
Testteams kunnen SoapUI gebruiken om de hoeveelheid tijd die ze besteden aan tijdrovende taken te minimaliseren en grondigere en efficiëntere teststrategieën te ontwikkelen.
3. Testsigma
Testsigma is een software testplatform dat van de plank werkt. Hiermee kunnen productteams automatisch softwaretests plannen en uitvoeren op websites, mobiele apps en API’s.
Het platform is gebouwd met Java, maar het werkt met testscripts die in eenvoudig Engels zijn geschreven.
4. TestingBot
TestingBot is een relatief goedkope bedrijfsoplossing voor bedrijven die in deze sector willen experimenteren zonder meteen veel geld uit te geven. TestingBot biedt testers een eenvoudige manier om zowel websites als mobiele apps te testen met behulp van een grid van 3200 combinaties van browsers en mobiele apparaten.
Het mist de functionaliteit van grotere Enterprise tools, maar het is een goede optie voor bedrijven met lagere budgetten.
Wanneer u zakelijke vs. gratis systeemtestprogramma’s moet gebruiken
Of u kiest voor enterprise of gratis systeemtest tools hangt af van de behoeften van uw team, uw budget, uw prioriteiten en uw werkschema.
Het spreekt voor zich dat zakelijke tools meer mogelijkheden en functionaliteit bieden dan gratis tools, maar voor kleinere bedrijven zonder veel ruimte in het budget zijn gratis tools een fantastische optie.
Als uw bedrijf groeit of als u merkt dat uw testteam meer tijd besteedt aan systeemtests en andere soorten softwaretests dan u zou willen, kan een upgrade naar enterprise testtools en het leren hoe u deze tools ten volle kunt benutten u helpen uw bedrijf verder op te schalen om aan de groeiende vraag te voldoen.
Bovendien kunt u met tools als ZAPTEST Enterprise, die innovatieve Software + Service-modellen en onbeperkte licentiemodellen bieden, gegarandeerd uw technische kenniskloof dichten en uw kosten laag houden, ongeacht hoe snel u groeit en hoeveel u de tools gebruikt.
Checklist, tips en trucs voor systeemtests
Loop, voordat u begint met systeemtesten, de onderstaande checklist voor systeemtesten door en volg deze tips om uw systeemtesten te optimaliseren voor nauwkeurigheid, efficiëntie en dekking.
Een checklist voor systeemtests kan helpen om ervoor te zorgen dat u alles wat u nodig hebt tijdens het testen van het systeem afdekt.
1. Testers betrekken bij de ontwerpfase
Hoewel testers meestal niet aan software werken tot de ontwikkelings- en ontwerpfase is afgerond, is het door testers vroeg te betrekken gemakkelijker voor hen om te begrijpen hoe verschillende componenten samenwerken en dit mee te nemen in hun tests.
Dit resulteert vaak in meer inzichtelijke verkennende tests.
2. Duidelijke testgevallen schrijven
Wanneer u uw testgevallen schrijft, zorg er dan voor dat ze duidelijk en ondubbelzinnig zijn.
Testers moeten testcases kunnen lezen en onmiddellijk begrijpen wat er getest moet worden en hoe het getest moet worden.
Leg zo nodig uit waar de te testen functie te vinden is en welke stappen tijdens het systeemtestproces moeten worden genomen.
3. Maximale testdekking
Het is meestal niet mogelijk om 100% testdekking te bereiken wanneer u systeemtests uitvoert, zelfs als u gebruik maakt van automatiseringstools.
Echter, hoe groter uw testdekking, hoe groter de kans dat u bugs opspoort en oplost vóór de release.
Probeer een testdekking te bereiken van ten minste 90% of zo dicht mogelijk daarbij in de buurt.
4. Resultaten grondig analyseren
Analyseer de resultaten van elke systeemtest grondig, en rapporteer bugs en defecten duidelijk in uw documentatie.
Hoe meer details u kunt geven over bugs, hoe gemakkelijker het voor ontwikkelaars is om die bugs later te repliceren.
Als u ideeën hebt over waarom de bugs zich voordoen en hoe de bugs kunnen worden verholpen, voeg die dan bij uw testresultaten.
5. Ga verder dan het testen van eisen
Test uw toepassingen niet alleen om te zien of ze doen wat ze moeten doen.
Test hoe uw software werkt buiten de vereisten om, om te zien hoe het reageert op taken en handelingen buiten het bedoelde gebruik. Dit kan u helpen bugs en defecten op te sporen die u anders zou missen.
7 fouten en valkuilen die u moet vermijden bij het uitvoeren van systeemtests
Wanneer systeemtests voor de eerste keer worden uitgevoerd, is het belangrijk zich bewust te zijn van veelgemaakte fouten en valkuilen die testteams vaak maken.
Als u weet wat deze fouten zijn, kunt u ze gemakkelijk vermijden, wat de doeltreffendheid en nauwkeurigheid van uw eigen systeemtests ten goede zou moeten komen.
1. Beginnen zonder testplan
Het is belangrijk om een gedetailleerd testplan op te stellen voordat u begint met systeemtests.
Als u begint met integratietesten zonder een plan, is het gemakkelijk om enkele testgevallen te vergeten die u van plan bent uit te voeren of testgevallen die buiten het testplan vallen.
De meeste mensen kunnen zich de volledige details van een testplan niet herinneren, tenzij het duidelijk gedocumenteerd is, en het voorkomt ook dat teams het doorspelen aan andere testers.
2. Het niet definiëren van de reikwijdte van systeemtests
Het testen van systemen is een multidimensionale taak waarbij veel verschillende aspecten van één softwarebouwwerk worden getest.
Afhankelijk van het soort software dat je ontwikkelt en wat je tot nu toe hebt getest, kan de reikwijdte van de systeemtests sterk variëren.
Het is belangrijk om de reikwijdte van het testen te bepalen voordat het testen begint en ervoor te zorgen dat deze reikwijdte door alle leden van het testteam wordt begrepen.
3. Het negeren van vals positieve en vals negatieve resultaten
Fout-positieve resultaten ontstaan wanneer systeemtests slagen ondanks dat de testscenario’s niet werken zoals verwacht.
Evenzo kunnen valse negatieven optreden wanneer een test mislukt hoewel hij werkt zoals verwacht.
Soms kan het moeilijk zijn om fout-positieven en fout-negatieven te herkennen, vooral als je alleen naar de testresultaten kijkt zonder je te verdiepen in de eigenlijke output van de test. Valse positieven en negatieven zijn bijzonder waarschijnlijk en gemakkelijk te missen bij geautomatiseerde systeemtests.
4. Testen met soortgelijke soorten testgegevens
Als u meerdere verschillende soorten testgegevens gebruikt, kunt u de dekking van uw systeemtests vergroten door de kenmerken van de testgegevens die u gebruikt zoveel mogelijk te variëren.
Dit betekent dat u minder snel bugs en defecten mist en geeft een meerwaarde aan het testen dat u uitvoert.
Door verschillende soorten testgegevens te gebruiken, krijgt u een gedetailleerder beeld van hoe het product zich na de release zal gedragen.
5. Het negeren van verkennende tests
Hoewel het volgen van het testplan belangrijk is, is het ook belangrijk om ruimte te maken voor verkennende tests en om testers in staat te stellen verschillende mogelijkheden en functies uit te proberen als ze die tijdens het testen tegenkomen.
Verkennende tests kunnen vaak nieuwe bugs aan het licht brengen die anders zouden worden gemist, of bugs die al tijdens andere testfasen zijn gemist.
U kunt zelfs verkennende testsessies plannen door testjamsessies te organiseren waarbij testers allemaal ongeplande systeemtests uitvoeren gedurende een bepaalde periode.
6. Het niet regelmatig beoordelen van de resultaten van de testautomatisering
Als je nieuw bent in het testen van softwaresystemen en in het bijzonder in geautomatiseerd testen, zou je kunnen denken dat je de test gewoon kunt laten lopen.
Maar het is belangrijk om de resultaten van de testautomatisering regelmatig te bekijken en waar nodig wijzigingen aan te brengen in de code van de testautomatisering.
Als u bijvoorbeeld wijzigingen aanbrengt in de software die u test, moeten deze worden weerspiegeld in de code van de geautomatiseerde tests.
Lees geautomatiseerde testresultaten zorgvuldig om elke output van de test te begrijpen, en niet alleen de pass/fail resultaten.
7. Het verkeerde automatiseringsprogramma gebruiken
Er zijn tegenwoordig veel automatiseringstools beschikbaar, waarvan sommige gratis te gebruiken zijn en andere waarvoor gebruikers een maandelijks bedrag moeten betalen.
Hoewel beginners meestal kiezen voor open-source tools, is het belangrijk om er zeker van te zijn dat de tool die u kiest past bij uw eisen en de functies biedt die u nodig hebt.
Open source tools staan bijvoorbeeld bekend om hun beperkte functionaliteit, niet-intuïtieve UI en zeer moeilijke leercurve. Full-stack testing tools zoals ZAPTEST Free Edition bieden daarentegen top end test- en RPA-functionaliteit zoals 1SCRIPT, Cross Browser, Cross Device, Cross Platform Technology, in een eenvoudig te gebruiken codeloze interface, geschikt voor zowel niet-technische als ervaren testers.
En soms is het de moeite waard om te investeren in een iets duurdere automatiseringstool op bedrijfsniveau als de functionaliteit die deze biedt veel beter bij uw project past.
Conclusie
Systeemtests zijn een belangrijke fase van softwaretests die het systeem als geheel controleren en ervoor zorgen dat elk afzonderlijk onderdeel soepel en efficiënt samenwerkt.
Het is de fase van het testen van software die komt na de integratietest en vóór de acceptatietest, en het is een van de laatste formele testfasen van software die plaatsvindt vóór de eerste vrijgave.
Met systeemtests kunnen testers verschillende soorten bugs opsporen, waaronder functionele en niet-functionele fouten, maar ook gebruiksfouten en configuratiefouten.
Het is mogelijk om systeemtests handmatig uit te voeren of te automatiseren, hoewel in de meeste gevallen een hybride aanpak wordt aanbevolen om de efficiëntie te maximaliseren en toch ruimte te maken voor verkennende tests.
Door best practices te volgen en de veelvoorkomende valkuilen van systeemtesten te vermijden, kunnen testteams nauwkeurige, effectieve systeemtesten uitvoeren die de meeste belangrijke gebieden van de build bestrijken.
FAQ’s en hulpmiddelen
Als je nieuw bent in het testen van systemen, zijn er online veel bronnen die je kunnen helpen om meer te leren over systeemtesten en hoe je systeemtesten uitvoert.
Hieronder vindt u een aantal nuttige online hulpmiddelen voor systeemtests en antwoorden op enkele van de meest gestelde vragen over systeemtests.
1. De beste cursussen over systeemtesten
Het volgen van online cursussen in systeemtesten of software testen kan QA professionals helpen om hun begrip van systeemtesten te ontwikkelen en kwalificaties te verdienen die die kennis aantonen.
Online trainingssites zoals Coursera, Udemy, edX en Pluralsight bieden gratis en betaalde cursussen in software testen en automatisering voor professionals en beginners.
Enkele voorbeelden van online cursussen in systeemtesten zijn:
- De Complete 2023 Software Testing Bootcamp, Udemy
- Software testen en automatisering specialisatie, Coursera
- Geautomatiseerd testen van software, edX
- Geautomatiseerd testen van software met Python, Udemy
- Bedrijfsanalist: Software Testing Processes and Techniques, Udemy
Zoek naar online cursussen die passen bij uw ervaringsniveau en uw budget. Als u in QA werkt, kunt u uw werkgever misschien vragen u te sponsoren om een geaccrediteerde cursus in softwaretesten te volgen.
2. Wat zijn de top 5 interviewvragen over systeemtesten?
Als u zich voorbereidt op een sollicitatiegesprek voor een functie waarbij systeemtests of andere vormen van softwaretests komen kijken, kan het vooraf voorbereiden van antwoorden op veelvoorkomende sollicitatievragen uw prestaties tijdens het gesprek ten goede komen.
Enkele van de meest voorkomende interviewvragen over systeemtesten zijn:
- Hoe verschillen systeemtests van integratietests?
- Wat zijn de voor- en nadelen van geautomatiseerde systeemtests?
- Hoeveel soorten systeemtests kunt u opnoemen?
- Hoe maximaliseert u de testdekking tijdens systeemtests?
- Wat voor soort bugs en defecten verwacht u te vinden in systeemtests?
U kunt deze vragen gebruiken om voorafgaand aan uw gesprek antwoorden voor te bereiden volgens de STAR-structuur, waarbij u voorbeelden uit uw carrière gebruikt om uw kennis van systeemtests en andere soorten softwaretests aan te tonen.
3. De beste YouTube tutorials over systeemtesten
Als u een visuele leerling bent, vindt u het misschien gemakkelijker om te begrijpen wat systeemtests zijn en hoe ze werken naast andere soorten softwaretests door video’s over systeemtests te bekijken.
Er zijn veel instructievideo’s op YouTube die uitleggen wat systeemtests zijn en hoe je met systeemtests kunt beginnen, of je die nu handmatig wilt uitvoeren of met behulp van automatiseringstools. Enkele van de beste YouTube tutorials over systeemtesten zijn:
- Wat is systeemtests?
- Acceptatietests en systeemtests
- Wat is systeemtests en hoe werken ze?
- Systeemintegratietesten met een real-time voorbeeld
- Wat is systeemtests in softwaretests?
4. Hoe onderhoud je systeemtests?
Testonderhoud is het proces van het aanpassen en onderhouden van systeemtests en andere soorten softwaretests om ze up-to-date te houden wanneer u wijzigingen aanbrengt in een software-build of de code wijzigt.
Als je bijvoorbeeld systeemtests uitvoert en bugs en defecten vindt, stuur je de software build terug naar de ontwikkelaars voor aanpassingen. Testteams moeten dan mogelijk testscripts onderhouden om ervoor te zorgen dat zij de nieuwe software build adequaat testen wanneer het tijd is om opnieuw te testen.
Testonderhoud is een belangrijk aspect van het testen van software, en testers kunnen ervoor zorgen dat ze software onderhouden door best practices voor onderhoud te volgen.
Deze omvatten:
1. Samenwerking:
Ontwikkelaars en testers moeten samenwerken om ervoor te zorgen dat de testers weten welke aspecten van de code zijn gewijzigd en hoe dit de testscripts kan beïnvloeden.
2. Ontwerp:
Ontwerp testscripts voordat u tests gaat automatiseren. Dit zorgt ervoor dat de tests die u automatiseert altijd geschikt zijn voor het doel.
3. Proces:
Houd tijdens het ontwerpproces rekening met het onderhoud van softwaretests. Vergeet niet dat u tests zult moeten onderhouden en neem dit mee in uw planning, testplannen en testontwerp.
4. Gemak:
Update al uw tests, inclusief systeemtests en sanity tests, indien mogelijk vanaf één dashboard.
Dit betekent dat het bijwerken van tests veel sneller en handiger gaat, en het minimaliseert het risico dat men vergeet een bepaalde test bij te werken wanneer er wijzigingen zijn aangebracht in de software build.
Is het testen van systemen white box of black box?
Systeemtests zijn een vorm van black-box testing.
Black box testing verschilt van white box testing doordat alleen de externe functies en kenmerken van de software in aanmerking worden genomen. Bij white box testing wordt getest hoe de software intern werkt, bijvoorbeeld hoe de code functioneert en samenwerkt.
Black box testing vereist geen kennis van de interne werking van het systeem of van de code, maar vereist eenvoudigweg dat de testers de outputs en functies van de softwaretoepassing testen en deze toetsen aan vastgestelde criteria.
Systeemtests omvatten zowel functionele als niet-functionele tests, maar testers gebruiken een black box techniek om zelfs niet-functionele aspecten van de build te testen.
Daarom worden systeemtests over het algemeen beschouwd als een vorm van black-box testing.
