Kör testfall i parallella och generera rapporter med Karate-verktyget

run test cases parallel generate reports using karate tool

Denna handledning förklarar hur man utför några grundläggande operationer på API: et, kör testfall parallellt och genererar rapporter med Karate Framework:

Vi har lärt oss hur man skapar ett grundläggande testskript i vår tidigare handledning, vi kan nu gå vidare med att lära oss några grundläggande operationer som kan utföras när vi arbetar med API och Karate Framework. Det finns många sådana operationer och vi kommer att diskutera några vanliga i denna handledning.

Vi ska också gräva i processen för att köra testfall parallellt genom att följa en steg-för-steg-metod. Vi kommer också att diskutera den nuvarande rapporten som genereras automatiskt och jämföra den med gurka-rapporten som vi kan generera genom att integrera ett plugin.

Vad du kommer att lära dig:

• Arbetar med API och Karate Testing Tool
  • Utföra olika operationer
  • Utför postoperationer
• Kör testfall parallellt
• Integrera gurka-plugin för rapportering
• Slutsats
  • Rekommenderad läsning

Arbetar med API och Karate Testing Tool

Som diskuterades i föregående handledning, i .funktion fil som vi skapade, kunde vi använda olika nyckelord för att utföra olika operationer på API: et. Karate Framework ger oss flera nyckelord som kan användas för att utföra olika åtgärder.

=> Rekommenderad läsning: API-testning med karate-ramverk

Utföra olika operationer

# 1) Skriva ut svaret i konsolen

Skriva ut är ett nyckelord som tillhandahålls av Karate Framework för att skriva ut resultatet i konsolen eller filen. En av de vanligaste användningarna är att skriva ut svaret från API: et. Detta kan vara mycket användbart för användaren.

Vi kan göra detta genom att använda följande kodrader:

Ovanstående kodrader ger följande utdata:

Så här kan vi skriva ut svaret från API: et i konsolen för läsändamålet, som kan användas vid felsökningstillfället.

# 2) Deklarera variablerna

Vi kan deklarera variablerna med hjälp av nyckelordet def i Karate-ramverket och använd sedan deklarerade variablerna i koden när det behövs.

I exemplet nedan har vi lagt till några fler kodrader till det befintliga userDetails.feature fil för att deklarera variablerna i skriptet.

# 3) Hävdar det faktiska svaret på det förväntade svaret

Karate Framework hjälper till att utföra de påståendrelaterade operationerna med hjälp av match nyckelord. De match är smart eftersom vitt utrymme inte spelar någon roll för det och tangenternas ordning är inte viktig.

För användning matcha sökord, vi måste använda det dubbla likhetstecknet “==” som representerar en jämförelse.

Nu ska vi försöka utarbeta några användningar av match nyckelord.

a) När hela det förväntade svaret nämns i själva .feature-filen.

Vid vissa tillfällen har vi några data som vi vill validera omedelbart i själva filen. Vanligtvis nämns sådana typer av data vid felsökning av koden.

Vi kan göra detsamma i själva .feature-filen som visas nedan:

Om du skickar en begäran till webbadressen 'Https://reqres.in/api/users/2' i webbläsaren du får följande svar:

Vi försöker validera ovan nämnda svar med * .feature-filen.

Vi har använt match nyckelord som tillhandahålls av Karate Framework, som hjälper till att utföra olika typer av Påståenden i API-svaret.

Notera : Vi skulle behöva omvandla API-svaret i en rad för att utföra steget ovan. Du kan använda något av de tillgängliga verktygen uppkopplad.

b) När den förväntade utdata sparas i en extern JSON-fil.

I exemplet ovan diskuterade vi ett scenario där vi hade begränsad data och samma svar som var lätt att hantera, men i de verkliga scenarierna kommer vi att ha gigantiska uppsättningar av JSON-svar som vi kan behöva utvärdera.

Så i dessa fall är det bättre att hålla svaret i den externa filen och sedan verifiera detsamma.

I exemplet nedan kommer vi att diskutera samma sak:

• Behöver skapa en ExpectedOutput.json filen i vår projektmapp som visas i bilden nedan.

Skapa en ny paketresurs -> Skapa en ny fil ExpectedOutput.json

Och lagra JSON-svaret i den här filen och spara den.

Du måste skriva följande kod i din userDetails.feature fil:

I exemplet ovan läser vi först filen ExpectedOutput.json och lagra svaret på det i variabeln Förväntat resultat använda följande kodrader:

