Karate Framework Tutorial: Automated API Testing With Karate

karate framework tutorial

Denna handledning är en introduktion till API-testning med hjälp av Karate Framework. Lär dig mer om strukturen i Karate Test Script och steg för att bygga det första testskriptet:

API är en akronym som står för Application Programming Interface. Enkelt uttryckt kan vi definiera det som en mjukvaruförmedlare som tillåter kommunikation mellan applikationer.

Vi behöver API-testning eftersom:

• Resultaten publiceras snabbare, därmed inte längre väntar på att se om API: n fungerar bra.
• Med det snabbare svaret blir implementeringen av dessa API: er också snabbare, vilket möjliggör snabb omloppstid.
• Tidig upptäckt av fel, även innan appens användargränssnitt skapas, tillåter oss att mildra risker och rätta till fel.
• Storskalig leverans möjlig på kortare tid.

För att kunna arbeta med API-testning har vi olika verktyg tillgängliga på marknaden som Postman, Mocha och Chai. Dessa har visat bra resultat och effektiv användning för att testa API: er, men dessa är starkt kodpåverkade. För att kunna använda dessa måste man vara tekniskt sund och bekant med programmeringsspråk.

Karate Framework löser vackert denna fråga av sina tidigare programvaruverktyg.

Vad du kommer att lära dig:

• Vad är karate-ramverk
  • Karate-ramverkets historia
• Jämföra Karate Vs Rest-Assured
  • Verktyg som krävs för att arbeta med Karate Framework
  • Strukturen av Karate Test Script
  • Skapa det första grundläggande karate-testmanuset
• Slutsats
  • Rekommenderad läsning

Vad är karate-ramverk

Karate? Låt oss prata Karate. Är det den från Japan? Vad tror du? Det kan vara så att den stora Bruce Lee hade utvecklat detta på sin fritid.

Även om vi vill gräva i Karate intressanta rötter, låt oss för närvarande prata om Karate verktyg som har utvecklats av Peter Thomas , ett av de fantastiska verktygen som räddar API-testare.

Karate-ramverket följer gurka för att skriva programmet som följer BDD-metoden. Syntaksen är lätt att förstå av icke-programmerare. Och detta ramverk är det enda API-testverktyget som har kombinerat API-automatisering och prestandatestning till ett enda fristående verktyg.

Det ger användarna möjlighet att utföra testfall i Parallel och utföra JSON & XML-kontroller.

Med denna information kan vissa viktiga punkter dras för att ytterligare förstå Karate-verktyget i detalj:

• Karate är ett BDD-testramverk istället för en TDD.
• Den är utformad för att vara lätt för icke-programmerare. Denna funktion är en spelväxlare eftersom den möjliggör mer användning och åtkomst för många människor oavsett deras tekniska bakgrund eller kapacitet.
• Det använder sig av gurkafunktionsfilen och agurkspråket för att skriva testet som är mycket lätt att förstå.

Alla dessa funktioner gör det till ett av de mest gynnsamma automatiseringsverktygen som finns idag.

Karate-ramverkets historia

Skapad av ' Peter Thomas ' 2017 syftar den här programvaran till att göra testfunktioner tillgängliga för alla. Det skrevs på Java och de flesta förväntade att filerna också skulle vara på samma språk, men lyckligtvis är det inte så.

Snarare använder den Gherkins-filer, vilket är ett resultat av dess förhållande till gurkastrukturen. Automationsprogramvaran är en förlängning av gurka och ärver därför användningen av Gherkins-filen i sin verksamhet. Den stora skillnaden mellan de två är att Karate inte använder Java under testning, men Gurka gör det.

Detta är just anledningen till att det riktar sig till icke-programmerare eftersom Gherkins-syntaxen är superläsbar och omfattande. Detta är anledningen till att Karate är mest lämplig och rekommenderas för att göra ett inträde i världen av automatiserad API-testning.

Följande är några funktioner i Karate Testing Framework:

