run test cases parallel generate reports using karate tool
Denne vejledning forklarer, hvordan man udfører nogle grundlæggende operationer på API'en, kører testcases parallelt og genererer rapporter med Karate Framework:
Vi har lært, hvordan man opretter et grundlæggende test script i vores tidligere tutorial, vi kan nu gå videre med at lære nogle grundlæggende operationer, der kan udføres, mens vi arbejder med API og Karate Framework. Der er mange sådanne operationer, og vi vil diskutere et par almindeligt anvendte i denne vejledning.
Vi skal også dykke ned i processen med at køre testsager parallelt ved at følge en trinvis tilgang. Vi vil også diskutere den aktuelle rapport, der bliver genereret automatisk, og sammenligne den med agurkerapporten, som vi kan generere ved at integrere et plugin.
Hvad du lærer:
- Arbejder med API og karate testværktøj
- Kør testtilfælde parallelt
- Integrer agurk plugin til rapportering
- Konklusion
Arbejder med API og karate testværktøj
Som diskuteret i den foregående vejledning, i .funktion fil, som vi havde oprettet, kunne vi bruge forskellige nøgleord til at udføre forskellige handlinger på API'en. Karate framework giver os flere nøgleord, der kan bruges til at udføre forskellige handlinger.
=> Anbefalet læsning: API-test med karate-ramme
Udfører forskellige operationer
# 1) Udskrivning af svaret i konsollen
Print er et nøgleord, der leveres af Karate Framework for at udskrive resultatet i konsollen eller filen. En af de mest almindelige anvendelser er at udskrive API-svaret. Dette kan være meget nyttigt for brugeren.
Vi kan gøre dette ved at bruge følgende kodelinjer:
Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #We are printing the Response of the API using the print keyword# Then print response
Ovenstående kodelinjer giver følgende output:
18:15:44.495 [main] INFO com.intuit.karate - [print] { 'ad': { 'company': 'StatusCode Weekly', 'text': 'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url': 'http://statuscode.org/' }, 'data': { 'last_name': 'Weaver', 'id': 2, 'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name': 'Janet', 'email': 'janet.weaver@reqres.in' } }
Sådan kan vi udskrive svaret fra API'et i konsollen til læseformålet, som kan bruges på tidspunktet for fejlfinding.
# 2) Erklæring om variablerne
Vi kan erklære variablerne ved hjælp af nøgleordet def i Karate-rammen, og brug derefter de deklarerede variabler i koden, hvor det er nødvendigt.
I nedenstående eksempel har vi tilføjet et par flere kodelinjer til den eksisterende userDetails.feature fil for at hjælpe med at erklære variablerne i scriptet.
Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #We are printing the Response of the API using the print keyword Then print response # Declaring and assigning a string value: Given def varName = 'value' # using a variable Then print varName
# 3) Påstand om det faktiske svar på det forventede svar
Karate Framework hjælper med at udføre de påstande relaterede operationer ved hjælp af match nøgleord. Det match er smart, fordi hvidt rum ikke betyder noget for det, og rækkefølgen af tasterne er ikke vigtig.
Til brug match søgeord, vi er nødt til at gøre brug af dobbelt-ligetegnet “==”, der repræsenterer en sammenligning.
Nu vil vi forsøge at uddybe nogle anvendelser af match nøgleord.
a) Når hele det forventede svar er nævnt i selve .feature-filen.
På bestemte tidspunkter har vi nogle data, som vi gerne vil validere med det samme i selve filen. Normalt nævnes sådanne slags data under fejlretning af koden.
Vi kunne gøre det samme i selve .feature-filen som vist nedenfor:
Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Asserting the reponse #response variable is holding the Actual response from API #Right hand side value is holding the expected Response And match response == {'ad':{'company':'StatusCode Weekly','text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.','url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg','first_name':'Janet', 'email':'janet.weaver@reqres.in'}}
Hvis du sender en anmodning til URL'en 'Https://reqres.in/api/users/2' i browseren du får følgende svar:
{ 'ad': { 'company': 'StatusCode Weekly', 'text': 'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url': 'http://statuscode.org/' }, 'data': { 'last_name': 'Weaver', 'id': 2, 'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name': 'Janet', 'email': 'janet.weaver@reqres.in' } }
Vi prøver at validere ovennævnte svar ved hjælp af * .feature-filen.
Vi har brugt match nøgleord, der leveres af Karate Framework, som hjælper med at udføre forskellige slags Påstande i API-svaret.
Bemærk : Vi bliver nødt til at omdanne API-svaret i en linje for at udføre ovenstående trin. Du kan bruge et hvilket som helst af de tilgængelige værktøjer online.
b) Når den forventede output gemmes i en ekstern JSON-fil.
I ovenstående eksempel diskuterede vi et scenario, hvor vi havde begrænsede data og det samme svar, der var let at håndtere, men i de virkelige scenarier vil vi have gigantiske sæt JSON-svar, som vi muligvis skal evaluere.
Så i disse tilfælde er det bedre at beholde svaret i den eksterne fil og derefter kontrollere det samme.
I nedenstående eksempel vil vi yderligere diskutere det samme:
- Brug for at oprette en ExpectedOutput.json fil i vores projektmappe som vist i nedenstående billede.
Opret en ny pakkeressource -> Opret en ny fil ExpectedOutput.json
Og gem JSON-svaret i denne fil, og gem det.
Du bliver nødt til at skrive følgende kode i din userDetails.feature fil:
Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Verifying the JSON response by providing same in feature file And match response == {'ad':{'company':'StatusCode Weekly','text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.','url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg','first_name': 'Janet','email':'janet.weaver@reqres.in'}} #Reading the file ExpectedOutput.json and storing same response in variable expectedResult Given expectedResult=read('./resources/ExpectedOutput.json') #Asserting the Actual Response with the Expected Response And match response == expectedResult
I ovenstående eksempel læser vi først filen ExpectedOutput.json og lagring af svaret på den i variablen forventet resultat bruger følgende kodelinjer:
Given expectedResult=read('./resources/ExpectedOutput.json')
Derefter placerer vi påstanden ved hjælp af følgende kodelinjer, hvor vi matcher Faktisk reaktion med forventet resultat svar med “ == ' operatør.
And match response == expectedResult
c) Matching / verificering af bestemte værdier fra svaret
Indtil nu har vi bekræftet hele API'ets svar, men hver gang ønsker du ikke at bekræfte hele svaret. Nogle gange vil du kun evaluere en del af svaret. Normalt gør vi det samme, når vi bruger de andre værktøjer til API-test eller mens vi opretter en ramme.
For at forstå det yderligere, lad os tage følgende JSON-svar som et eksempel:
{ 'ad': { 'company': 'StatusCode Weekly' } }
Hvis vi vil kontrollere, at parameteren Selskab skal have værdien som StatusCode ugentligt, så bliver vi nødt til at oprette en JSON-sti. Dette kan gøres ved at krydse JSON-filen og bruge “.” (Punktoperatør)
JSON-stien til ovenstående svar vil være:
ad.company == “StatusCode Ugentlig”
Nedenfor er kodestykket, som hjælper os med at evaluere værdierne for den bestemte parameter. Denne kode hører til .funktion fil.
Feature: fetching User Details Scenario: testing the get call for User Details Given url 'https://reqres.in/api/users/2' When method GET Then status 200 #Verifying the JSON response by providing same in feature file And match response == {'ad':{'company':'StatusCode Weekly', 'text':'A weekly newsletter focusing on software development, infrastructure, the server, performance, and the stack end of things.', 'url':'http://statuscode.org/'},'data':{'last_name':'Weaver','id':2,'avatar': 'https://s3.amazonaws.com/uifaces/faces/twitter/josephstein/128.jpg', 'first_name':'Janet','email':'janet.weaver@reqres.in'}} #Reading the file ExpectedOutput.json and storing same response in variable expectedResult Given expectedResult=read('./resources/ExpectedOutput.json') #Asserting the Actual Response with the Expected Response And match response == expectedResult ##Creating JSON path to verify the values of particular parameters## And match response.ad.url == 'http://statuscode.org/' And match response.data.first_name == 'Janet'
Nedenfor er kodelinjen, der udfører de parametriske påstande.
And match response.ad.url == 'http://statuscode.org/' And match response.data.first_name == 'Janet'
Ved hjælp af JSON-stien evaluerer vi værdierne for parametrene.
Udfører postoperationer
Indtil nu har vi dækket de grundlæggende scenarier for at teste en API, da metoden var “ FÅ'. Men når vi arbejder i det virkelige miljø, er vi nødt til at sende en masse information til serveren, så i så fald bruger vi “ STOLPE' metode .
Dette afsnit giver dig et indblik i at arbejde med den grundlæggende POST-anmodning.
Lad os få nogle korte ideer om de parametre, som vi har brug for til at sende POST-anmodningen.
# 1) Oprettelse af en POST-anmodning, når JSON-kroppen er nævnt i * .feature-filen
- Opret en userDetailsPost.feature ved hjælp af de lignende trin nævnt i den foregående tutorial.
- Skriv følgende kodelinjer:
Feature: Posting User Details Scenario: testing the POST call for User Creation Given url 'https://reqres.in/api/users' And request '{'name': 'morpheus','job': 'leader'}' When method POST Then status 201
Da det er en POST-anmodning, som altid skal ledsages af et organ, der skal sendes til serveren for et bestemt svar, har vi nævnt det under følgende komponent:
anmodning: Det tager et JSON-organ som den anmodning, der kræves med POST-metoden.
# 2) Oprettelse af en POST-anmodning, når JSON-kroppen er nævnt i en ekstern fil
Normalt vil vi have et stort anmodningsorgan, som det ville være vanskeligt at nævne i * .funktion fil. Så det er bedre at gemme den i den eksterne fil.
- Brug for at oprette en PostBody.json-fil i vores projektmappe som vist nedenfor. Opret en ny pakkeressource -> Opret en ny fil PostBody.json, og gem JSON Body i denne fil, og gem den.
Bemærk: Vi har nævnt POST-metoden i ovenstående JSON-fil.
- Du bliver nødt til at skrive følgende kode i din userDetailsPost .funktion fil:
Feature: Posting User Details Scenario: testing the POST call for User Creation using External File Given url 'https://reqres.in/api/users' Given postBody=read('./resources/PostBody.json') And request postBody When method POST Then status 201
Vi læser JSON Body fra PostBody.json ved hjælp af følgende kodelinjer:
Given postBody=read('./resources/PostBody.json')
Bemærk: Alle userDeatils.feature filer, som vi hidtil har oprettet, kræver det grundlæggende TestRunner.java fil til at udføre dem, som vi oprettede i vores Basic Test Script tutorial som vist nedenfor:
import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { }
Kør testtilfælde parallelt
Nu, da vi har lært trinnene til at oprette et grundlæggende test script og udført nogle grundlæggende operationer på API'en, er det tid til at komme i gang med at arbejde i det faktiske miljø.
Normalt skal vi køre testsagerne parallelt for at gøre udførelsen hurtigere. Grundlæggende er ideen at få mere output på kortere tid.
Dette er et kerneelement i rammen og afhænger ikke af JUnit, Maven eller Grade. Det giver os mulighed for at:
- Vælg nemt funktionerne og koderne for at køre testpakker på en enkel måde.
- Se parallelle resultater under mappen surefire-plugin.
- Vi kan endda integrere Cucumber JSON-rapporterne for bedre brugergrænseflade (som snart vil blive diskuteret).
I Karate Framework behøver vi ikke udføre mange trin for at starte den parallelle udførelse af vores testsager. Vi skal bare gennemgå følgende trin:
1) Vi er nu nødt til at ændre TestRunner.java fil, som vi har brugt indtil nu. Koden til parallel udførelse skal skrives i ovenstående fil.
Husk følgende linje, mens du udfører din kode i Parallel:
fri grammatikkontrol bedre end grammatik
** Vi kan ikke bruge @RunWith (Karate.class) -kommentarer, når vi prøver at arbejde i et parallelt miljø.
Åbn originalen TestRunner.java fil og brug følgende kode nu:
import com.intuit.karate.Results; import com.intuit.karate.Runner; import org.junit.Test; // important: do not use @RunWith(Karate.class) ! public class TestRunner { @Test public void testParallel() { Results results = Runner.parallel(getClass(),5); } }
** Følgende kode gælder for JUnit 4 Maven afhængighed
I kodestykket ovenfor har vi inkluderet nedenstående kodelinje-
Resultater resultater = Runner.parallel (getClass (), 5);
Denne linje instruerer at køre forekomsten af testkasserne parallelt ved dynamisk at hente klasser på løbetiden.
to) Opret et duplikat userDetails.feature filen som nævnt nedenfor under src / test / java folder.
Nu er vi klar til Parallel-udførelse med to . funktioner fil.
3) Gå til TestRunner.java fil oprettet i ovenstående trin og kør det som JUnit Test. Med dette vil vi udføre vores testsager i parallelformat.
For nem læsbarhed præsenteres nogle oplysninger af Karate Framework i konsollen, når testudførelsen er afsluttet.
Resultatet ser ud som følgende:
Med den parallelle udførelse udføres alle funktionerne parallelt, og scenarierne kører også i et parallelt format.
Ved at følge ovenstående trin vil du være i stand til at starte den meget grundlæggende parallelle udførelse af API-testen ved hjælp af Karate Framework.
** Du kan studere om parallel test ved at gennemgå de forskellige filtre på siden Parallel udførelse
Integrer agurk plugin til rapportering
Som vi bruger JUnit-løber til udførelse af forskellige scenarier, der er nævnt i de forskellige * .funktion filer opretter den automatisk en rapport for hver af de funktionsfiler, der er gemt i stien mål / sikkerhedsrapporter.
Det genererer en Grundlæggende UI-formateret rapport til præsentation af de eksekverede testsager.
Men de rapporter, der bliver genereret, er ikke særlig glædelige med hensyn til brugergrænsefladen, og for at dele rapporter med interessenterne har vi brug for noget, der er mere brugervenligt og let forståeligt.
For at opnå et sådant rapporteringsformat giver Karate Framework mulighed for at integrere Agurk-rapporterings-plugin som vil hjælpe os med at generere en grafisk formateret rapport, som vil være mere præsentabel.
Følgende er trinene til integration af det samme:
# 1) Tilføj følgende Agurk-rapportering afhængighed af din POM.xml
net.masterthought cucumber-reporting 3.8.0 test
#to) Rediger TestRunner.java-filen, når der kun er en enkelt * .funktion fil i projektet.
Vi har brug for at opdatere vores TestRunner.java-fil med følgende generereReport () -metode til agurk-pluginet.
public class TestRunner { @Test public void testParallel() { generateReport(results.getReportDir()); assertTrue(results.getErrorMessages(), results.getFailCount() == 0); } public static void generateReport(String karateOutputPath) { Collection jsonFiles = FileUtils.listFiles(new File(karateOutputPath), new String[] {'json'}, true); final List jsonPaths = new ArrayList(jsonFiles.size()); jsonFiles.forEach(file -> jsonPaths.add(file.getAbsolutePath())); Configuration config = new Configuration(new File('target'), 'demo'); ReportBuilder reportBuilder = new ReportBuilder(jsonPaths, config); reportBuilder.generateReports(); } }
I ovennævnte kode udfører vi følgende handlinger:
- Oprettelse af en ny filforekomst
- Tilvejebringelse af stien til lagring af filerne under målmappen
- Oprettelse af et ReportBuilder-objekt, der opretter en ny agurkerapport
Bemærk : Ovenstående kode fungerer fint, når vi har single *. funktion fil i vores projekt.
# 3) Rediger TestRunner.java-filen, når der er flere * .funktion filer i projektet.
Vi bliver nødt til at tilføje en linje kode (fremhævet med fed skrift nedenfor) for at sikre, at parallel udførelse bliver taget hånd om, mens scenarierne udføres til rapportgenerering.
public class TestRunner { @Test public void testParallel() { System.setProperty('karate.env', 'demo'); // ensure reset if other tests (e.g. mock) had set env in CI Results results = Runner.parallel(getClass(),5); generateReport(results.getReportDir()); assertTrue(results.getErrorMessages(), results.getFailCount() == 0); } public static void generateReport(String karateOutputPath) { Collection jsonFiles = FileUtils.listFiles(new File(karateOutputPath), new String[] {'json'}, true); final List jsonPaths = new ArrayList(jsonFiles.size()); jsonFiles.forEach(file -> jsonPaths.add(file.getAbsolutePath())); Configuration config = new Configuration(new File('target'), 'demo'); ReportBuilder reportBuilder = new ReportBuilder(jsonPaths, config); reportBuilder.generateReports(); } }
Efter at have udført de ovennævnte trin, vil vi være i stand til at oprette en velrepræsenteret grafisk brugergrænsefladesrapport med succes Agurk - rapportering plugin.
Vi kan finde rapporten på følgende vej i vores projekt som vist på billedet nedenfor:
Følgende rapport blev genereret til vores projekt for alle de operationer, vi indtil nu har udført i denne Karate Framework Tutorial:
Konklusion
For at opsummere har vi i denne vejledning diskuteret de grundlæggende operationer, der er nyttige dagligt, mens vi arbejder med Karate Framework og hvordan man udfører flere * .feature-filer parallelt. Vi lærte også at oprette en grafisk rapport til brugerne ved hjælp af Agurk rapportering plugin.
Først diskuterede vi de grundlæggende operationer, der kan udføres på API'en. Vi diskuterede, hvordan vi kan sende POST-kroppen / anmodningen til serveren enten ved at nævne kroppen i selve * .feature-filen (som normalt ikke er en anbefalet praksis) eller ved at bruge en ekstern fil (en anbefalet praksis for at opretholde en ren kode).
For det andet, efter at have fulgt et par grundlæggende trin, kunne vi med succes udføre testresultatet for to * .funktion filer, der blev udført parallelt, bare ved at tilføje et par kodelinjer i TestRunner.java fil, der muliggør initiering af parallelkørslen.
Ud over dette lærte vi, hvordan man omdanner den oprindelige JUnit Test-rapport til en agurkerapport ved at integrere Agurk-rapportering plugin. Pluginet giver os mulighed for at generere rapporter, der har en bedre brugergrænseflade, er meget mere forståelige for brugeren og dermed give en bedre brugeroplevelse for de interessenter, som disse rapporter deles med.
Nu skal du være i stand til at udføre nogle grundlæggende operationer, køre testsagerne parallelt og generere en letlæselig rapport til brugerne.
Anbefalet læsning
- Karate Framework Tutorial: Automatiseret API-test med karate
- 10 bedste API-testværktøjer i 2021 (SOAP og REST API-testværktøjer)
- Sådan køres agurk med Jenkins: Vejledning med eksempler
- Vejledning til generering af omfattende rapporter i Selen WebDriver
- Specflow-rapportering: Sådan genereres testrapporter og udføres selektive tests
- Sådan håndteres krav, udfører testtilfælde og genererer rapporter ved hjælp af TestLink - Vejledning nr. 2
- Kørsel af dine appiumtests parallelt med Appium Studio til Eclipse
- Sådan køres udførelse i stor skala af appiumtests parallelt