Sedan sätter vi påståendet med följande kodrader, där vi matchar Faktiskt svar med Förväntat resultat svar med “ == ' operatör.

c) Matcha / verifiera vissa värden från svaret

Hittills har vi verifierat hela API-svaret, men varje gång vill du inte verifiera hela svaret. Ibland vill du bara utvärdera en del av svaret. Vanligtvis gör vi detsamma när vi använder de andra verktygen för API-testning eller när vi skapar en ram.

För att förstå det vidare, låt oss ta följande JSON-svar som ett exempel:

Om vi ​​vill verifiera att parametern företag bör ha värdet som StatusCode Weekly, då måste vi skapa en JSON Path. Detta kan göras genom att korsa JSON-filen och använda '.' (Dotoperatör)

JSON-sökvägen för ovanstående svar kommer att vara:

ad.company == “StatusCode Weekly”

Nedan är kodavsnittet som hjälper oss att utvärdera värdena för den specifika parametern. Denna kod tillhör .funktion fil.

Nedan är kodraden som utför parametriska påståenden.

Med JSON Path utvärderar vi värdena för parametrarna.

Utför postoperationer

Hittills har vi täckt de grundläggande scenarierna för att testa ett API när metoden var ” SKAFFA SIG'. Men när vi arbetar i den verkliga miljön måste vi skicka mycket information till servern, så i så fall använder vi ” POSTA' metod .

Detta avsnitt ger dig en inblick i arbetet med den grundläggande POST-begäran.

Låt oss få några korta idéer om de parametrar som vi behöver för att skicka POST-begäran.

# 1) Skapa en POST-begäran när JSON-kroppen nämns i * .feature-filen

• Skapa en userDetailsPost.feature med liknande steg som nämns i föregående handledning.
• Skriv följande kodrader:

Eftersom det är en POST-begäran, som alltid måste åtföljas av en kropp som måste skickas till servern för ett visst svar, har vi nämnt det under följande komponent:

begäran: Det tar en JSON-kropp som den begäran som krävs med POST-metoden.

# 2) Skapa en POST-begäran när JSON-kroppen nämns i en extern fil

Vanligtvis kommer vi att ha en enorm begäran organ, som det skulle vara svårt att nämna i *.funktion fil. Så det är bättre att behålla den i den externa filen.

• Behöver du skapa en PostBody.json-fil i vår projektmapp enligt nedan. Skapa en ny paketresurs -> Skapa en ny fil PostBody.json och lagra JSON Body i den här filen och spara den.

Notera: Vi har nämnt POST-metoden i ovanstående JSON-fil.

• Du måste skriva följande kod i din userDetailsPost .funktion fil:

Vi läser JSON Body från PostBody.json med följande kodrader:

Notera: Alla userDeatils.feature filer som vi hittills har skapat kräver grundläggande TestRunner.java fil för att utföra dem, som vi skapade i vår handledning för grundläggande testskript som visas nedan:

Kör testfall parallellt

Nu, eftersom vi har lärt oss stegen för att skapa ett grundläggande testskript och utfört några grundläggande operationer på API: et, är det dags att vi börjar med att arbeta i den faktiska miljön.

Vanligtvis måste vi köra testfallet parallellt för att göra körningen snabbare. I grund och botten är tanken att få mer produktion på kortare tid.

Detta är en kärnfunktion i ramverket och beror inte på JUnit, Maven eller Grade. Det gör att vi kan:

• Välj enkelt funktionerna och taggarna för att köra testsviter på ett enkelt sätt.
• Visa parallella resultat under mappen surefire-plugin.
• Vi kan även integrera Cucumber JSON-rapporterna för bättre användargränssnitt (som kommer att diskuteras inom kort).

I Karate Framework behöver vi inte utföra många steg för att starta parallell körning av våra testfall. Vi behöver bara gå igenom följande steg:

1) Vi måste nu ändra TestRunner.java fil som vi hittills har använt. Koden för parallell körning måste skrivas i ovanstående fil.

Tänk på följande rad när du kör din kod i Parallel:

hur man skapar ny java-fil i förmörkelse

** Vi kan inte använda @RunWith (Karate.class) -anteckningen när vi försöker arbeta i en parallell miljö.

Öppna originalet TestRunner.java fil och använd följande kod nu:

** Följande kod gäller för JUnit 4 Maven-beroende

I kodavsnittet ovan har vi inkluderat nedanstående kodrad-

Resultat resultat = Runner.parallel (getClass (), 5);