• Använder lättförståeligt gurka-språk.
• Det kräver ingen teknisk kunskap om programmering som Java.
• Den är baserad på de populära gurkastandarderna.
• Lätt att skapa en ram.
• Parallell testning är kärnfunktionaliteten som tillhandahålls av Karate själv, därför behöver vi inte vara beroende av Maven, Gradle , etc.
• UI för felsökning av testet.
• Ringa en funktionsfil från en annan fil.
• Ger stöd för datadrivrutintestning som är inbyggd internt, följaktligen inget behov av att bero på externa ramar.
• Inbyggda Native Rest-rapporter. Dessutom kan den integreras med gurkan för bättre UI-rapporter och mer tydlighet.
• Ger internt stöd för att byta konfiguration över olika testmiljöer (QA, Stage, Prod, Pre-Prod).
• Sömlöst stöd för CI / CD-integration som kan vara användbart.
• Kan hantera olika HTTP-samtal:
  • Stöd för webbuttag
  • SOAP-begäran
  • HTTP
  • Hantering av webbläsarkakor
  • HTTPS
  • HTML-formdata
  • XML-begäran

Jämföra Karate Vs Rest-Assured

Var så säker : Det är ett Java-baserat bibliotek för att testa REST-tjänsterna. Det använder Java-språk för att skriva kodrader. Det hjälper till att testa många förfrågningskategorier, vilket ytterligare resulterar i verifiering av olika affärslogikkombinationer.

Karate-ramverk : Ett gurka / agurkbaserat verktyg som används för testning av SOAP & REST-tjänster.

I följande tabell listas några mer framträdande skillnader mellan Rest-Assured & Karate Framework:

Således, vilket visas av skillnaderna ovan, är det säkert att säga att Karate är en av de enklaste sakerna som alla kan göra.

Verktyg som krävs för att arbeta med Karate Framework

Nu, eftersom vi har vår grundläggande kunskap om Karate Framework på plats, låt oss titta på de processer och verktyg som krävs för att skapa Karate-miljön.

# 1) förmörkelse

Eclipse är en integrerad utvecklingsmiljö som används inom datorprogrammering. Det används mest för Java-programmering. Som nämnts tidigare är Karate skrivet i Java, så det är mer meningsfullt varför Eclipse är den gå-till-IDE för API-testprogramvaran. En annan anledning är att det är ett verktyg med öppen källkod, och detta är en ganska stark anledning att välja det här verktyget.

Notera: Vi kan till och med använda IntelliJ, Visual Studio och andra olika redaktörer som finns tillgängliga på marknaden.

# 2) Maven

Detta är ett verktyg för att bygga automatisering som främst används för att bygga Java-projekt. Det är ett sätt att skapa en karate-miljö och skriva koden. För att ställa in din Eclipse med Maven-krav kan du klicka här för installation av Maven.

När du arbetar i Maven, använd Maven-beroenden som hjälper dig att stödja Karate Framework.

Följande beroenden kommer att användas med Maven i pom.xml.

Notera: De senaste versionerna kan finnas i Maven-arkivet.

merge sort c ++ exempel

# 3) Gradle

Gradle är ett alternativ till Maven och kan användas i lika stor kapacitet. De har sina likheter och skillnader men kan också användas för att skapa en miljö för våra karatekoder.

Det är lättare att använda, flexibelt och rekommenderas att använda när vår applikation har vissa modulerings- och hanteringskrav med en massa plugin-program. Gradle-installationskoden skulle se ut så här,

Notera: Du kan antingen använda MAVEN eller GRADLE.

# 4) Installation av Java-miljö i ditt system

Behöver du ställa in JDK- och JRE-miljön för att komma igång med Karate Framework-skript.

Strukturen av Karate Test Script

Ett Karate-testmanus är känt för innehavet av tillägget '.feature'. Den här egenskapen ärvs från gurka. Organisationen av filer i Java-konventionen är också tillåten. Du är fri att organisera dina filer enligt Java-paketkonventionerna.

I Maven-riktlinjerna anges dock att lagring av icke-Java-filer ska göras separat. De görs i en src / test / resurser strukturera. Och Java-filerna hålls under src / main / java .

Men enligt skaparna av Karate Framework tror de starkt att vi håller både Java- och icke-Java-filer sida vid sida. Enligt dem är det mycket lättare att se upp för * .java- och * .feature-filerna när de hålls ihop, snarare än att följa Maven-standardstrukturen.

Detta kan enkelt göras genom att justera din pom.xml enligt följande (For Maven):

