Denne vejledning er en introduktion til API-testning ved hjælp af Karate Framework. Lær om strukturen af Karate Test Script og trinene til at opbygge det første test script:
API er et akronym, der står for Application Programming Interface (API), og kan i enkle vendinger defineres som en softwareformidler, der gør det muligt at kommunikere mellem applikationer.
Vi har brug for API-testning, fordi:
- Resultaterne offentliggøres hurtigere, så du behøver ikke længere at vente på at se, om API'et fungerer korrekt.
- Med den hurtigere respons bliver implementeringen af disse API'er også hurtigere, hvilket giver mulighed for hurtig omsætningstid.
- Tidlig fejlopsporing, selv før appens brugergrænseflade er oprettet, giver os mulighed for at mindske risici og rette fejl.
- Mulighed for levering i stor skala inden for en kortere periode.
For at kunne arbejde med API-testning har vi forskellige værktøjer på markedet som Postman, Mocha og Chai. Disse har vist gode resultater og effektiv brug til test af API'er, men de er stærkt kodepåvirkede. For at kunne bruge dem skal man være teknisk velfunderet og fortrolig med programmeringssprog.
Karate Framework løser dette problem med de foregående softwareværktøjer på smukkeste vis.
Hvad er Karate Framework
Karate? Lad os tale om karate. Er det den fra Japan? Hvad tror du? Det kan være, at den store Bruce Lee har udviklet den i sin fritid.
Selv om vi gerne vil dykke ned i Karates interessante rødder, så lad os nu tale om de Karate værktøj som er udviklet af Peter Thomas , et af de fantastiske værktøjer, der kommer API-testere til undsætning.
Karate framework følger Cucumber-stilen til at skrive programmet, som følger BDD-tilgangen. Syntaksen er let at forstå for ikke-programmører. Og dette framework er det eneste API-testværktøj, der har kombineret API-automatisering og præstationstest i et enkelt selvstændigt værktøj.
Det giver brugerne mulighed for at udføre testcases parallelt og udføre JSON- og XML-kontroller.
Med disse oplysninger kan man udlede visse nøglepunkter for at forstå Karate-værktøjet nærmere:
- Karate er en BDD-testramme i stedet for en TDD-testramme.
- Den er designet til at være nem for ikke-programmører. Denne funktion er en afgørende ændring, da den giver mulighed for mere brug og adgang for mange mennesker uanset deres tekniske baggrund eller kapacitet.
- Den anvender Cucumber feature file og Gherkins-sproget til at skrive testen, som er meget let at forstå.
Alle disse funktioner gør det til et af de mest fordelagtige automatiseringsværktøjer, der findes i dag.
Historien om Karate Framework
Oprettet af ' Peter Thomas' Denne software, der blev udviklet i 2017, har til formål at gøre testfunktioner let tilgængelige for alle. Den blev skrevet i Java, og de fleste forventede, at filerne også ville være på samme sprog, men det er heldigvis ikke tilfældet.
Det bruger snarere Gherkins-filer, hvilket er et resultat af dets forhold til Cucumber-rammen. Automatiseringsprogrammet er en udvidelse af Cucumber og arver derfor brugen af Gherkins-filer i sin drift. Den store forskel mellem de to er, at Karate ikke bruger Java under testning, men det gør Cucumber.
Det er netop derfor, at den henvender sig til ikke-programmører, da Gherkins-syntaksen er superlæsbar og omfattende. Det er grunden til, at Karate er den mest velegnede og anbefalede løsning til at komme ind i verdenen af automatiseret API-testning.
Følgende er nogle af funktionerne i Karate Testing Framework:
- Gør brug af et letforståeligt Gherkins-sprog.
- Det kræver ingen teknisk programmeringskendskab som Java.
- Den er baseret på de populære Cucumber-standarder.
- Det er nemt at skabe en ramme.
- Parallel testning er den centrale funktionalitet, der leveres af Karate selv, og derfor behøver vi ikke at være afhængige af Maven, Gradle , osv.
- Brugergrænseflade til fejlfinding i testen.
- Kaldning af en feature-fil fra en anden fil.
- Giver støtte til datadrivertestning, der er bygget internt, og som derfor ikke behøver at være afhængig af eksterne rammer.
- Indbyggede Native Rest Reports. Desuden kan den integreres med Cucumber for bedre UI Reports og mere klarhed.
- Giver intern support til at skifte konfiguration på tværs af forskellige testmiljøer (QA, Stage, Prod, Pre-Prod).
- Problemfri understøttelse af CI/CD-integration, som kan være nyttig.
- Kan håndtere forskellige HTTP-opkald:
- Web Socket-understøttelse
- SOAP-anmodning
- HTTP
- Håndtering af cookies i browseren
- HTTPS
- HTML-formular data
- XML-anmodning
Sammenligning af Karate og Rest-Assured
Vær sikker : Det er et Java-baseret bibliotek til test af REST-tjenester. Det bruger Java-sproget til at skrive kodelinjerne. Det hjælper med at teste mange anmodningskategorier, hvilket yderligere resulterer i verifikation af forskellige kombinationer af forretningslogik.
Karate rammer : Et Cucumber/Gherkins-baseret værktøj, der bruges til test af SOAP- og REST-tjenester.
Følgende tabel viser nogle få mere fremtrædende forskelle mellem Rest-Assured & Karate Framework:
| S.nr. | Basis | Karate rammer | REST-sikret |
|---|---|---|---|
| 1 | Sprog | Der anvendes en kombination af agurk og agurker | Det gør brug af Java-sproget |
| 2 | Kode Størrelse | Normalt er kodelinjen mindre, da den følger en Cucumber-lignende struktur | Der er flere kodelinjer, da det indebærer brug af Java-sproget |
| 3 | Teknisk viden påkrævet | Ikke-programmører kan nemt skrive Gherkins-koden | Teknisk viden er nødvendig for at skrive Java-kode |
| 4 | Datadrevet testning | Behov for at gøre brug af TestNG eller tilsvarende for at understøtte det samme | Interne tags kan bruges til at støtte datatestning |
| 5 | Understøtter den SOAP-opkald? | Ja, det giver | Den er kun relateret til en REST-anmodning |
| 6 | Parallel afprøvning | Ja, parallel testning understøttes også nemt med den parallelle rapportgenerering | Ikke i stor udstrækning. Selv om folk har prøvet at gøre det, er fiaskoprocenten større end succesprocenten. |
| 7 | Rapportering | Den giver intern rapportering, og behøver derfor ikke at være afhængig af eksterne plugins. Vi kan endda integrere den med Cucumber-rapporteringsplugin for bedre brugergrænseflade. | Skal være afhængig af eksterne plugins som Junit, TestNG |
| 8 | CSV-understøttelse for eksterne data | Ja, fra Karate 0.9.0 | Nej, du skal bruge Java-kode eller bibliotek |
| 9 | Automatisering af brugergrænsefladen på nettet | Ja, fra Karate 0.9.5 er det muligt at automatisere Web-UI Automation | Nej, det er ikke understøttet |
| 10 | Eksempel på GET | Givet param val1 = 'name1' | givet(). |
Som det fremgår af ovenstående forskelle, kan man derfor roligt sige, at Karate er en af de nemmeste ting, som alle kan lave.
Værktøjer, der kræves for at arbejde med Karate Framework
Nu hvor vi har fået vores grundlæggende viden om Karate Framework på plads, kan vi se på de processer og værktøjer, der er nødvendige for at opsætte Karate-miljøet.
#1) Formørkelse
Eclipse er et integreret udviklingsmiljø, der bruges inden for computerprogrammering. Det bruges mest til Java-programmering. Som tidligere nævnt er Karate skrevet i Java, så det giver mere mening, hvorfor Eclipse er det bedste IDE til API-testsoftware. En anden grund er, at det er et open source-værktøj, og det er en ret stærk grund til at vælge dette værktøj.
Bemærk: Vi kan endda bruge IntelliJ, Visual Studio og andre forskellige editorer, der findes på markedet.
#2) Maven
Dette er et værktøj til automatiseret opbygning, der primært bruges til at opbygge Java-projekter. Det er en måde at opsætte et Karate-miljø og skrive koden på. For at opsætte din Eclipse med Maven-krav kan du klikke her for Maven-installation.
Når du arbejder i Maven, skal du bruge Maven-afhængigheder, der kan hjælpe dig med at understøtte Karate Framework.
Følgende afhængigheder vil blive brugt sammen med Maven i pom.xml.
com.intuit.karate karate-apache 0.9.5 test com.intuit.karate karate karate-junit4 0.9.5 test
Bemærk: De nyeste versioner kan være tilgængelige i Maven-repositoriet.
#3) Gradle
Gradle er et alternativ til Maven og kan bruges på samme måde. De har deres ligheder og forskelle, men kan bruges på samme måde til at opstille et miljø for vores Karate-koder.
Det er nemmere at bruge, fleksibelt og anbefales at bruge, når vores applikation har nogle krav til modularisering og administration med en masse plug-ins. Koden til Gradle-opsætning ville se nogenlunde sådan ud,
testCompile 'com.intuit.karate:karate-junit4:0.6.0' testCompile 'com.intuit.karate:karate-apache:0.6.0'
Bemærk: Du kan enten bruge MAVEN eller GRADLE.
#4) Opsætning af Java-miljøet i dit system
Du skal konfigurere JDK- og JRE-miljøet for at komme i gang med Karate Framework-scripts.
Strukturen af Karate Test Script
Et Karate-testscript er kendt for at have udvidelsen ".feature". Denne egenskab er arvet fra Cucumber. Organiseringen af filer i Java-konventioner er også tilladt. Du kan frit organisere dine filer i henhold til Java-pakkekonventionerne.
Maven-retningslinjerne anviser dog, at opbevaring af ikke-Java-filer skal ske separat. De opbevares i en src/test/ressourcer strukturen. Og Java-filerne opbevares under src/main/java .
Men ifølge skaberne af Karate Framework mener de, at det er vigtigt at opbevare både Java- og ikke-Java-filer side om side. Ifølge dem er det meget nemmere at finde *.java- og *.feature-filer, når de opbevares sammen, i stedet for at følge Maven-standardstrukturen.
Dette kan nemt gøres ved at justere din pom.xml som følger (for Maven):
src/test/java **/*.java ...
Nedenstående er en oversigt over den generelle struktur af Karate Framework:
Da denne Karate Framework bruger Runner-filen, som også er nødvendig i Cucumber for at køre feature-filerne, vil det meste af det skrevne følge Cucumber-standarderne.
Men i modsætning til Cucumber kræver trinene ikke en klar definition i Karate, hvilket igen øger fleksibiliteten og brugervenligheden. Vi behøver ikke at tilføje den ekstra lim, som vi normalt er nødt til at tilføje, når vi følger Cucumber-rammen.
"Runner"-klassen hedder for det meste TestRunner.java.
Derefter vil filen TestRunner.java få følgende form:
import com.intuit.karate.junit4.Karate; import org.junit.runner.RunWith; @RunWith(Karate.class) public class TestRunner { } Og når vi taler om den .feature filen indeholder alle de testscenarier, der skal testes for at sikre, at API'en fungerer som forventet.
En generel *.feature-fil ser ud som vist nedenfor:
Funktion: Hentning af brugeroplysninger Scenario: Test af hent-opkaldet til brugeroplysninger Givet url '//reqres.in/api/users/2' Når metode GET Så status 200
Oprettelse af det første grundlæggende script til Karate-test
Dette afsnit vil hjælpe dig med at komme i gang med at oprette dit allerførste testskript, som vil være nyttigt for dig til at konvertere API'er i form af en Karate-ramme.
Før vi skriver de grundlæggende Karate-testskripter, skal du installere følgende forudsætninger på din maskine:
- Eclipse IDE
- Maven. Indstil den relevante Maven-sti.
- JDK & JRE. Indstil den relevante sti.
Lad os se på den trinvise fremgangsmåde:
#1) Opret en ny MAVEN Projekt i Eclipse Editor
- Åbn Eclipse
- Klik på File. Vælg New Project.
- Vælg Maven-projekt
- Vælg placering af arbejdsområdet.
- Vælg arketype (normalt vælger vi " Maven-archetype-quickstart 1.1 " for simple Maven-projekter).
- Angiv gruppe-id & artefakt-id (vi har brugt følgende værdier i vores eksempel).
- Gruppe-ID : Karate
- Artefakt-ID: KarateTestScriptsSample
- Klik på Afslut for at afslutte installationen.
#2) Når den er oprettet, kan du nu se følgende struktur i vinduet Project Explorer.
#3) Medtag alle dine afhængigheder.
Vores allerførste skridt, efter opsætningen, vil være at inkludere alle afhængigheder Vi gemmer alle taggene under POM.xml (hvis du allerede kender til brugen af POM.xml).
- Åbn POM.xml, og kopier nedenstående kode under afhængighedstagget, og gem filen.
com.intuit.karate karate-apache 0.9.5 test com.intuit.karate karate karate-junit4 0.9.5 test
Klik her for at se kilden.
#4) Lad os brainstorme scenariet, hvad vi skal teste i dette Karate Basic Test Script.
Scenarie:
Vi skal teste en API med denne URL.
Sti: api/bruger/2
Metode: GET
Og vi er nødt til at validere , om anmodningen returnerer en Kode for succes (200) eller ej.
Vi tester ganske enkelt et API-eksempel for at se, om det bliver udført med succes eller ej.
Bemærk: Vi bruger en prøve-API, der er tilgængelig til test. Du kan vælge en hvilken som helst PATH eller henvise til din API.
Klik her for at se kilden.
#5) Vores næste skridt er nu at oprette en .feature fil.
Som omtalt i indledningen er det .feature-fil er den egenskab, der er arvet fra Cucumber. I denne fil vil vi skrive de testscenarier, der skal udføres for at udføre API-testningen.
- Gå til mappe src/test/java i dit projekt.
- Højreklik på den, og opret en ny fil - userDetails.feature. Klik derefter på knappen Afslut.
Nu vil du se følgende fil under mappen src/test/java
Grønt ikon ligner den .feature fi le i Cucumber, som vi netop har oprettet.
- Når filen er oprettet, skal vi nu skrive vores testscenarier, som vil blive gennemgået i det følgende afsnit.
#6) Da vi har scenariet og den tomme . funktion fil klar, lad os nu komme i gang med vores første script. Lad os begynde at kode
Skriv følgende kodelinje i filen userDetails.feature, som vi oprettede i trin 5:
Funktion: Hentning af brugeroplysninger Scenario: Test af hentningskaldet til brugeroplysninger Givet url '//reqres.in/api/users/2' Når metode GET Så status 200
Lad os prøve at forstå de komponenter, der er skrevet i ovenstående fil:
- Funktion: Nøgleord forklarer navnet på den funktion, vi tester.
- Baggrund: Dette er et valgfrit afsnit, der behandles som et afsnit om forudsætninger. Det kan bruges til at definere alt det, der er nødvendigt for at teste API'et. Det indeholder HEADER, URL & PARAM muligheder.
- Scenarie: Hver feature-fil, som du vil se, vil indeholde mindst én feature (selv om den kan give flere Det er beskrivelsen af testscenariet.
- Givet: Det er det trin, der skal udføres, før et andet testtrin udføres. Det er en obligatorisk handling, der skal udføres.
- Hvornår: Den angiver den betingelse, der skal være opfyldt for at udføre det næste testtrin.
- Derefter: Den fortæller os, hvad der skal ske, hvis den betingelse, der er nævnt i Når er opfyldt.
Bemærk: Alle de ovennævnte nøgleord er fra Gherkins-sproget. De er standardmetoden til at skrive testskripter med Cucumber.
Og nogle andre ord, der anvendes i feature-filen, er:
- 200: Det er den status/responskode, som vi forventer (Klik her for at se en liste over statuskoder)
- GET: Det er en API-metode som POST, PUT osv.
Vi håber, at denne forklaring var let for dig at forstå, og at du nu vil være i stand til at forstå, hvad der præcist står skrevet i ovenstående fil.
Nu skal vi oprette en TestRunner.java-fil
Som forklaret i ovenstående afsnit har Cucumber brug for en Runner-fil, som er nødvendig for at udføre .feature fil, der indeholder testscenarierne.
- Gå til mappe src/test/java i dit projekt
- Højreklik på den, og opret en ny Java-fil: TestRunner.java
- Når filen er blevet oprettet, placer følgende kodelinjer under den:
import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { } - Test Runner er den fil, der nu vil blive udført for at udføre det ønskede scenarie, som er blevet skrevet under trin 5.
#7) Nu er vi klar med begge filer TestRunner.Java og userDeatils.feature. Den eneste opgave, der er tilbage for os, er at Kør manuskriptet.
- Gå til filen TestRunner.java, og højreklik på filen som vist i nedenstående billede.
- Vælg Kør som -> Junit Test
- Når du har valgt det, kan du se, at testcasen nu er startet.
- Vent på, at testskriptet udføres. Når det er gjort, vil du se noget som vist på nedenstående billede i dit vindue.
- Endelig kan vi sige, at det er lykkedes os at skabe vores allerførste grundlæggende Testmanuskript ved hjælp af Karate Framework.
#8) Endelig giver Karate-rammen også en HTML-rapportpræsentation af den udførte udførelse.
- Gå til Target Folder -> surefire-reports-> Her vil du se din HTML-rapport, som du kan åbne.
** Vi foreslår også, at du åbner den samme med Chrome-browseren for at få et bedre udseende og en bedre fornemmelse.
- Følgende HTML-rapport vises for dig og viser Scenarier & Test der er blevet udført for det nævnte scenario:
Konklusion
I denne vejledning har vi diskuteret API-testning, forskellige testværktøjer på markedet og hvordan Karate Framework er en bedre løsning sammenlignet med andre værktøjer.
Vi fulgte en trinvis fremgangsmåde for at oprette vores første grundlæggende testskript. Vi startede med at oprette en grundlæggende Maven-projekt i Eclipse IDE for at oprette en .feature-fil, som indeholder alle testscenarierne og en Runner-fil til at udføre testcasen, der er nævnt i .feature-filen.
Ved afslutningen af de mange trin kan vi se en rapport over testresultaterne.
Vi håber, at denne vejledning var nyttig for begyndere, der skal lære at opbygge deres første testskripter ved hjælp af Karate Framework og udføre API-testning. Denne detaljerede trinvise fremgangsmåde er en fantastisk måde at køre og udføre forskellige test på API'et på.
NEXT>>