Testning av användargränssnitt är viktigare än någonsin tidigare tack vare den globala ökningen av webbplatser och applikationer. Om du lanserar en ny programvara eller webbsida är det viktigt att du får användargränssnittet rätt för att balansera funktionalitet och estetik.
Det är mycket som krävs för att skapa ett övertygande användargränssnitt, och UI-testning fungerar som ett lackmusprov för att avgöra om gränssnittet uppfyller alla krav eller inte.
I den här artikeln går vi igenom alla viktiga områden som rör UI-testning, från att definiera vad ett UI är till de bästa sätten att testa ditt UI.
UI vs. GUI: Att reda ut förvirringen
Till att börja med ska vi försöka reda ut all förvirring kring begreppen UI och GUI. Nedan följer en uppdelning av vad dessa två termer betyder och vad de skiljer sig åt:
1. Vad är testning av användargränssnitt?
Användargränssnittet är den plattform som du använder för att interagera med en viss programvara. Användargränssnittet är den plats där du kan ange instruktioner, mata in data eller visa information från en skärm eller monitor.
Det finns många olika typer av användargränssnitt, inklusive grafiska användargränssnitt (GUI) och kommandoradsgränssnitt som bara visar kod och text.
2. Vad är ett grafiskt användargränssnitt (GUI)?
Det grafiska användargränssnittet (GUI) är en typ av användargränssnitt som de flesta känner till. Det är en typ av gränssnitt som använder visuella element för att hjälpa oss att interagera med funktioner i systemet.
Du kan till exempel använda menyer eller verktygsfält med ikoner för att hjälpa dig att navigera i ett system. Även text fungerar bra i grafiska gränssnitt som ett sätt att guida användaren genom en funktion, till exempel genom att klicka på ”file” när du vill öppna eller spara ett dokument.
3. UI vs. GUI
För att hjälpa dig att bättre förstå dessa två former av datorinteraktion kan du ta en titt på den direkta jämförelsen mellan UI och GUI nedan:
UI:
– En förkortning av användargränssnitt
– Det är en typ av plattform som gör det möjligt för användare att interagera med enheter.
– Det är en form av interaktion mellan människa och maskin.
– Den används av alla och fungerar ofta i bakgrunden, så att du inte vet att du använder den.
– Vanliga exempel är MS-DOS eller Unix
GUI:
– En förkortning av grafiskt användargränssnitt.
– Det är en typ av plattform som använder grafik för att hjälpa användarna att navigera i en enhet.
– Det är en underklass till UI
– Den används vanligtvis av vanliga användare, t.ex. konsumenter.
– Vanliga exempel är Windows 10, iOS och Android.
Vad är testning av användargränssnitt (UI)?
Testning av användargränssnitt (UI), ibland kallat GUI-testning beroende på sammanhanget, är en serie åtgärder som används för att mäta prestanda och övergripande funktionalitet hos en applikations visuella element. Det handlar om att verifiera och validera olika funktioner i användargränssnittet och se till att det inte finns några oväntade resultat, defekter eller buggar.
UI-testning med hjälp av verktyg som ZAPTEST används i första hand för att kontrollera saker som användbarhet, funktionalitet och prestanda för UI för att se till att det är lämpligt för ändamålet.
I vissa fall kontrolleras även om det finns saker som överensstämmelse eller visuell enhetlighet med systemets övergripande designkoncept.
När och varför behöver du test av användargränssnitt?
UI-testning är oftast effektivast innan programmet släpps i produktion. Detta för att se till att slutanvändaren får den bästa upplevelsen med så få fel och brister som möjligt.
Slutanvändare är inte de bästa testarna av programvara, så det är viktigt att reda ut eventuella problem innan de når dem.
UI-testning är ett användbart sätt att bedöma hur programmet hanterar vissa åtgärder, t.ex. att använda tangentbord och mus för att interagera med menyer. Den hjälper till att kontrollera de visuella elementen i programmet för att se till att de visas korrekt.
UI-testning är också ett bra sätt att mäta prestanda och se till att det inte finns några buggar eller problem med applikationens funktionalitet.
Typer av UI-tester
Det finns en rad olika UI-tester att överväga beroende på vilken applikation som ska testas.
UI-tester har potential att verifiera många funktioner i olika applikationer, så att välja rätt testtyp kan hjälpa till att identifiera specifika problem.
Med andra ord finns det olika metoder för UI-testning och verktyg som ZAPTEST:s automatiserade verktyg för UI-testning som du kan använda beroende på vad du vill testa.
Några av de vanligaste metoderna för funktionell och icke-funktionell testning är följande:
1. Regressionstestning
Regressionstestning är en typ av UI-testning där man undersöker eventuella ändringar i kodningen av programmet eller webbplatsen.
Den säkerställer att alla funktioner i programmet fungerar som avsett efter att ändringar har gjorts i delar av koden.
Den behöver inte göra några avancerade tester, utan kör bara koden för att se till att alla beroenden och funktioner fungerar på samma sätt som de gjorde innan ändringarna gjordes.
2. Funktionell testning
Funktionell testning syftar till att validera applikationen för att se till att den uppfyller alla funktionella krav.
Den testar alla enskilda funktioner i programmet och verifierar sedan resultatet för att se till att det fungerar som förväntat.
Denna typ av UI-testning fokuserar vanligtvis på black box-testning, där man inte tittar på någon av källkoderna. Den brukar kontrollera saker som användargränssnittet, eventuella tillhörande API:er, kommunikation mellan klient och server eller säkerhet.
3. Godkännandeprovning
Acceptanstestning, ibland kallad User Acceptance Testing (UAT), är en form av UI-testning som utförs av slutanvändaren av applikationen för att verifiera systemet innan det övergår till produktion.
Denna typ av UI-testning förekommer oftast i slutfasen av testningen när de andra områdena har kontrollerats.
Acceptanstestning används för att validera applikationens övergripande flöde från början till slut. Den tittar inte på ytliga frågor som stavfel eller estetiska problem. En separat testmiljö används för att efterlikna produktionsmiljön och säkerställa att den är redo att gå vidare till nästa fas.
4. Testning av enheter
Enhetstestning syftar till att inspektera enskilda komponenter i ett program för att kontrollera att det fungerar som det är tänkt.
Det utförs vanligtvis under kodningsfasen, så det är vanligtvis utvecklarna som utför denna typ av UI-test.
Enhetstestning fungerar genom att separera en kodbit för att se till att den fungerar som förväntat. Denna enskilda kodbit kan vara en specifik modul, en funktion, ett objekt eller någon annan enskild del av programmet.
5. Prövning av prestanda
Prestandatestning syftar till att utvärdera optimeringen av applikationen och undersöker saker som applikationens hastighet, stabilitet, responsivitet och skalbarhet när den används.
Denna typ av UI-testning syftar till att hitta eventuella problemområden i applikationen eller flaskhalsar i dataflödet. De tre viktigaste områdena är snabbhet, skalbarhet och stabilitet i applikationen.
6. Testning av GUI
Verktyg för GUI-testning inspekterar det grafiska användargränssnittet i ett program för att se till att alla funktioner fungerar som förväntat.
Detta innebär att man tittar på programmets grafiska tillgångar och kontroller, t.ex. knappar, verktygsfält och ikoner. GUI är det som slutanvändaren interagerar med och ser när han eller hon använder ett program.
Vilka är fördelarna med UI-testning?
Det finns ett antal fördelar med UI-testning och användning av verktyg som ZAPTESTs UI-testningssvit, både för utvecklaren och slutanvändaren.
Nedan följer några av de viktigaste fördelarna med UI-testning:
1. Det förbättrar funktionaliteten
Det är viktigt att testa applikationer för att se till att de fungerar som förväntat, så att eventuella problem, buggar eller andra problem kan åtgärdas innan de släpps.
Om ett program når slutanvändarna och det är buggigt, fullt av fel eller trasigt kommer det inte att göra det jobb som förväntas av det. Detta skapar i sin tur för många problem för slutanvändarna och de kommer sannolikt att sluta använda den.
2. Det gör det lättare att använda
Automatiseringsverktyg för UI-testning är också ett bra sätt att optimera och effektivisera applikationen.
Även om all kodning fungerar som den ska kan ett dåligt utformat gränssnitt förvirra slutanvändarna och snabbt stänga av dem, vilket minskar användningsgraden för applikationen. UI-testning är ett utmärkt sätt att förbättra element eller designval så att det blir lättare att använda den.
3. Det stärker ansökningarnas rykte.
Att ta sig tid att utföra UI-testning på rätt sätt och använda verktyg som ZAPTEST:s programvara för automatiserad testning är bra sätt att finslipa applikationen och göra den så användarvänlig som möjligt.
När det görs på rätt sätt blir applikationen en bra varumärkesambassadör, vilket ökar dess allmänna rykte. Om programmet fungerar felfritt och gör allt som det ska göra kommer användarna att uppskatta detta och använda programmet.
Vilka är de största utmaningarna med UI-testning?
Även om UI-testning är en viktig del av programutvecklingen är det inte nödvändigtvis en enkel del av processen.
Det finns ett antal problem och utmaningar i samband med gratis programvara för automatisering av UI-tester som gör det till ett svårt jobb.
Nedan följer några av de största utmaningarna i samband med UI-testning när man använder otillräckliga UI-testverktyg:
1. Uppdateringar av användargränssnittet
Programutveckling är vanligtvis en iterativ process som innebär att nya funktioner införs under hela utvecklingscykeln och även därefter.
Alla dessa sporadiska ändringar kan göra det ganska svårt att utföra UI-tester på ett effektivt sätt eftersom andra beroenden och kodinteraktioner ändrar det som testas.
2. Testning som växer i komplexitet
Applikationer och webbplatser är mycket mer sofistikerade nu än för bara några år sedan. Med alla dessa ytterligare funktioner måste UI-testverktyg och UI-automatiseringsprogramvara undersöka fler element och processer.
Därför måste många av verktygen för UI-testning anpassas för att kunna hantera alla dessa komplexa tillägg.
3. Tidsbegränsningar
I takt med att applikationerna blir allt mer komplexa ökar också verktygen som används för testning. Skripten för UI-testning blir allt mer tidskrävande på grund av den stora mängden kod som måste testas. Problemet förvärras när det inte finns rätt verktyg för UI-testning.
4. Håller UI-skript uppdaterade
När användargränssnittet ändras och nya funktioner införs måste testskript anpassas för att testa de nya processerna. Detta blir en större utmaning för varje nytt tillägg, eftersom testskript ständigt uppdateras och justeras för att passa in i den nya funktionaliteten.
Bör du automatisera UI-testning?
När det gäller att bestämma sig för det bästa tillvägagångssättet för testning av användargränssnitt för applikationer eller webben finns det två olika vägar att överväga – manuell testning eller automatiserad testning av användargränssnitt med hjälp av automatiserade verktyg. Både manuell testning och automatisering av användargränssnittet har sina egna fördelar och nackdelar, så det är klokt att överväga båda för att se vad som passar bäst för applikationen.
Vad är manuell UI-testning?
Manuell testning, till skillnad från UI-automatisering, innebär att en testare manuellt interagerar med och inspekterar alla funktioner som finns i ett program eller på en webbplats.
Deras främsta uppgift är att se om det finns några frågor, oegentligheter eller problem i den övergripande ansökan. Detta är ett särskilt användbart alternativ för mindre tillämpningar med begränsade element, t.ex. i tidiga versioner av tillämpningar.
1. Fördelar med manuell testning av användargränssnittet
Det finns många fördelar med att välja manuell testning av användargränssnittet, beroende på applikationen och dess utformning.
Nedan följer några av fördelarna med manuell testning av användargränssnittet:
– Manuell testning av användargränssnittet innebär att mänsklig intelligens ingår i testningen för att leta efter fel eller problem. Det finns saker som automatiserad UI-testning helt enkelt inte kan åstadkomma, och det krävs mänsklig interaktion, kritiskt tänkande och mänsklig del för att hitta alla brister i programmet.
– Automatiserade tester kan vara ganska tidskrävande eftersom de återskapar flera scenarier för olika funktioner som måste kontrolleras av en mänsklig testare. Manuell testning av användargränssnitt gör att mänskliga testare kan fokusera på att hitta fel i stället för att sätta upp simuleringar.
– Mänskliga testare tenderar att ha en ingående kunskap om programmet och tillbringar ofta otaliga timmar med att vänja sig vid gränssnittet. Det är tack vare detta som de förstår vad de ska leta efter när det gäller fel, samtidigt som de kan hålla sig uppdaterade om applikationens aktuella status.
– Det finns problem som kanske inte upptäcks av automatiserad UI-testning eftersom det inte påverkar koden. Saker som serverns svarstider kan vara eftersatta, men de kan lätt förbises av ett automatiserat test. Manuell testning av användargränssnittet tar bort detta problem eftersom den mänskliga användaren lägger märke till dessa problem omedelbart.
– Manuell UI-testning är den mest exakta emuleringen av användarupplevelsen, eftersom du skapar en situation som speglar hur slutanvändaren kommer att interagera med programmet. Detta skapar ett verkligt sammanhang för att hitta problem som ofta upptäcks av slutanvändare, men som kanske missas av automatiserade UI-tester.
2. Begränsningar med manuell UI-testning
Det finns också begränsningar för manuell testning av användargränssnittet som bör beaktas innan du fattar ett beslut om vilken testmetod som är bäst för din applikation.
Några av begränsningarna med manuella UI-tester är följande:
– Det tar mycket längre tid att utföra manuell testning än automatiserad UI-testning, särskilt när man använder moderna verktyg som hyperautomation. Skript för automatiserad testning kan köras mycket snabbare än någon form av mänsklig input, så om du väljer manuell testning av användargränssnittet på webben läggs ytterligare timmar till schemat.
– Eftersom det i slutändan är en mänsklig process är manuell testning av användargränssnittet känsligt för mänskliga fel. Missade fel på grund av bristande fokus eller distraktion kan inträffa vid manuell testning av användargränssnittet, vilket kan leda till problem. Automatiserad UI-testning tar bort den mänskliga faktorn från processen, vilket gör den mycket mindre benägen att drabbas av dessa typer av problem. Detta gäller särskilt de senaste typerna av automatiserad testning av användargränssnittet, t.ex. automatisering av robotprocesser.
– Själva loggningen av eventuella fel tar mycket längre tid, vilket kan göra det svårt att spåra eventuella ändringar när de görs. Automatiserad UI-testning är ett bättre tillvägagångssätt här eftersom det bara krävs en uppdatering om en ny funktion implementeras.
– Manuell UI-testning kräver ingående kunskap om programmet för att kunna testa problem på ett kompetent sätt. Som ett resultat av detta krävs det en viss kunskapsnivå av mänskliga testare innan de kan testa effektivt. Automatiserad testning kräver inte denna kunskapsnivå.
3. Inspelning och uppspelning av testning
Testning med inspelning och uppspelning är en form av kodlös UI-testning som gör att du kan köra tester utan djupa kunskaper i programmering. Den använder funktionalitet för att registrera manuella åtgärder som utförs i programmet innan den sparas som ett testmönster.
Detta gör att UI-testet kan köras om och om igen utan mänsklig inblandning.
4. Manuell testning vs. inspelning och uppspelning vs. automatiserad testning
När man väljer mellan dessa tre typer av UI-testning är det viktigt att ta hänsyn till applikationens omfattning och skala samt tillgängliga resurser.
Manuell UI-testning är lättast att sätta upp och använda, men den ställer många krav, t.ex. att testaren ska ha god kunskap om programmet. Det är också svårt att fortsätta med manuell UI-testning om du ständigt uppdaterar en applikation.
Verktyg för automatisering av användargränssnittstester, som de som Zaptest erbjuder, är ett bra alternativ om du ska göra regelbundna uppdateringar av programmet, och med tiden lönar det sig.
Inspelning och uppspelning kommer in i bilden för att överbrygga klyftan mellan de två typerna av UI-testning. Den erbjuder en grundläggande nivå av automatisering av användargränssnittet, men kräver fortfarande mänsklig input för att aktiveras.
Vad testar du när du utför UI-tester?
Vad du testar när du utför UI-tester med hjälp av verktyg som ZAPTEST:s UI-testprogramvara kommer att variera beroende på vad programmet innehåller.
Den tenderar dock att följa programmets funktionalitet. Om applikationen till exempel har en kassasida skulle UI-testning innefatta saker som att testa knappen ”Köp nu”.
Även om de faktiska processerna som ska testas varierar från applikation till applikation finns det ett antal allmänna saker som ska testas, t.ex:
1. Fel i datatyper
Detta UI-test säkerställer att rätt typ av data används i rätt fält. Till exempel text för namn utan möjlighet att använda siffror. Om UI-testaren kan ange numeriska värden i namnfältet är det något som är fel.
2. Frågor om fältets bredd
Detta används för att begränsa antalet tecken för vissa fält, t.ex. postnummer. Om programmet inte begränsar antalet tecken i dessa fält kan det leda till ogiltiga inmatningar från slutanvändaren.
3. Knappar
Dessa UI-tester säkerställer att knapparna fungerar korrekt, så att t.ex. en knapp för nästa sida leder slutanvändaren till nästa sida. Det finns många olika typer av knappar med olika syften, så det är viktigt att de gör det de ska för att skapa ett funktionellt program.
4.Tabellrullning
Om det finns tabeller med data i programmet säkerställer tabellrullning att du kan rulla genom data samtidigt som rubrikerna är synliga.
Om detta inte fungerar blir uppgifterna förvirrande för slutanvändaren.
5. Felrapporter
I händelse av en programkrasch eller ett programfel är det viktigt att testa felloggarna för att se till att de ger korrekta resultat för felrapporter.
Utan noggrann felrapportering och felloggar finns det inget bra sätt att avgöra vad som orsakar problemet eller hur det ska åtgärdas.
Hur utför du ett UI-test (GUI-test)?
För att du ska få en bra uppfattning om hur man utför ett UI- eller GUI-test skapar vi ett exempel som du kan titta på.
Låt oss säga att vi ska testa en formulärsida i ett program för att registrera ett konto. Det finns flera UI-element att testa på den här sidan, som är märkta TC-X (där TC står för testfall och X anger elementets nummer).
Nedan finns en lista över tillgängliga TC:s att testa för:
TC-1: Varumärkeslogotyp högst upp på skärmen
– Detta bör testas för att kontrollera att det visar rätt position, teckensnittstyp och sidbeteckning.
TC-2: Registrera ditt konto
– Detta bör kontrollera att sidans rubrik är korrekt.
– Den ska också kontrollera att rätt typsnitt visas.
TC-3: Fältet för förnamn
– Detta bör testa om textrutan är rätt placerad och rätt inriktad.
– Den bör också testa fälttetiketterna och kontrollera att den accepterar giltiga och vägrar ogiltiga uppgifter.
TC-4: Fältet för efternamn
– Detta bör testa om textrutan är rätt placerad och rätt inriktad.
– Den bör också testa fälttetiketterna och kontrollera att den accepterar giltiga och vägrar ogiltiga uppgifter.
TC-5: Fältet för användarnamn
– Detta bör testa vilket felmeddelande som visas när du anger begränsade tecken.
– Den bör också kontrollera att felmeddelandet är giltigt och korrekt.
TC-6: Fältet för lösenord
– Detta bör testa fälttetiketterna för att se till att de accepterar giltiga tecken och avvisar ogiltiga tecken.
– Den bör också testa textrutans inriktning och position.
TC-7: Nästa sida-knappen
– På så sätt kan du testa att formuläret fungerar som det är tänkt.
– Den ska också kontrollera knappens placering och se till att den är läsbar för användaren.
UI-testplan – Vad är det?
En testplan för användargränssnittet är ett dokument som är en del av testprocessen för applikationer.
Testplanen för användargränssnittet innehåller viktig information om applikationen och alla testaktiviteter som är kopplade till den.
Att skapa en testplan är normalt ett av de första stegen du tar när du testar applikationer, eftersom den lägger grunden för testmetoderna och de avsedda resultaten.
Det är ett användbart dokument som ger personer utanför testteamet en bättre uppfattning om vad som händer i processen.
Hur man skriver en testplan för användargränssnittet
Testplaner för användargränssnitt erbjuder utmärkt vägledning och instruktion för testare av användargränssnitt, så att göra rätt hjälper verkligen till vid testning och inspektion av applikationer.
Ta en titt på stegen nedan för att lära dig hur du skriver en testplan för användargränssnittet:
1. Inkludera viktig information om UI-testningen.
En testplan för användargränssnittet innehåller all viktig information som krävs för att genomföra testning av en applikation. Bland denna information finns bland annat följande:
– De yrkesgrupper som krävs för testningen, deras roller och kompetens.
– Den totala tid som krävs för att testa programmet.
– De testmetoder som tillämpas på testet.
– Eventuella resurser som krävs för testning, t.ex. särskild hårdvara, dokumentation eller verktyg.
– En uppdelning av måltestmiljöerna, t.ex. mobila enheter, ett visst operativsystem eller webbläsare.
– De övergripande målen för testprocessen.
2. Rökprovning
Därefter kan du använda rökprov för att skapa en testplan för användargränssnittet. Smoke-testning är ett användbart sätt att identifiera grundläggande problem och fel i programmet, men det är inte tillräckligt djupgående för att hitta problem.
Det är en teknik som lämpar sig bäst för UI-testning av det övre lagret av programmet, så den kan fånga upp uppenbara problem ganska lätt.
3. Testning av sanitet
För att gräva djupare i programmet och hitta mindre uppenbara buggar och fel är sanity testing en bra teknik att använda för UI-testning.
Sanity testing syftar till att inspektera all ny eller ändrad kodning för att kontrollera att den överensstämmer med applikationskraven.
Den skiljer sig från rökprovningen genom att den är mycket mer omfattande med UI-testning, vilket gör det möjligt att titta djupare på applikationens funktionalitet.
När en applikation klarar ett röktest lägger sanitetstestet till en extra kontrollnivå.
Testscenarier för användargränssnittet
För att säkerställa att applikationen fungerar som avsett i flera områden och interaktioner är det viktigt att utföra olika testscenarier för användargränssnittet.
Nedan följer en uppdelning av vad UI-testscenarier är, med ett exempel.
1. Vad är UI-testscenarier?
Ett UI-testscenario är ett sätt att upprätta dokumentation för flera användningsfall i en applikation.
Ett testscenario för användargränssnittet används för att beskriva de specifika åtgärder som en användare kan vidta när han eller hon använder programmet.
I vissa fall beskrivs också ett scenario som en användare kan uppleva när han eller hon använder programmet.
Testscenarier för användargränssnittet är användbara eftersom de verifierar att funktionaliteten i en applikation fungerar som förväntat. För att skapa användbara scenarier krävs en ingående förståelse för applikationen och input från kunder och utvecklare.
2. Exempel på testscenarier för användargränssnittet
Som ett exempel kan du tänka dig ett testscenario för inloggningssidan i ett program. Ett UI-testscenario för detta ska försöka besvara följande frågor:
– Kan användarna logga in på plattformen med rätt autentiseringsuppgifter?
– Vad blir resultatet om du använder felaktiga autentiseringsuppgifter för att logga in?
– Vad händer när du använder ett giltigt användarnamn men ett ogiltigt lösenord?
– Vad händer när du lämnar fälten tomma och försöker logga in?
– Om det finns en ”glömt lösenord”-knapp, vad händer när du klickar på den?
– Fungerar alla länkar på sidan som avsett?
Svaren på dessa frågor hjälper UI-testarna att identifiera områden i applikationen som inte fungerar som de ska.
Den kontrollerar också att alla tillgängliga åtgärder ger det förväntade resultatet, t.ex. att du loggar in med rätt autentiseringsuppgifter.
Testfall för användargränssnittet
För att titta på enskilda aspekter av ett scenario för UI-testning används testfall för att dela upp enskilda funktioner i en applikation.
Nedan följer en sammanfattning av vad UI-testfall är med exempel.
1. Vad är UI-testfall?
Ett UI-testfall är en serie åtgärder som utförs för att verifiera en specifik funktion eller funktionalitet i ett program.
Testfall för användargränssnittet innehåller teststeg, data, för- och eftervillkor för specifika scenarier och kontrollerar även kraven.
Ett UI-testfall brukar innehålla mycket specifika variabler för att möjliggöra djupgående testning på en enskild nivå. UI-testare jämför sedan de faktiska resultaten med det förväntade resultatet för att se till att programmet fungerar enligt kraven.
2. Exempel på testfall för UI och GUI
För att hjälpa dig att bättre förstå UI- och GUI-testfall kan du ta en titt på exemplen nedan som är testfall för testscenariot som undersöker funktionaliteten hos en inloggningsskärm:
– Kontrollera systemets beteende när giltiga autentiseringsuppgifter matas in.
– Kontrollera hur systemet beter sig när ett ogiltigt e-postmeddelande men ett giltigt lösenord används.
– Kontrollera hur systemet beter sig när ett giltigt e-postmeddelande men ett ogiltigt lösenord används.
– Kontrollera hur systemet beter sig när en ogiltig e-postadress och ett ogiltigt lösenord används.
– Kontrollera hur systemet beter sig när fälten lämnas tomma.
– Kontrollera länken ”glömt lösenord” för att se om den fungerar som förväntat.
– Kontrollera hur systemet beter sig när knappen ”Håll mig inloggad” är markerad.
– Kontrollera hur systemet beter sig när ett ogiltigt telefonnummer matas in.
Alla dessa exempel är alltså enskilda testfall för användargränssnittet.
Till skillnad från testscenariot, som omfattar hela processen, tittar testfallen på de enskilda funktionerna. Med andra ord är varje exempel ovan ett UI-testfall och hela listan klassas som ett testscenario.
Skripter för UI-tester
För att få en ännu mer detaljerad uppdelning av applikationstestning skapas UI-testskript för att ge testare mer information om testfall och scenarier.
Nedan följer en sammanfattning av vad UI-testskript är och hur man skriver dem.
1. Vad är UI-testskript?
UI-testskript är mycket detaljerade beskrivningar av tester som utförs på en applikation, vanligtvis rad för rad.
De är mycket specifika till sin karaktär och innehåller många detaljer om vilka testfall som används, vilka data som används och vilken funktionalitet som förväntas av applikationen.
Alla resultat från testfall inkluderas också i testskript för att öka informationsrikedomen.
2. Hur man skriver UI-testskript
UI-testskript är enkla eftersom de bara beskriver testfallen.
Om du tar med följande information i dem bör du kunna få ut mycket värde av dina UI-testskript:
– ID för testskriptet: Detta är testskriptets unika identifierare.
– Titel: Testskriptets titel: Titeln på testskriptet.
– Testfalls-ID: Detta är ID för det testfall som du skapar ett skript för.
– Krav: Dessa är specifikationerna för den hårdvara som krävs för att köra testfallen.
– Förfarande: Detta är de steg som tas för att gå vidare med testningen.
– Resultat: Detta är testets resultat och slutresultat.
– Status: Detta är en indikation på hur väl testskriptet har lyckats – klarade det sig eller misslyckades det?
– Felkod: Om ett problem uppstod, anger felkoden vad problemet var.
Checklista för dina UI-tester
Nu när du är redo att komma igång med UI-testning kan du använda checklistan nedan för att skapa dina egna tester:
1. Kontrollera den grundläggande funktionaliteten
Funktionell testning är ett bra sätt att hitta saker som visuella fel eller problem på plattformen.
Se till att inkludera saker som biometri, eventuella meddelanden och information om programminne i detta skede.
2. Kontrollera kompatibilitet mellan olika plattformar
För att undvika problem som enhetsfragmentering som blockerar vissa användare från applikationen är det bra att utföra kompatibilitetskontroller mellan olika plattformar.
Detta inkluderar att kontrollera programmet i olika skärmupplösningar.
Det är en bra idé att undersöka kompatibiliteten för både inbyggda och hybrida applikationer på mobila enheter som Android och iOS.
3. Kontrollera kompatibilitet mellan olika skärmstorlekar
Det finns många olika skärmstorlekar som slutanvändarna kan försöka använda programmet, så det är viktigt att testa användargränssnittet för dessa.
Testning av användargränssnittets responsivitet genomförs bäst på de senaste enheterna för att åtgärda eventuella problem. Kom också ihåg att testa i både liggande och stående läge.
4. Kontrollera prestanda och skalbarhet
När en applikation är skalbar kan den leverera utmärkta prestanda på olika plattformar.
Testa olika belastningsnivåer, trafik och andra slutanvändarscenarier för att bedöma applikationens prestanda och skalbarhet.
Detta kan göras med hjälp av parallell testning, där automatiserad UI-testning används som robotiserad processautomatisering i flera olika miljöer.
5. Kontrollera tillgängligheten till programmet
Tillgänglighetstestning säkerställer att specifika funktioner som är inriktade på att hjälpa slutanvändare fungerar som förväntat. Kontrollera t.ex. teckensnittsstorlek, skärmläsningsläge och zoomalternativ här.
6. Kontrollera färger och text
Programmen ska visa färger på ett visst sätt, så det är viktigt att kontrollera detta genom att testa färgscheman.
Detta inkluderar saker som färgen på en hyperlänk eller andra typsnittstyper. Det är också bra att kontrollera texten med avseende på stavning, teckenstorlek och justering.
7. Bedöm navigationshastigheten.
Se till att testa att applikationens användargränssnitt fungerar smidigt och utan problem. Saker som laddningsskärmen för rubriker är ett bra ställe att leta efter fördröjning.