Nedan följer en översikt över den allmänna strukturen i Karate Framework:

Nu, eftersom detta Karate Framework använder Runner-filen, vilket också behövs i Gurka för att köra funktionsfilerna, så det mesta av skrivningen följer Gurka-standarderna.

Men till skillnad från gurka kräver stegen inte en tydlig definition i Karate och som i sin tur förbättrar flexibiliteten och användarvänligheten. Vi behöver inte lägga till det extra limet som vi brukar lägga på när vi följer gurkaramen.

Klassen “Runner” heter mestadels TestRunner.java.

Då tar TestRunner.java-filen form av:

Och prata om .funktion filen innehåller alla testscenarier som behöver testas för att säkerställa att API: et fungerar enligt de förväntade kraven.

En allmän * .funktionsfil ser ungefär ut som visas nedan:

Skapa det första grundläggande karate-testmanuset

Detta avsnitt hjälper dig att komma igång med skapandet av ditt allra första testskript, vilket kommer att vara till hjälp för dig att konvertera API: er i form av ett karate-ramverk.

Innan vi skriver de grundläggande Karate-testmanusen, vänligen installera följande krav på din maskin:

• Förmörkelse IDE
• Maven. Ställ in lämplig Maven-väg.
• JDK & JRE. Ställ in rätt väg.

Låt oss ta en titt på steg-för-steg-metoden:

# 1) Skapa en ny MAVEN Projekt i Eclipse Editor

• Öppna Eclipse
• Klicka på Arkiv. Välj Nytt projekt.

• Välj Maven Project

• Välj arbetsytans plats.
• Välj arketyp (vanligtvis väljer vi “ Maven-archetype-quickstart 1.1 ”För enkla Maven-projekt).
• Ange grupp-ID och artefakt-ID (vi har använt följande värden i vårt exempel).
  • Grupp-ID : Karate
  • Artefakt-ID: KarateTestScriptsSample
• Klicka på Slutför för att slutföra installationen.

#två) När du väl har skapat kan du se följande struktur i Project Explorer-fönstret.

# 3) Inkludera alla dina beroende.

Vårt första steg, efter installationen kommer vi att vara inkludera alla beroenden som krävs för utförandet. Vi kommer att behålla hela taggen under POM.xml (förutsatt att du redan är medveten om POM.xml-användningen).

• Öppna POM.xml och kopiera nedanstående kod under beroendetaggen och spara filen.

Klick här för källa.

# 4) Låt oss brainstorma scenariot, vad ska vi testa i detta Karate Basic Test Script.

Scenario:

Vi kommer att testa ett API med detta URL.

Väg: api / användare / 2

Metod: SKAFFA SIG

Och vi måste validera , om begäran returnerar a Framgångskod (200) eller inte.

Enkelt uttryckt ska vi bara testa ett API-exempel för att se om det körs framgångsrikt eller inte.

Notera: Vi tar ett exempel-API som är tillgängligt för testning. Du kan välja vilken som helst PATH eller hänvisa till ditt API.

Klick här för källa.

# 5) Nu skulle vårt nästa steg vara att skapa en .funktion fil.

Som diskuterades i introduktionsavsnittet, .funktionsfil är den egendom som har ärvts från Gurka. I den här filen kommer vi att skriva ut de testscenarier som måste köras för att utföra API-testning.

• Gå till Mapp src / test / java i ditt projekt.

• Högerklicka på den och skapa en ny fil - userDetails.feature. Klicka sedan på Slutför-knappen.

Nu ser du följande fil under mappen src / test / java

De Grön färgad ikon liknar .funktion fi le i Gurka som vi just skapade.

• När filen har skapats kommer vi nu att skriva våra testscenarier som kommer att diskuteras i följande avsnitt.

# 6) Eftersom vi har scenariot och tomt. funktion fil klar, låt oss nu komma igång med vårt första skript. Låt oss börja koda

Skriv följande rad kod under userDetails.feature-filen som vi skapade i steg # 5:

Låt oss försöka förstå komponenterna som är skrivna i ovanstående fil:

