understanding working with robot framework
Självstudien förklarar hur man skapar och utför ett grundläggande testfall i robotramen. Du lär dig också om variabler och nyckelord i Robot Framework:
Vi lärde oss om Grunderna i Robot Framework IDE - RIDE i vår tidigare handledning för att hjälpa oss komma igång med att skriva testskript med hjälp av RIDE i detta Robot Framework-serien .
Självstudien ger dig en förståelse för grunderna i Robot Framework.
Vi ska lära oss om variabler och vilken typ av variabler som finns i Robot Framework. Vi kommer att se hur man skapar och använder variabeln. Vi kommer också att förstå vad som är nyckelorden tillsammans med deras olika typer. Vi kommer också att lära känna hur nyckelord kan skapas och användas.
bästa appen för att kontrollera cpu temp
Dessutom skulle den här självstudien också ge dig kunskap om inställnings- och nedbrytningsalternativen i RIDE som är användbara vid utförande av testfall. Vi kommer också att lära oss mer om taggar - en funktion i RIDE som hjälper till med selektiv utförande av testfall.
Viktigast av allt kommer vi att skriva testskriptet (med och utan lokaliserare) för några exempel på testfall. Vi lär oss hur dessa testskript körs i Ride och slutligen mot slutet av handledningen lär vi oss att visa rapporterna för de körda testskripten.
Vi kommer att avsluta handledningen med några användbara länkar om Robot Framework som du kan referera till när som helst.
Vad du kommer att lära dig:
- Skapa och genomföra ett grundläggande testfall
- Förstå variabler i robotramen
- Förstå nyckelord i robotramen
- Använda inställning och nedbrytning i RIDE
- Använda taggar i RIDE
- Skapa testfall med hjälp av Locators
- Förstå nyckelord och datadriven strategi i robotramen
- Åtkomst till rapporter i Ride
- Slutsats
- Rekommenderad läsning
Skapa och genomföra ett grundläggande testfall
Låt oss nu skapa ett grundläggande testfall i RIDE där vi öppnar webbplatsen google.com i Chrome-webbläsaren och sedan stänger vi webbläsaren. Så låt oss komma igång med vårt första testfall i Robot Framework med Ride.
Klicka på 'TestCase1' och du kan se ett rutnät (du borde vara på fliken 'Redigera').
Följ stegen nedan för att skriva koden:
- Skriv 'Öppna webbläsare' (nyckelord från Selenium Library) i den första cellen.
- När du börjar skriva väljer du ctrl + alt + mellanslag (eller ctrl + mellanslag) för att få innehållshjälp.
- Skriv webbadressen i nästa cell Google .
- Skriv webbläsarens namn i den tredje cellen. Att ange webbläsarens namn är valfritt.
- Skriv ”Stäng webbläsare” i den första cellen i nästa rad.
Låt oss förstå vad vi just har gjort.
- 'Öppna webbläsare' är ett nyckelord från Selenium-biblioteket som vi importerade ovan i vårt testfall.
- Innehållsassistans hjälper oss med den exakta syntaxen utan att behöva komma ihåg det.
- ”Öppna webbläsare” tar det första argumentet som URL för webbplatsen som vi vill öppna i webbläsaren. Det andra argumentet är valfritt och det anger vilken webbläsare vi vill använda. Om detta inte nämns används Firefox som standardwebbläsare.
- 'Stäng webbläsare' är återigen ett nyckelord i Selenium Library som stänger webbläsaren vi öppnade.
Nu ska vi köra den här koden genom att följa stegen nedan:
- Klicka på fliken 'Kör' - Den här fliken innehåller alternativet att utföra testfallet.
- Markera ”Autosave” - För att säkerställa att alla sparade ändringar i testfallet sparas automatiskt.
- Kontrollera ”TestCase1” - För att låta RIDE veta vilket testfall vi vill utföra.
- Klicka på 'Start' -knappen - För att starta utförandet av testfallet.
Testfallet utförs framgångsrikt. Nedan visas skärmen som vi får efter det lyckade genomförandet av testfallet. Här kan vi se den totala tid det tar för testkörning tillsammans med antalet godkända och misslyckade testfall.
Förutom detta har vi också möjlighet att visa rapport och logg för det utförda testfallet. Vi får se det i de kommande handledningarna.
Förstå variabler i robotramen
Precis som alla programmeringsspråk där vi använder variabler, har vi också variabler i Robot Framework.
Vad är variabler?
Variabler är bara lagringsplatser som hänvisas till med ett namn som innehåller något värde.
Typer av variabler
I Robot Framework har vi tre typer av variabler:
- Skalär
- Lista
- Ordbok
I de kommande två ämnena ska vi se hur var och en av ovanstående variabler kan skapas och användas.
Skapa variabler
I Robot Framework är variablerna inte skiftlägeskänsliga. Vi bör använda versaler för att hänvisa till globala variabler (som används i hela uppsättningen testfall) och små bokstäver för att hänvisa till lokala variabler (som endast används i vissa testfall).
För att namnge en variabel använde vi en variabel-typ-identifierare (&,%, $, @) som föregår variabelnamnet skrivet inom lockiga parenteser. Låt oss ta en titt på hur var och en av variabeltyperna deklareras.
# 1) Skalarvariabel : En skalarvariabel hänvisas till som $ {Name}.
Här refererar $ - till variabeltypen, dvs Scalar Name - är variabelnamnet.
Som regel placeras detta inom lockiga hängslen. En skalarvariabel kan tillhandahållas med vilket värde som helst, till exempel en sträng, ett objekt, siffror, listor, ordböcker eller anpassade objekt.
Låt oss tilldela värde 5 till den skalära variabeln 'a'.
Följ stegen nedan för att göra det:
TestCase1 (högerklicka) -> New Scalar
Du får en popup-skärm som visas nedan:
Ange variabelnamnet inom de lockiga hakparenteserna som visas i ögonblicksbilden ovan. Ange dess värde i textrutan 'Värde' och lägg till en kommentar om du vill.
Denna skalära variabel - $ {a} som vi just skapade kan nu ses i den vänstra panelen.
# 2) Listvariabel : En listvariabel refereras till @ {name}.
Här refererar @ - till variabeltypen, d.v.s. Listnamn - är variabelnamnet. Som regel placeras detta inom lockiga hängslen.
Listan tillåter att en Python-lista eller ett listliknande objekt lagras i den. Robot Framework tillåter inte att strängar används som listor, men objekt som tuples eller ordböcker är tillåtna.
Låt oss tilldela värdena 'Hello', 'Robot' och 'Framework' för att lista variabeln 'b'. Följ stegen nedan för att göra det:
TestSuite1 (högerklicka) -> Ny listvariabel
Du får en popup-skärm som visas nedan. Istället för standard 4 i kolumnerna kommer vi att välja 2.
Följ nu stegen nedan:
- Ange variabelnamnet 'b' inom de lockiga hakparenteserna som visas i ögonblicksbilden nedan.
- Ange dess värden i textrutan ”Värde”.
- Lägg till en kommentar (valfritt).
- Klicka på ”OK” för att spara variabeln.
Var och en av värdena i listvariabeln nås i förhållande till dess index som anses från 0 för det första värdet i listan. Till exempel, för att hänvisa till ett ramverk skulle vi skriva det som @ {b} (2), eftersom det är vid position 3 för vilket indexet skulle vara 2.
# 3) Ordboksvariabel : En ordboksvariabel hänvisas till som & {Namn}.
Här refererar & - till variabeltypen d.v.s. Dictionary Dictionary - är variabelnamnet. Som regel placeras detta inom lockiga hängslen.
Ordboksvariabler används främst när vi har en tabell med nyckel-värdepar. Till exempel när vi vill testa inloggningen för en uppsättning ID och lösenord. Skillnaden mellan variablerna List och Dictionary är hur de hänvisas och vi kommer att se det framöver.
Låt oss skapa en ordboksvariabel 'inloggning' och tilldela värden: e-postadress och lösenord till den enligt nedan: 'testingrf19@gmail.com', '123'. Följ stegen nedan för att göra det:
TestSuite1 (högerklicka) -> Ny ordboksvariabel
Du får en popup-skärm som visas nedan. Istället för standard 4 i kolumnerna kommer vi att välja 1.
Följ nu stegen nedan:
- Ange variabelnamnet 'inloggning' inom de lockiga hakparenteserna som visas i ögonblicksbilden nedan.
- Ange dess värden i textrutan ”Värde”.
- Lägg till en kommentar (valfritt).
- Klicka på ”OK” för att spara variabeln.
Till skillnad från Listvariabler som använder indexet för att referera till de enskilda värdena i det, använder ordboksvariabler ett tydligare sätt att referera till dess värden. Som i fallet ovan skulle vi använda & {login} (e-post) och & {login} (lösenord). Ser det inte riktigt självförklarande ut?
Dessa skapade variabler syns också i ”TestSuite1” (fliken Redigera).
Använda variabler
Vi ska nu se hur vi kan använda dessa variabler i vårt testfall. Vi använder testfallet som skapats tidigare och ersätter webbadressen som används med en variabel som lagrar webbadressen istället. Så låt oss skapa en skalarvariabel med namnet “URL” och lagra värdet Google i det.
Vi kommer nu att ersätta webbadressen med variabeln i vår kod. Eftersom detta är en skalarvariabel hänvisas till den som $ {URL}. Vårt testfall ska nu se ut som nedan:
Låt oss köra detta testfall och se om variabeln 'URL' ersätts med rätt värde. ja! Vårt testfall utförs framgångsrikt. Google com öppnas i webbläsaren och sedan stängs webbläsaren. Resultatet visar att det var en framgång.
Den gröna symbolen bredvid testfallets namn på den vänstra panelen och PASS på den högra panelen visar att testfallets utförande lyckades.
Så här använder vi variabler i ett testfall. Fördelen med att använda variabler är synlig när vi använder samma värde på flera platser. Närhelst det sker en förändring i värdet behöver vi bara byta ut variabelns värde och detsamma återspeglas på varje plats där variabeln har använts.
På samma sätt kan vi använda listan såväl som ordboksvariabeln enligt våra testfall.
Förstå nyckelord i robotramen
Vad är nyckelord?
Nyckelord som namnet antyder ('Nyckel' + 'ord') är ett ord som fungerar som en nyckel till något som inte syns. Låt oss mer förstå att om jag har en uppgift med 10 steg att göra och jag nämner de 10 stegen och hänvisar dem till med ett namn så är namnet ett nyckelord.
Typer av nyckelord
Robot Framework innehåller två typer av nyckelord:
- Biblioteksnyckelord : Dessa nyckelord kallas även nyckelord på låg nivå. Dessa görs tillgängliga av biblioteken som används med Robot Framework (inbyggda och externa bibliotek). Till exempel, Vi har ett nyckelord 'Logga till konsol' som tillhandahålls av det inbyggda biblioteket och 'Öppna webbläsare' är ett nyckelord som tillhandahålls av Selenium-biblioteket.
- Användardefinierade nyckelord : Dessa kallas också nyckelord på hög nivå. De definieras av användaren. Användardefinierade nyckelord kan också innehålla andra biblioteksnyckelord och / eller andra åtgärder.
Skapa nyckelord
Denna handledning kommer att förklara sätten att skapa användardefinierade nyckelord.
Högerklicka 'TestSuite1' och välj Ny sökord för användare .
Du skulle få en skärm som visas nedan. Låt oss skapa ett nyckelord för att öppna Googles webbplats. Så vi skulle bara ha ett nyckelord för att utföra uppgiften i testfallet som vi hade skapat.
Öppna testfallet du skapade och titta på stegen du lade till. Vi hade öppnat google.com i Chrome och stängde sedan webbläsaren.
Låt oss ge namnet 'Öppna google' till vårt nyckelord och klicka på ”Ok”.
Nyckelordet har definierats och nu kommer de åtgärder som måste utföras skrivas inom detta nyckelord. Så klicka på “ Öppna Google ' och skriv samma steg som vi skrev i vårt TestCase1.
Som du ser nedan är nyckelordet “ Opengoogle ”Skulle öppna Google com i Chrome-webbläsaren och stäng sedan webbläsaren.
Använda nyckelord
Vi har nu definierat vårt nyckelord “ Öppna Google ”. Det är ganska enkelt att använda det i vårt testfall. Ta först en titt på vårt ursprungliga testfall som vi skapade för att öppna google nedan.
Vi kommer nu att ersätta den här koden med nyckelordet. Du kommer att märka att när du börjar skriva nyckelordet och öppna innehållsassistenten kommer detta nyckelord också att synas i listan som dyker upp. Titta på skärmdumpen nedan.
När TestCase1 har bytts ut ser det enkelt ut som visas nedan:
Låt oss utföra detta och se om det fungerar som avsett.
ja! testfallet passerar och vi har det förväntade resultatet.
Använda inställning och nedbrytning i RIDE
Precis som namnet antyder är Setup den uppsättning instruktioner / nyckelord som ska köras som en första förberedelse för att utföra själva testfallet. Som ett exempel är vårt grundläggande krav att öppna en webbläsare, i allmänhet för alla utföranden av testfall. Så vi kan alltid lägga till detta steg för att öppna webbläsaren som en installationsaktivitet.
På samma sätt är nedbrytning uppsättningen instruktioner / nyckelord som ska köras i slutet av ett testfall. Som ett exempel vill vi stänga webbläsaren när vi är färdiga med ett testfall. Så vi kan alltid lägga till detta steg för att stänga webbläsaren som en nedbrytningsaktivitet.
Installations- och nedbrytningsaktiviteter kan deklareras på:
- Test svit nivå: När deklareras på testsvitenivå kommer installationsinstruktionerna att utföras innan något av testfallet inom den testsviten körs. På samma sätt skulle nedrivning som deklareras på testsvitnivå köras efter att något av testfallet inom den testsviten har körts.
- Testfallets nivå : När deklareras på en testfallsnivå kommer installationsinstruktionerna att utföras innan körningen av testfall inom den testsviten körs. På liknande sätt skulle nedrivning som deklareras på testfallet bli exekverad efter att testfallet har utförts.
Låt oss nu se hur vi lägger till en installationsaktivitet på testfallet.
- Skapa TestCase2.
- Klicka på knappen 'Redigera' för installation, precis under Inställningar i den högra panelen.
- Skriv in nyckelordet 'Öppna webbläsare' i vårt fall. Du kan också använda innehållshjälpen här.
- Argument kan skickas tillsammans med nyckelordet genom att separera dem med ett '|' rörskylt.
- Klicka på ”OK”.
Låt oss nu se hur vi lägger till en nedrivningsaktivitet på testfallet.
- Klicka på TestCase1
- Klicka på knappen 'Redigera' för att riva ner, strax under Inställningar i den högra panelen.
- Skriv in nyckelordet 'Stäng webbläsare' i vårt fall. Du kan också använda innehållshjälpen här.
- Klicka på ”OK”.
Nu när vi har flyttat båda stegen i testfallet som uppställning och nedbrytning av aktivitet, låt oss lägga till ytterligare ett steg i testfallet så att vi kan utföra och kontrollera resultatet. Låt oss visa “Hej” på konsolen. Nyckelordet vi har använt är 'Logg' som kommer från det inbyggda biblioteket.
TestCase2 ser ut som visas nedan:
När den körs körs installationsprogrammet först, följt av loggning ”Hej” på konsolen och slutligen utförs nedrivningsaktiviteten och webbläsaren stängs.
Använda taggar i RIDE
Märkning används när vi vill gruppera en uppsättning testfall antingen för att utföra dem eller för att undvika att de körs. Vi grupperar främst tester under Regression, Smoke och Sanity. Eller det kan vara i scenarier där en del viktiga funktioner måste testas upprepade gånger.
För att förstå hur taggar skapas och används, låt oss skriva två enkla testfall - 'TestCase3' och 'TestCase4'. Koden för detta är som visas nedan. Vi har använt nyckelorden, 'Logga in till konsolen' som kommer från det inbyggda biblioteket.
Testfall 3
Testfall 4
Följ stegen nedan för att märka dessa testfall:
- Klicka på knappen Redigera för 'Taggar'.
- I popup-fönstret anger du ett namn på taggen, säg Case3.
- Klicka på 'OK'
Båda testfallet har nu taggen 'Case3'. Låt oss se hur detta kan användas.
Antag att vi bara vill köra testcase3 och testcase4.
- Gå till fliken KÖR
- Markera rutan 'Kör bara tester med dessa taggar'
- Skriv ”Case3” i textrutan nedan.
- Klicka på startknappen.
Observera att vi inte valde något testfall men efter testkörningen ser du att endast 'TestCase3' och 'TestCase4' har körts.
På samma sätt har vi också möjlighet att hoppa över specifika taggade testfall med 'Hoppa över test med dessa taggar' och nämna taggnamnet.
Vi har också möjlighet att skapa taggar dynamiskt vid körning med hjälp av nyckelordet “Ange tagg” , på samma sätt kan vi också ta bort taggar vid körning med hjälp av nyckelordet 'Ta bort taggen' .
Hoppas att den här guiden har gett dig en klar uppfattning om att skapa och använda taggar nu.
Skapa testfall med hjälp av Locators
Vi skapade ett mycket grundläggande testfall som innebar att skriva något på konsolen eller bara öppna en webbläsare. Låt oss nu skriva testfall som innefattar användning av lokaliserare.
Att testa en webbplats eller någon applikation innebär att du hittar elementen. När vi vill utföra en åtgärd på något element måste vi känna till dess lokaliserare. Normalt är 'id' eller 'namn' attributen för ett element som används för att identifiera det på en sida och därmed utföra en åtgärd med hjälp av nyckelord.
Vi öppnar en webbläsare och söker efter den officiella webbplatsen för Robot Framework och öppnar den.
Låt oss gå igång och skriva koden för detta.
- Skapa 'TestCase5' i TestSuite1.
- Öppna webbläsaren (Chrome).
- Hitta sedan sökaren till textrutan för google-sökning.
Chrome-inställningar -> Verktyg -> Utvecklarverktyg .
Samma kan också nås med Ctrl + Shift + I.
- När utvecklarverktyget är öppet klickar du på ikonen för lokaliseringselement enligt nedan.
- Håll den över textrutan för google-sökning tills den blir markerad och klicka över den. Du kommer att märka att koden relaterad till sökrutan markeras på den högra panelen.
- Från koden kommer vi att använda namnet = ’q’ som lokaliserare.
- ”Inmatningstext” är det Selenium-nyckelord som ska användas för att skriva in text i Googles sökruta.
- Tryck på Enter för att få sökresultaten.
Så här skulle vår kod se ut. Det ser ganska enkelt ut !! Är det inte?
Det handlar om övning. Allt vi behöver är att kunna komma ihåg vilket nyckelord som är tillgängligt för att automatisera en viss åtgärd. Så ju mer du automatiserar dina tester, desto bekvämare skulle du arbeta med detta ramverk.
Resultatet av ovanstående testfall efter utförande är som visas nedan. Chrome-webbläsaren ses öppen nedan genom att visa sökresultaten för ”Robot Framework”.
Förstå nyckelord och datadriven strategi i robotramen
När vi skriver ett testfall i Robot Framework följer vi någon av nedanstående metoder:
- Sökordsdriven strategi: När vi använder nyckelord för att skriva testfallet kallar vi det för ett nyckelordsdrivet tillvägagångssätt. Det nyckelordsstyrda tillvägagångssättet förbättrar testläsets läsbarhet. Vi har redan sett hur nyckelord kan skapas och användas i ett testfall.
- Datadriven strategi : Detta tillvägagångssätt följs främst när vi vill testa logik för olika datavärden. I detta tillvägagångssätt skapas en mall för ett nyckelord på hög nivå, och argumenten till detta nyckelord skickas från testfallet, vilket är det datavärde som testfallet måste köras för.
Hur vi använder detta tillvägagångssätt i våra testfall är vad vi kommer att se nedan när vi skapar ett nytt nyckelord.
Låt oss skapa ett testfall för att söka efter olika testautomationsverktyg / ramar - Robot Framework, J-meter, Selen, etc.
Testfallet skulle bara innehålla data, i det här fallet sökorden som skulle skickas som argument till mallen. Mallen skulle innehålla sökordet på hög nivå som skulle ha den verkliga koden som ska köras. Sökvärdena skulle skrivas i testfallet.
Med denna korta förståelse låt oss skapa mallen 'Google-sökning' genom att följa stegen nedan:
- Skapa TestCase6 enligt förklaringen i avsnittet “Skapa ett projekt, Test Suite och ett testfall i Ride”.
- Klicka på 'Redigera' för mall och ange ett namn. ”Google-sökning” i vårt fall.
- Vi kommer att använda samma kod som i TestCase5, med den enda skillnaden att texten som ska sökas skickas som ett argument som anges nedan.
- Detta argument ska också nämnas i textrutan Argument. Så klicka på Redigera i textrutan Argument och skriv in argumentet och klicka på 'OK'.
- Låt oss nu komma tillbaka till TestCase6 och ange data.
- Så här ser din skärm ut efter att genomförandet av testfallet har slutförts.
Du kommer att märka att fem instanser av Chrome-webbläsaren har öppnats och var och en skulle ha sökresultaten för de fem olika testautomationsverktygen som vi har sökt efter.
Vi hoppas att detta testfall har gett dig god klarhet i den datadrivna metoden. När du testar fler sådana exempel verkar detta tillvägagångssätt ganska enkelt för dig.
Åtkomst till rapporter i Ride
Nedan visas skärmdumpen efter att TestCase6 har körts. Den ger två alternativ ”Rapportera” och ”Logga” enligt nedan. Det ger också den fullständiga länken för att komma åt loggen och rapporten.
Rapportera - TestCase6-körningsresultat
Det ger en sammanfattande rapport över de testserier som körs. När du klickar på Test-sviten visas detaljerna i test-sviten, testfallet. När vi ytterligare klickar på testfallet öppnar det detaljerna i testfallet som kallas loggen.
Logga - TestCase6-körningsresultat.
Logg ger en detaljerad rapport testvis för hela projektet.
Förutom ikonerna för rapport och logg. Vi har också webbadresserna till dessa som kan kopieras och öppnas direkt i webbläsaren. Det är en känd fråga att ibland efter att ha kört ett testfall är ikonerna 'Rapporter', 'Logg' inaktiverade. I ett sådant scenario kan dessa länkar kopieras och öppnas i webbläsaren för att visa rapporten.
sql intervjufrågor för 5 års erfarenhet
URL: en är platsen i den lokala maskinen där rapporterna sparas. Varje gång vi utför ett testfall uppdateras denna plats och den nya genererade rapporten sparas på den här platsen.
Robotramverk - användbara länkar
Slutsats
Vi hoppas att som en nybörjare skulle denna handledning ha gett dig god kunskap om användningen av Robot Framework som ett testautomatiseringsverktyg.
I den här handledningen lärde vi oss om skapandet av variabler och nyckelord. Vi såg hur man skriver testskript med nyckelorddrivet och datadrivet tillvägagångssätt.
Vi gjorde också en praktisk testskriptkörning. Självstudien gav en inblick i att visa de detaljerade testresultaten via logg och rapporter. Dessutom har viktiga webbadresser relaterade till Robot Framework delats.
'Övning gör en man perfekt', så utan fördröjning ta det här verktyget i bruk så mycket du kan så att du gradvis kan bli säker på att använda det.
Glad läsning!!
PREV-handledning | FÖRSTA självstudier
Rekommenderad läsning
- Robot Framework Tutorial - Funktioner och programvaruinstallation
- Komma igång med RIDE - Robot Framework IDE
- TestNG Tutorial: Introduktion till TestNG Framework
- BDD (Behavior Driven Development) Framework: A Complete Tutorial
- D3.js-handledning - Datavisualiseringsramverk för nybörjare
- Jasmine Framework Tutorial Inklusive Jasmine Jquery med exempel
- Java Collections Framework (JCF) Tutorial
- Karate Framework Tutorial: Automated API Testing With Karate