Den här raden instruerar att köra förekomsten av testfall i parallell genom att dynamiskt hämta klasserna på Runtime.

två) Skapa ett duplikat userDetails.feature filen som nämns nedan under src / test / java mapp.

Nu är vi redo för parallell körning med två . funktioner fil.

3) Gå till TestRunner.java fil skapad i steget ovan och kör det som JUnit Test. Med detta kommer vi att utföra våra testfall i parallellt format.

För enkel läsbarhet presenteras viss information av Karate Framework i konsolen när testkörningen är klar.

Resultatet ser ut som följande:

Med parallell körning kommer alla funktioner att köras parallellt och scenarierna kommer också att köras i ett parallellt format.

Genom att följa ovanstående steg kommer du att kunna starta den mycket grundläggande parallellkörningen av API-testet med Karate Framework.

** Du kan studera om parallell testning genom att gå igenom de olika filtren på sidan Parallell utförande

Integrera gurka-plugin för rapportering

När vi använder JUnit löpare för genomförandet av olika scenarier som har nämnts i de olika *.funktion filer skapar den automatiskt en rapport för var och en av funktionsfilerna som lagras i sökvägen mål / säkerhetsrapporter.

Det genererar en Grundläggande UI-formaterad rapport för att presentera de testfall som har utförts.

Men de rapporter som genereras är inte särskilt trevliga när det gäller användargränssnittet, och för att dela rapporter med intressenterna behöver vi något som är mer användarvänligt och lättförståeligt.

För att uppnå ett sådant rapporteringsformat ger Karate Framework en möjlighet att integrera Gurka-rapporteringsplugin vilket kommer att hjälpa oss att generera en grafisk formaterad rapport, som blir mer presentabel.

Följande är stegen för att integrera samma:

# 1) Lägg till följande Gurka-rapportering beroende av din POM.xml

#två) Redigera TestRunner.java-filen när det bara finns en enda *.funktion filen i projektet.

Vi måste uppdatera vår TestRunner.java-fil med följande genereraReport () -metod för gurkaprogrammet.

I koden som nämns ovan utför vi följande åtgärder:

• Skapa en ny instans av fil
• Ange sökvägen för att lagra filerna under målmappen
• Skapa ett ReportBuilder-objekt som skapar en ny Gurka-rapport

Notera : Ovanstående kod fungerar bra när vi har singel *. funktion filen i vårt projekt.

# 3) Redigera TestRunner.java-filen när det finns flera * .funktion filer i projektet.

Vi skulle behöva lägga till en kodrad (markerad med fetstil nedan) för att säkerställa att parallell körning tas om hand, medan scenarierna körs för rapportgenerering.

Efter att ha utfört ovannämnda steg kommer vi att kunna skapa en väl representerad grafisk gränssnittsrapport med hjälp av Gurka - rapportering plugin.

Vi hittar rapporten på följande väg i vårt projekt som visas i bilden nedan:

Följande rapport genererades för vårt projekt för alla de operationer som vi hittills har utfört i denna Karate Framework Tutorial:

Slutsats

Sammanfattningsvis har vi i denna handledning diskuterat de grundläggande operationerna som är användbara dagligen när vi arbetar med Karate-ramverk och hur man kör flera * .funktionsfiler parallellt. Vi lärde oss också att skapa en grafisk rapport för användarna med hjälp av Gurka rapportering plugin.

Först diskuterade vi de grundläggande operationerna som kan utföras på API: et. Vi diskuterade hur vi kan skicka POST-kroppen / begäran till servern, antingen genom att nämna kroppen i * .feature-filen i sig (som vanligtvis inte är en rekommenderad metod) eller genom att använda en extern fil (en rekommenderad metod för att upprätthålla en ren kod).

För det andra, efter att ha följt några grundläggande steg, kunde vi framgångsrikt utföra testresultatet för två *.funktion filer som kördes parallellt, bara genom att lägga till några rader kod i TestRunner.java fil som möjliggör initiering av parallellkörningen.

Vidare lärde vi oss hur man omvandlar den ursprungliga JUnit Test-rapporten till en gurka-rapport genom att integrera Gurka-rapportering plugin. Plugin tillåter oss att generera rapporter som har ett bättre användargränssnitt, är mycket mer begripliga för användaren och därmed ger en bättre användarupplevelse för de intressenter som dessa rapporter delas med.

Nu ska du kunna utföra en del grundläggande operationer, köra testfallet parallellt och skapa en lättläst rapport för användarna.

<