Het testen van gebruikersinterfaces is belangrijker dan ooit tevoren dankzij een wereldwijde toename van websites en toepassingen. Als u een nieuw stuk software of een nieuwe webpagina uitrolt, is het van cruciaal belang dat u de gebruikersinterface (UI) goed afstemt op functionaliteit en esthetiek.
Er komt veel kijken bij het maken van een aantrekkelijke UI, waarbij UI-tests dienen als lakmoesproef om te bepalen of de interface aan alle eisen voldoet.
In dit artikel bespreken we alle belangrijke aspecten van UI-tests, van de definitie van UI tot de beste manieren om uw UI te testen.
UI vs. GUI: De verwarring ophelderen
Laten we om te beginnen proberen alle verwarring rond de termen UI en GUI weg te nemen. Hieronder wordt uiteengezet wat deze twee termen betekenen en waarin zij verschillen:
1. Wat is testen van gebruikersinterfaces?
De gebruikersinterface, of UI, is het platform dat u gebruikt voor interactie met een bepaald stuk software. De UI is de plaats waar u instructies kunt invoeren, gegevens kunt invoeren of informatie van een scherm of monitor kunt bekijken.
Er zijn veel verschillende soorten UI, waaronder grafische gebruikersinterfaces (GUI) en opdrachtregelinterfaces die alleen code en tekst tonen.
2. Wat is een grafische gebruikersinterface (GUI)?
De grafische gebruikersinterface (GUI) is een type UI waarmee de meeste mensen vertrouwd zijn. Het is een type interface dat gebruik maakt van visuals om ons te helpen bij de interactie met functies in het systeem.
U kunt bijvoorbeeld menu’s of werkbalken met pictogrammen gebruiken om u te helpen door een systeem te navigeren. Zelfs tekst werkt goed in GUI’s als een manier om de gebruiker door een functie te leiden, zoals het klikken op ‘bestand’ wanneer je een document wilt openen of opslaan.
3. UI vs. GUI
Om deze twee vormen van computerinteractie beter te begrijpen, zie hieronder de directe vergelijking tussen UI en GUI:
UI:
– Een afkorting van user interface
– Het is een soort platform waarmee gebruikers kunnen communiceren met apparaten
– Het is een vorm van mens-machine interactie
– Het wordt door iedereen gebruikt en werkt vaak op de achtergrond, zodat je niet weet dat je het gebruikt.
– Gangbare voorbeelden zijn MS-DOS of Unix
GUI:
– Een afkorting van graphical user interface
– Het is een type platform dat afbeeldingen gebruikt om gebruikers te helpen navigeren door de functies van een apparaat.
– Het is een subklasse van UI
– Het wordt meestal gebruikt door gemiddelde, alledaagse gebruikers zoals consumenten
– Bekende voorbeelden zijn Windows 10, iOS en Android
Wat is gebruikersinterface (UI) testen?
User interface (UI) testing, soms bekend als GUI testing afhankelijk van de context, is een reeks handelingen om de prestaties en algemene functionaliteit van de visuele elementen van een applicatie te meten. Hij controleert en valideert verschillende functies van de UI en zorgt ervoor dat er geen onverwachte uitkomsten, defecten of bugs zijn.
UI-tests met hulpmiddelen zoals ZAPTEST worden voornamelijk gebruikt om zaken als bruikbaarheid, functionaliteit en prestaties van de UI te controleren om er zeker van te zijn dat deze geschikt is voor het doel.
In sommige gevallen wordt ook gecontroleerd op zaken als overeenstemming of visuele eenheid met de algemene ontwerpconcepten van het systeem.
Wanneer en waarom zijn gebruikersinterfacetests nodig?
UI-tests zijn meestal het meest effectief voordat de applicatie wordt vrijgegeven voor productie. Dit is om ervoor te zorgen dat de eindgebruiker de beste ervaring heeft, met zo weinig mogelijk bugs en defecten.
Eindgebruikers zijn niet de beste softwaretesters, dus het is belangrijk om eventuele problemen op te lossen voordat de software hen bereikt.
UI-tests zijn een nuttige manier om te beoordelen hoe de toepassing omgaat met bepaalde acties, zoals het gebruik van een toetsenbord en muis voor interactie met menu’s. Het helpt de visuele elementen van de toepassing te controleren om er zeker van te zijn dat ze correct worden weergegeven.
UI-tests zijn ook een goede manier om de prestaties te meten en ervoor te zorgen dat er geen bugs of problemen zijn met de functionaliteit van de applicatie.
Soorten UI-tests
Er zijn verschillende UI-tests te overwegen, afhankelijk van de te testen toepassing.
UI-tests hebben het potentieel om veel functies in applicaties te verifiëren, dus het kiezen van het juiste type test kan helpen bij het identificeren van specifieke problemen.
Met andere woorden, er zijn verschillende UI-testmethoden te overwegen, en tools zoals de geautomatiseerde UI-test tools van ZAPTEST, afhankelijk van waar u op wilt testen.
Enkele van de meest voorkomende methoden om functionele en niet-functionele tests te benaderen zijn de volgende:
1. Regressietests
Regressietests zijn een vorm van UI-tests waarbij wordt gekeken naar wijzigingen in de codering van de applicatie of website.
Het zorgt ervoor dat alle functionaliteit van de toepassing is zoals bedoeld na het aanbrengen van wijzigingen in delen van de code.
Het hoeft geen fancy tests te doen, het voert alleen de code uit om er zeker van te zijn dat alle afhankelijkheden en functies op dezelfde manier werken als voor de wijzigingen.
2. Functioneel testen
Bij functionele tests wordt de applicatie gevalideerd om er zeker van te zijn dat deze aan alle functionele eisen voldoet.
Het test alle individuele functies van de toepassing en controleert vervolgens het resultaat om er zeker van te zijn dat de toepassing werkt zoals verwacht.
Dit type UI-test richt zich meestal op black box testing, waarbij niet naar de broncode wordt gekeken. Het controleert meestal zaken als de gebruikersinterface, eventuele bijbehorende API’s, client- en servercommunicatie of beveiliging.
3. Acceptatietests
Acceptatietests, ook wel User Acceptance Testing (UAT) genoemd, zijn een vorm van UI-tests die door de eindgebruiker van de applicatie worden uitgevoerd om het systeem te controleren voordat het in productie wordt genomen.
Dit type UI-tests vindt meestal plaats in de laatste testfasen, nadat de andere gebieden zijn gecontroleerd.
Acceptatietests worden gebruikt om de algemene stroom van de toepassing van begin tot eind te valideren. Het kijkt niet naar oppervlakkige problemen zoals spelfouten of esthetische kwesties. Het gebruikt een aparte testomgeving om de productieomgeving na te bootsen, zodat het klaar is voor de volgende fase.
4. Eenheidstesten
Eenheidstests zijn bedoeld om afzonderlijke componenten van een toepassing te inspecteren om na te gaan of deze werkt zoals bedoeld.
Het wordt meestal uitgevoerd tijdens de codeerfase, dus het is meestal aan ontwikkelaars om dit type UI-test uit te voeren.
Unit testing werkt door een stuk code te scheiden om er zeker van te zijn dat het werkt zoals verwacht. Dit individuele stukje code kan een specifieke module, een functie, een object of een ander individueel onderdeel van de applicatie zijn.
5. Prestatietesten
Bij prestatietests wordt gekeken naar de optimalisatie van de toepassing, waarbij zaken als snelheid, stabiliteit, reactievermogen en schaalbaarheid van de toepassing tijdens het gebruik worden onderzocht.
Dit type UI-test is erop gericht eventuele probleemgebieden in de toepassing of knelpunten in de gegevensstroom op te sporen. De drie belangrijkste gebieden waarnaar wordt gekeken zijn snelheid, schaalbaarheid en stabiliteit van de toepassing.
6. GUI testen
GUI-testprogramma’s inspecteren de grafische gebruikersinterface van een toepassing om na te gaan of alle functies werken zoals verwacht.
Dit omvat het bekijken van de grafische middelen en bedieningselementen van de toepassing, zoals knoppen, werkbalken en pictogrammen. De GUI is wat de eindgebruiker ziet wanneer hij een toepassing gebruikt.
Wat zijn de voordelen van UI-testen?
Er zijn een aantal voordelen verbonden aan UI-testen en het gebruik van tools zoals de UI-testsuite van ZAPTEST, zowel voor de ontwikkelaar als voor de eindgebruiker.
Hieronder volgen enkele van de belangrijkste voordelen van UI-tests:
1. Het verbetert de functionaliteit
Het is belangrijk om applicaties te testen om ervoor te zorgen dat ze werken zoals verwacht, zodat eventuele fouten, bugs of andere problemen kunnen worden aangepakt voordat ze worden vrijgegeven.
Als een applicatie zijn weg vindt naar eindgebruikers en er zitten bugs in, vol met fouten of hij is kapot, dan doet hij niet het werk dat ervan verwacht wordt. Dit levert dan weer te veel problemen op voor de eindgebruikers en zij zullen het waarschijnlijk niet meer gebruiken.
2. Het maakt het gebruik gemakkelijker
UI testing automation tools zijn ook een nuttige manier om de applicatie te optimaliseren en te stroomlijnen.
Zelfs als alle codering werkt zoals het hoort, kan een slecht ontworpen interface eindgebruikers verwarren en snel afschrikken, waardoor de adoptiegraad van de toepassing daalt. UI-tests zijn een goede manier om elementen of ontwerpkeuzes glad te strijken, zodat het gebruik ervan gemakkelijker wordt.
3. Het versterkt de reputatie van de toepassingen
De tijd nemen om de UI goed te testen en hulpmiddelen zoals de testautomatiseringssoftware van ZAPTEST in te zetten, zijn geweldige manieren om de applicatie op te poetsen en zo gebruiksvriendelijk mogelijk te maken.
Wanneer dit correct wordt gedaan, maakt het van de toepassing een grote merkambassadeur, wat de algemene reputatie ervan versterkt. Als de toepassing probleemloos draait en alles doet wat zij moet doen, dan zullen de gebruikers dit waarderen en de toepassing gebruiken.
Wat zijn de belangrijkste uitdagingen van UI-testen?
Hoewel UI-testen een belangrijk onderdeel is van de ontwikkeling van toepassingen, is het niet noodzakelijk een gemakkelijk onderdeel van het proces.
Er zijn een aantal problemen en uitdagingen in verband met gratis UI-test automatiseringssoftware die het een moeilijke klus maken.
Hieronder volgen enkele van de belangrijkste uitdagingen bij UI-testen wanneer gebruik wordt gemaakt van ontoereikende UI-testtools:
1. UI-updates
Applicatieontwikkeling is typisch een iteratief proces waarbij nieuwe mogelijkheden en functies worden toegevoegd gedurende de ontwikkelingscyclus en daarna.
Al deze sporadische veranderingen kunnen het heel moeilijk maken om effectief UI-tests uit te voeren, omdat andere afhankelijkheden en code-interacties veranderen wat wordt getest.
2. Testen die in complexiteit toenemen
Toepassingen en websites zijn nu veel geavanceerder dan een paar jaar geleden. Met al deze extra functionaliteit moeten UI-testtools en UI-automatiseringssoftware meer elementen en processen onderzoeken.
Als gevolg daarvan moeten veel van de hulpmiddelen voor UI-tests worden aangepast aan al deze complexe toevoegingen.
3. Tijdsbeperkingen
Naarmate toepassingen complexer worden, nemen ook de testinstrumenten toe. UI-testscripts worden veel tijdrovender door de enorme hoeveelheid code die moet worden getest. Dit probleem wordt nog groter wanneer de juiste UI-testinstrumenten niet beschikbaar zijn.
4. UI-scripts up-to-date houden
Naarmate de gebruikersinterface verandert en nieuwe functionaliteit wordt ingevoerd, moeten de testscripts worden aangepast om de nieuwe processen te testen. Met elke nieuwe toevoeging wordt dit een grotere uitdaging, omdat de testscripts voortdurend worden bijgewerkt en aangepast aan de nieuwe functionaliteit.
Moet u UI-tests automatiseren?
Bij het bepalen van de beste aanpak voor het testen van toepassingen of UI’s op het web zijn er twee verschillende wegen te overwegen: handmatig testen of geautomatiseerd UI-testen met behulp van geautomatiseerde hulpmiddelen. Zowel handmatig testen als UI-automatisering hebben hun eigen voor- en nadelen, dus het is verstandig beide te overwegen om te zien welke het beste bij de toepassing past.
Wat is handmatige UI-tests?
Bij handmatig testen wordt, in tegenstelling tot UI-automatisering, een tester gebruikt om handmatig alle functies van een applicatie of website te inspecteren.
Hun voornaamste doel is het opsporen van problemen, onregelmatigheden of problemen in de gehele aanvraag. Dit is een bijzonder nuttige optie voor kleinere toepassingen met beperkte elementen, zoals die van vroege versies van toepassingen.
1. Voordelen van handmatige UI-tests
De keuze voor handmatige UI-tests heeft vele voordelen, afhankelijk van de toepassing en het ontwerp ervan.
Hieronder volgen enkele van de voordelen van handmatig UI-testen:
– Bij handmatige UI-tests wordt menselijke intelligentie gebruikt om fouten of problemen op te sporen. Er zijn dingen die geautomatiseerde UI-tests eenvoudigweg niet kunnen bewerkstelligen en er is menselijke interactie, kritisch denken en het menselijke element nodig om alle toepassingsgebreken te vinden.
– Geautomatiseerde tests kunnen vrij tijdrovend zijn, omdat ze meerdere scenario’s voor verschillende functies nabootsen die door een menselijke tester moeten worden geverifieerd. Bij handmatige UI-tests kunnen menselijke testers zich concentreren op het vinden van fouten in plaats van op het opzetten van emulaties.
– Menselijke testers hebben vaak een grondige kennis van de toepassing en brengen vaak ontelbare uren door om aan de interface te wennen. Hierdoor begrijpen zij waar zij op moeten letten wat betreft fouten en blijven zij op de hoogte van de actuele stand van de applicatie.
– Er zijn problemen die misschien niet worden opgemerkt door geautomatiseerde UI-tests, omdat ze geen invloed hebben op de code. Zaken als serverreactietijden kunnen achterblijven, maar kunnen door een geautomatiseerde test gemakkelijk over het hoofd worden gezien. Handmatige UI-tests nemen dit probleem weg, omdat de menselijke gebruiker deze problemen onmiddellijk opmerkt.
– Handmatig UI-testen is de meest nauwkeurige emulatie van de gebruikerservaring, omdat u een situatie opzet die weerspiegelt hoe de eindgebruiker met de toepassing zal omgaan. Dit creëert een realistische context om problemen te vinden die vaak door eindgebruikers worden gevonden, maar misschien door geautomatiseerde UI-tests worden gemist.
2. Beperkingen van handmatige UI-tests
Er zijn ook beperkingen aan het handmatig testen van UI die moeten worden overwogen voordat een beslissing wordt genomen over de beste testaanpak voor uw toepassing.
Enkele beperkingen van handmatige UI-tests zijn de volgende:
– Het duurt veel langer om handmatige tests uit te voeren dan geautomatiseerde UI-tests, vooral wanneer moderne hulpmiddelen zoals hyperautomation worden gebruikt. Scripts voor geautomatiseerde tests kunnen veel sneller worden uitgevoerd dan enige vorm van menselijke input, dus kiezen voor handmatige web UI-tests voegt extra uren toe aan het schema.
– Omdat het uiteindelijk een menselijk proces is, zijn handmatige web UI-tests vatbaar voor menselijke fouten. Gemiste bugs door een gebrek aan focus of afleiding kunnen voorkomen bij handmatige UI-tests, wat tot problemen kan leiden. Geautomatiseerde UI-tests daarentegen halen het menselijke element uit het proces, waardoor ze veel minder vatbaar zijn voor dit soort problemen. Dit geldt met name voor de nieuwste vormen van UI geautomatiseerd testen, zoals robotische procesautomatisering.
– Het eigenlijke proces van het registreren van gevonden fouten duurt veel langer, wat het moeilijk kan maken om eventuele wijzigingen op te sporen. Geautomatiseerde UI-tests zijn hier een betere aanpak, omdat er alleen een update nodig is als er een nieuwe functie wordt geïmplementeerd.
– Voor het handmatig testen van UI is een grondige kennis van de applicatie nodig om competent te kunnen testen op problemen. Als gevolg daarvan hebben menselijke testers een bepaald kennisniveau nodig om effectief te kunnen testen. Geautomatiseerd testen vereist dit kennisniveau niet.
3. Opname- en herhalingstests
Record & replay testing is een vorm van codeloze UI-tests waarmee u tests kunt uitvoeren zonder diepgaande programmeerkennis. Het gebruikt functionaliteit om handmatige acties die in de applicatie worden uitgevoerd vast te leggen voordat ze als testpatroon worden opgeslagen.
Hierdoor kan de UI-test steeds opnieuw worden uitgevoerd zonder menselijke tussenkomst.
4. Handmatig vs. record & replay vs. automatiseringstesten
Bij de keuze tussen deze drie soorten UI-tests is het belangrijk rekening te houden met de omvang en de schaal van de toepassing en de beschikbare middelen.
Handmatige UI-tests zijn het gemakkelijkst op te zetten en te gebruiken, maar er worden veel eisen aan gesteld, zoals goede kennis van de applicatie bij de tester. Het is ook moeilijk om handmatige UI-tests uit te voeren als je een applicatie voortdurend bijwerkt.
UI-testautomatiseringstools zoals die van Zaptest zijn een goede optie als je regelmatig updates van de applicatie gaat uitvoeren, en na verloop van tijd loont het de moeite.
Record & replay komt in beeld om de kloof tussen de twee soorten UI-tests te overbruggen. Het biedt een basisniveau van UI-automatisering, maar vereist nog steeds menselijke input om het in werking te stellen.
Wat test u bij het uitvoeren van UI-tests?
Waarop u test bij het uitvoeren van UI-tests met hulpmiddelen zoals de UI-testsoftware van ZAPTEST, hangt af van wat de applicatie bevat.
Het volgt echter de functionaliteit van de toepassing. Als de toepassing bijvoorbeeld een kassapagina heeft, omvat UI-testen zaken als het testen van de ‘koop nu’-knop.
Hoewel de feitelijke processen om op te testen per toepassing verschillen, zijn er een aantal algemene UI-dingen om te testen, zoals:
1. Fouten in gegevenstypes
Deze UI-test zorgt ervoor dat het juiste type gegevens in de juiste velden werkt. Bijvoorbeeld tekst voor namen zonder de mogelijkheid om nummers te gebruiken. Als de UI-tester numerieke waarden kan invoeren onder het naamveld, dan is er iets mis.
2. Problemen met de veldbreedte
Dit wordt gebruikt om het aantal tekens voor bepaalde velden, zoals postcodes, te beperken. Als de toepassing het aantal tekens van deze velden niet beperkt, kan dit leiden tot ongeldige invoer door de eindgebruiker.
3. Knoppen
Deze UI-tests zorgen ervoor dat knoppen correct functioneren, zodat bijvoorbeeld een knop voor de volgende pagina de eindgebruiker naar de volgende pagina leidt. Er zijn veel verschillende soorten knoppen met verschillende doelen, dus het is belangrijk dat ze doen wat ze moeten doen om een functionele toepassing te maken.
4.Tabel scrollen
Als er tabellen met gegevens in de toepassing aanwezig zijn, zorgt table scrolling ervoor dat u door de gegevens kunt scrollen terwijl de koppen zichtbaar blijven.
Als dit niet werkt, worden de gegevens verwarrend voor de eindgebruiker.
5. Foutmeldingen
In het geval van een applicatiecrash of -fout is het belangrijk om de foutenlogs te testen om er zeker van te zijn dat ze accurate output leveren voor bugrapporten.
Zonder nauwkeurige foutenrapportage en foutenlogboeken is er geen goede manier om te bepalen wat het probleem veroorzaakt of hoe het moet worden opgelost.
Hoe voer je een UI-test (GUI) uit?
Om je een goed idee te geven van hoe je een UI – of GUI – test uitvoert, maken we een voorbeeld om te bekijken.
Laten we zeggen dat we een formulierpagina gaan testen in een applicatie voor het registreren van een account. Er zijn meerdere UI-elementen om op te testen op deze pagina, die gelabeld zijn met TC-X (waarbij TC staat voor testgeval en de X voor het elementnummer).
Hieronder volgt een lijst van de beschikbare TC’s om op te testen:
TC-1: Merklogo bovenaan het scherm
– Dit moet worden getest om na te gaan of het de juiste positie, het juiste lettertype en het juiste paginalabel weergeeft.
TC-2: Registreer uw account
– Dit zou moeten testen of de paginakop juist is.
– Het moet ook controleren of het juiste lettertype wordt weergegeven.
TC-3: Voornaamveld
– Dit zou de juiste uitlijning en positie van het tekstvak moeten testen.
– Het moet ook de veldlabels testen en controleren of het geldige gegevens accepteert en ongeldige gegevens weigert.
TC-4: Achternaamveld
– Dit zou de juiste uitlijning en positie van het tekstvak moeten testen.
– Het moet ook de veldlabels testen en controleren of het geldige gegevens accepteert en ongeldige gegevens weigert.
TC-5: Gebruikersnaamveld
– Dit moet testen welke foutmelding wordt weergegeven bij het invoeren van beperkte tekens.
– Hij moet ook controleren of de foutmelding geldig en juist is.
TC-6: Wachtwoordveld
– Dit moet de veldlabels testen om er zeker van te zijn dat het geldige tekens accepteert en ongeldige weigert.
– Het moet ook de uitlijning en positie van het tekstvak testen.
TC-7: knop Volgende pagina
– Dit zou moeten testen of het indienen van het formulier werkt zoals bedoeld.
– Het moet ook de positionering van de knop controleren en ervoor zorgen dat deze leesbaar is voor de gebruiker.
UI Test Plan – Wat is het?
Een UI-testplan is een document dat deel uitmaakt van het testproces voor toepassingen.
In het UI-testplan wordt de belangrijkste informatie over de applicatie en de bijbehorende testactiviteiten opgesplitst.
Het maken van een testplan is normaal gesproken een van de eerste stappen die u neemt bij het testen van toepassingen, omdat het de basis legt voor de testmethoden en de beoogde resultaten.
Het is een nuttig document dat degenen buiten het testteam een beter idee geeft van wat er in het proces gebeurt.
Hoe schrijf je een UI-testplan?
UI-testplannen bieden uitstekende begeleiding en instructie voor UI-testers, dus het goed krijgen ervan helpt echt bij het testen en inspecteren van toepassingen.
Bekijk de onderstaande stappen om te leren hoe je een UI-testplan schrijft:
1. Neem belangrijke informatie op over voor de UI-tests
Een UI-testplan bevat alle belangrijke informatie die nodig is om het testen van een applicatie uit te voeren. Een deel van deze informatie omvat het volgende:
– De professionals die nodig zijn voor het testen, hun rol en vaardigheden.
– De totale tijd die nodig is om de toepassing te testen.
– De testtechnieken die op de test worden toegepast.
– Alle middelen die nodig zijn voor het testen, zoals specifieke hardware, documentatie of instrumenten.
– Een opsplitsing van de beoogde testomgevingen, zoals mobiele apparaten, een specifiek besturingssysteem of browsers.
– De algemene doelstellingen van het testproces.
2. Rooktesten
Vervolgens kunt u rooktesten gebruiken om een UI-testplan op te stellen. Smoke testing is een nuttige manier om basisproblemen en bugs in de applicatie op te sporen, maar het zoekt niet te diep naar problemen.
Het is een techniek die het meest geschikt is voor het testen van de bovenste laag van de toepassing, zodat opvallende problemen gemakkelijk kunnen worden opgespoord.
3. Saniteitstests
Om dieper in de applicatie te graven en minder duidelijke bugs en fouten te vinden, is sanity testing een geweldige techniek om uit te rollen voor UI-tests.
Saniteitstests zijn bedoeld om nieuwe of gewijzigde codering te controleren op overeenstemming met de applicatie-eisen.
Het verschilt van smoke testing door veel uitgebreider te zijn met UI testing, waardoor dieper in de functionaliteit van de applicatie kan worden gekeken.
Nadat een toepassing een rooktest heeft doorstaan, voegt de saniteitstest een extra inspectieniveau toe.
UI-testscenario’s
Om ervoor te zorgen dat de applicatie op meerdere gebieden en in meerdere interacties werkt zoals bedoeld, is het belangrijk om verschillende UI-testscenario’s uit te voeren.
Hieronder wordt uiteengezet wat UI-testscenario’s zijn, met een voorbeeld.
1. Wat zijn UI-testscenario’s?
Een UI-testscenario is een manier om documentatie op te stellen voor meerdere use cases in een applicatie.
Een UI-testscenario wordt gebruikt om de specifieke acties te beschrijven die een gebruiker kan ondernemen tijdens het gebruik van de toepassing.
In sommige gevallen wordt ook een scenario beschreven dat een gebruiker zou kunnen ervaren tijdens het gebruik van de toepassing.
UI-testscenario’s zijn nuttig omdat zij nagaan of de functionaliteit binnen een toepassing werkt zoals verwacht. Het vergt een grondige kennis van de toepassing en input van klanten en ontwikkelaars om bruikbare scenario’s te genereren.
2. Voorbeeld van UI-testscenario’s
Neem als voorbeeld een testscenario voor de inlogpagina van een applicatie. Een UI-testscenario hiervoor zal trachten de volgende vragen te beantwoorden:
– Kunnen gebruikers inloggen op het platform met de juiste referenties?
– Wat is het gevolg van het gebruik van onjuiste gegevens om in te loggen?
– Wat gebeurt er als u een geldige gebruikersnaam gebruikt, maar een ongeldig wachtwoord?
– Wat gebeurt er als u de velden leeg laat en probeert in te loggen?
– Als er een knop ‘wachtwoord vergeten’ is, wat gebeurt er dan als je erop klikt?
– Werken alle links op de pagina zoals bedoeld?
Het beantwoorden van deze vragen helpt UI-testers bij het identificeren van delen van de applicatie die niet naar behoren werken.
Ook wordt gecontroleerd of alle beschikbare acties een verwacht resultaat opleveren, zoals inloggen met de juiste referenties.
UI-testgevallen
Om afzonderlijke aspecten van een UI-testscenario te bekijken, worden testgevallen gebruikt om afzonderlijke kenmerken van stukken functionaliteit in een toepassing op te splitsen.
Hieronder volgt een samenvatting van wat UI-testgevallen zijn, met voorbeelden.
1. Wat zijn UI Test Cases?
Een UI-testcase is een reeks acties die worden uitgevoerd om een specifieke functie of een stuk functionaliteit binnen een applicatie te verifiëren.
UI-testgevallen splitsen teststappen, gegevens, precondities en postcondities op voor specifieke scenario’s en controleren ook de vereisten.
Een UI-testcase bevat meestal zeer specifieke variabelen om diepgaande tests op een individueel niveau mogelijk te maken. UI Testers vergelijken dan de werkelijke resultaten met het verwachte resultaat om er zeker van te zijn dat de applicatie werkt volgens de vereisten.
2. Voorbeelden van UI- & GUI-testgevallen
Om u te helpen UI en GUI testgevallen beter te begrijpen, bekijk de onderstaande voorbeelden die testgevallen zijn voor het testscenario dat kijkt naar de functionaliteit van een inlogscherm:
– Controleer het gedrag van het systeem bij het invoeren van geldige referenties.
– Controleer het gedrag van het systeem wanneer een ongeldige e-mail maar een geldig wachtwoord wordt gebruikt.
– Controleer het gedrag van het systeem wanneer een geldig e-mailadres maar een ongeldig wachtwoord wordt gebruikt.
– Controleer het gedrag van het systeem wanneer een ongeldig e-mailadres en wachtwoord worden gebruikt.
– Controleer het gedrag van het systeem wanneer de velden leeg blijven.
– Controleer de ‘wachtwoord vergeten’ link om te zien of deze zich gedraagt zoals verwacht.
– Controleer het gedrag van het systeem wanneer de knop “hou me aangemeld” is aangevinkt.
– Controleer het gedrag van het systeem wanneer een ongeldig telefoonnummer wordt ingevoerd.
Al deze voorbeelden zijn dus individuele UI-testgevallen.
In tegenstelling tot het testscenario, dat het gehele proces omvat, kijken testgevallen naar de afzonderlijke functies. Met andere woorden, elk voorbeeld hierboven is een UI-testgeval, waarbij de hele lijst als testscenario wordt beschouwd.
UI Test Scripts
Voor een nog gedetailleerder overzicht van het testen van toepassingen worden UI-testscripts gemaakt om testers meer informatie te geven over testgevallen en scenario’s.
Hieronder volgt een samenvatting van wat UI-testscripts zijn en hoe je ze schrijft.
1. Wat zijn UI Test Scripts?
UI-testscripts zijn zeer gedetailleerde beschrijvingen van tests die op een applicatie worden uitgevoerd, meestal regel voor regel.
Ze zijn zeer specifiek van aard, met veel details over de gebruikte testgevallen, gegevens en verwachte functionaliteit van de toepassing.
Eventuele resultaten van testgevallen worden ook opgenomen in testscripts om de informatie rijker te maken.
2. Hoe UI Test scripts te schrijven
UI-testscripts zijn ongecompliceerd, omdat ze eenvoudigweg de testgevallen beschrijven.
Zolang u de volgende informatie erin opneemt, zou u veel waarde uit uw UI-testscripts moeten kunnen halen:
– ID van het testscript: Dit is de unieke identificatiecode voor het testscript.
– Titel: De titel van het testscript.
– Test case ID: Dit is de ID van het testgeval waarvoor u een script maakt.
– Vereisten: Dit zijn de specificaties van de toepassing van de hardware die nodig is om de testgevallen uit te voeren.
– Procedure: Dit zijn de stappen die genomen worden om verder te gaan met de test.
– Resultaat: Dit is de output en het eindresultaat van de test.
– Status: Dit is een indicatie van het succes van het testscript – is het geslaagd of mislukt?
– Foutcode: Als er een probleem is opgetreden, geeft de foutcode aan wat het probleem was.
Checklist voor uw UI-tests
Nu u klaar bent om aan de slag te gaan met UI-tests, kunt u onderstaande checklist gebruiken om uw eigen tests te maken:
1. Controleer de basisfunctionaliteit
Functioneel testen is een geweldige manier om zaken als visuele bugs of glitches op het platform te vinden.
Zorg ervoor dat u in dit stadium zaken als biometrische gegevens, eventuele berichten en informatie over het applicatiegeheugen opneemt.
2. Controleer cross-platform compatibiliteit
Om problemen als apparaatfragmentatie te voorkomen, waardoor bepaalde gebruikers de toepassing niet kunnen gebruiken, is het nuttig om platformoverschrijdende compatibiliteitscontroles uit te voeren.
Dit omvat het controleren van de toepassing op verschillende schermresoluties.
Het is een goed idee om te kijken naar zowel native als hybride applicatie compatibiliteit op mobiele apparaten zoals Android en iOS.
3. Controleer de compatibiliteit met verschillende schermformaten
Er zijn veel verschillende schermformaten die eindgebruikers zouden kunnen proberen te gebruiken met de applicatie, dus het is belangrijk om de UI daarvoor te testen.
UI-reactietests kunnen het best worden uitgevoerd op de meest recente apparaten om mogelijke problemen aan te pakken. Vergeet ook niet te testen in zowel liggende als staande modus.
4. Prestaties en schaalbaarheid controleren
Wanneer een toepassing schaalbaar is, kan zij uitstekende prestaties leveren op verschillende platforms.
Testen van verschillende belastingsniveaus, verkeer en andere eindgebruikersscenario’s om de prestaties en schaalbaarheid van de toepassing te beoordelen.
Dit kan worden gedaan met behulp van parallelle tests, waarbij geautomatiseerde UI-tests als robotic process automation over meerdere omgevingen worden gebruikt.
5. Controleer de toegankelijkheid van de toepassing
Toegankelijkheidstesten zorgen ervoor dat specifieke functies die bedoeld zijn om eindgebruikers te helpen, werken zoals verwacht. Controleer hier zaken als lettergrootte, schermleesmodus en zoomopties.
6. Kleuren en tekst controleren
Toepassingen moeten kleuren op een specifieke manier weergeven, dus het is belangrijk dit te controleren door kleurenschema’s te testen.
Dit omvat zaken als de kleur van een hyperlink of andere lettertypes. Het is ook nuttig om de tekst te controleren op spelling, lettergrootte en uitlijning.
7. Beoordelen van de navigatiesnelheid
Zorg ervoor dat de UI van de toepassing soepel loopt, zonder haperingen. Dingen zoals het laadscherm voor headers zijn een goede plaats om te zoeken naar vertraging.