• Funktion: Nyckelord förklarar namnet på funktionen vi testar.
• Bakgrund: Det här är ett valfritt avsnitt som behandlas som ett avsnitt som är nödvändigt. Detta kan användas för att definiera vad allt behövs för att testa API: et. Det innehåller HEADER, URL & PARAM alternativ.
• Scenario: Varje funktionsfil som du ser kommer att ha minst en funktion (även om den kan ge flera olika scenarier). Det är beskrivningen av testfallet.
• Given: Det är steget som måste utföras innan något annat teststeg utförs. Det är en obligatorisk åtgärd som ska utföras.
• När: Den anger villkoret som ska uppfyllas för att utföra nästa teststeg.
• Sedan: Det berättar för oss att vad som ska hända om det tillstånd som nämns i När är nöjd.

Notera: Alla ovannämnda nyckelord är från Gherkins-språket. Det här är det vanliga sättet att skriva testskript med gurka.

Och några fler ord som används i funktionsfilen är:

• 200: Det är den status / svarkod som vi förväntar oss (klicka på här för listan över statuskoder)
• SKAFFA SIG: Det är API-metoden som POST, PUT, etc.

Vi hoppas att den här förklaringen var lätt att förstå. Nu kommer du att kunna relatera till vad som exakt står i ovanstående fil.

Nu måste vi skapa en TestRunner.java-fil

Som förklaras i ovanstående avsnitt behöver gurka en Runner-fil som krävs för att köra .funktion fil som innehåller testscenarierna.

• Gå till Mapp src / test / java i ditt projekt

• Högerklicka på den och skapa en ny Java-fil: TestRunner.java
• När filen har skapats, placera följande kodrader under den:

• Test Runner är filen som nu kommer att köras för att utföra det önskade scenariot som har skrivits under steg # 5.

# 7) Nu är vi redo med båda filerna TestRunner.Java och userDeatils.feature. Den enda uppgiften kvar för oss är att Springa manuset.

• Gå till TestRunner.java-filen och högerklicka på filen som visas i bilden nedan.

bästa programvaran för virtuell maskin för Windows 10

• Välj Kör som -> Junit-test
• När du väl har valt kommer du att börja observera att testfallet nu har startat.
• Vänta tills testskriptet körs. När du är klar kommer du att observera något som visas i bilden nedan i ditt fönster.

• Slutligen kan vi säga att vi framgångsrikt har skapat vår allra första bas Testa skript använda Karate-ramverk.

# 8) Till sist ger Karate-ramverket också en HTML-rapportpresentation för utförandet som har utförts.

• Gå till målmapp -> säkerhetsrapporter-> Här ser du din HTML-rapport som du kan öppna.

** Vi föreslår också att du öppnar samma med hjälp av Chrome-webbläsaren för ett bättre utseende.

• Följande HTML-rapport visas för dig som visar Scenarier och test som har utförts för det nämnda scenariot:

Slutsats

I denna handledning har vi diskuterat API-testning, olika testverktyg som finns på marknaden och hur Karate Framework är ett bättre alternativ jämfört med dess motsvarigheter.

Vi följde en steg-för-steg-metod för att skapa vårt första grundläggande testskript. Vi började med att skapa en bas Maven-projekt i Eclipse IDE för att skapa en .feature-fil, som innehåller alla testscenarier och en Runner-fil för att utföra testfallet som nämns i .feature-filen.

I slutet av flera steg kunde vi se exekveringsrapporten för testresultaten.

Vi hoppas att den här guiden var till hjälp för nybörjare att lära sig att bygga sitt första testskript med hjälp av Karate Framework och utföra API-testning. Det här detaljerade steg-för-steg-tillvägagångssättet är ett underbart sätt att köra och utföra olika tester på API: et.

NÄSTA >>

Rekommenderad läsning

• Så här ställer du in Node.js Testing Framework: Node.js Tutorial
• Parasoft SOAtest Tutorial: Scriptless API Testing Tool
• Mockito Tutorial: Mockito Framework for Mocking in Unit Testing
• API Testing Tutorial: En komplett guide för nybörjare
• TestNG Tutorial: Introduktion till TestNG Framework
• Jest Tutorial - JavaScript-enhetstestning med Jest Framework
• Handledning med destruktiv testning och icke-destruktiv testning
• Hur använder jag Postman för att testa olika API-format?