Menu

Spouštějte testovací případy paralelně a generujte zprávy pomocí nástroje Karate

  • Hlavní
  • Jiný
  • Spouštějte testovací případy paralelně a generujte zprávy pomocí nástroje Karate

run test cases parallel generate reports using karate tool

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

bezplatný optimalizátor systému pro Windows 7

Tento kurz vysvětluje, jak provádět některé základní operace s API, paralelně spouštět testovací případy a generovat zprávy pomocí Karate Framework:

Naučili jsme se, jak vytvořit základní testovací skript v našem předchozím kurzu, nyní můžeme pokročit s učením některých základních operací, které lze provádět při práci s API a Karate Framework. Existuje mnoho takových operací a v tomto tutoriálu probereme několik běžně používaných operací.

Rovněž se ponoříme do procesu paralelního běhu testovacích případů pomocí postupného přístupu. Budeme také diskutovat o aktuální zprávě, která se generuje automaticky, a porovnáme ji se zprávou Okurka, kterou můžeme vygenerovat integrací pluginu.

Provádění různých operací, paralelní běh testovacích případů a generování zpráv

Co se naučíte:

Práce s API a nástrojem pro testování karate

Jak je popsáno v předchozím kurzu, v .Vlastnosti soubor, který jsme vytvořili, jsme mohli použít různá klíčová slova k provedení různých operací s API. Karate framework nám poskytuje několik klíčových slov, která lze použít k provádění různých akcí.

=> Doporučené čtení: Testování API s Karate Framework

Provádění různých operací

# 1) Tisk odpovědi v konzole

Tisk je klíčové slovo, které poskytuje Karate Framework pro tisk výsledku v konzole nebo souboru. Jedním z nejběžnějších použití je tisk odpovědi API. To může být pro uživatele velmi užitečné.

Můžeme to udělat pomocí následujících řádků kódu:

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

Výše uvedené řádky kódu poskytnou následující výstup:

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' } }

Takto můžeme vytisknout odpověď API v konzole pro účely čtení, kterou lze použít v době ladění.

# 2) Deklarace proměnných

Proměnné můžeme deklarovat pomocí klíčového slova def v rámci Karate a poté použít deklarované proměnné v kódu, kdykoli je to nutné.

V níže uvedeném příkladu jsme do existujícího přidali několik dalších řádků kódu userDetails.feature soubor, který pomůže deklarovat proměnné ve skriptu.

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) Uplatnění skutečné odpovědi na očekávanou odpověď

Karate Framework pomáhá při provádění operací souvisejících s tvrzením pomocí zápas klíčové slovo. The zápas je chytrý, protože na něm nezáleží na prázdném prostoru a pořadí klíčů není důležité.

Pro použití shoda klíčové slovo, musíme použít znaménko dvojité rovnosti „==“, které představuje srovnání.

Nyní se pokusíme rozvinout některá použití zápas klíčové slovo.

a) Když je celá očekávaná odpověď uvedena v samotném souboru .feature.

V určitém okamžiku máme v samotném souboru některá data, která bychom chtěli okamžitě ověřit. Obvykle jsou tyto druhy dat zmíněny při ladění kódu.

Totéž bychom mohli udělat v samotném souboru .feature, jak je znázorněno níže:

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'}}

Pokud pošlete požadavek na adresu URL „Https://reqres.in/api/users/2“ poté v prohlížeči dostanete následující odpověď:

{ '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' } }

Pokoušíme se ověřit výše uvedenou odpověď pomocí souboru * .feature.

Použili jsme zápas klíčové slovo poskytované rámcem Karate, které pomáhá při provádění různých druhů Tvrzení v odpovědi API.

Poznámka : Abychom provedli výše uvedený krok, potřebovali bychom transformovat odpověď API do jednoho řádku. Můžete použít kterýkoli z dostupných nástrojů online.

b) Když je očekávaný výstup uchován v externím souboru JSON.

Ve výše uvedeném příkladu jsme diskutovali o scénáři, kde jsme měli omezená data a stejnou odpověď, která byla snadno zpracovatelná, ale ve skutečných scénářích budeme mít gigantické sady odpovědí JSON, které budeme muset vyhodnotit.

V těchto případech je tedy lepší ponechat odpověď v externím souboru a poté ji ověřit.

V níže uvedeném příkladu budeme dále diskutovat o stejném:

  • Je třeba vytvořit ExpectedOutput.json soubor v naší složce Project, jak je znázorněno na následujícím obrázku.

Vytvořit nový prostředek balíčku -> Vytvořit nový soubor ExpectedOutput.json

Uložte odpověď JSON do tohoto souboru a uložte ji.

ExpectedOutput.json1

Vytvořte nové prostředky balíčku

Budete muset napsat následující kód do vašeho userDetails.feature soubor:

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

Ve výše uvedeném příkladu nejprve čteme soubor ExpectedOutput.json a uložení její odpovědi do proměnné Očekávaný výsledek za použití následující řádky kódu:

Given expectedResult=read('./resources/ExpectedOutput.json')

Potom vložíme tvrzení pomocí následujících řádků kódu, kde se shodujeme s Skutečná odpověď s Očekávaný výsledek odpověď s „ == ' operátor.

And match response == expectedResult

c) Shoda / Ověření určitých hodnot z odpovědi

Doposud jsme ověřili celou odpověď API, ale pokaždé, když nebudete chtít ověřit celou odpověď. Někdy byste chtěli vyhodnotit pouze část odpovědi. Obvykle děláme totéž, když používáme ostatní nástroje pro testování API nebo při vytváření rámce.

Abychom tomu porozuměli dále, vezměme si jako příklad následující odpověď JSON:

{ 'ad': { 'company': 'StatusCode Weekly' } }

Pokud chceme ověřit, že parametr společnost by měl mít hodnotu jako StatusCode týdně, pak budeme muset vytvořit cestu JSON. Toho lze dosáhnout procházením souboru JSON a použitím „.“ (Operátor tečky)

Cesta JSON pro výše uvedenou odpověď bude:

ad.company == „StatusCode týdně“

Níže je fragment kódu, který nám pomůže při hodnocení hodnot pro konkrétní parametr. Tento kód patří do .Vlastnosti soubor.

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'

Níže je řádek kódu, který provádí parametrická tvrzení.

And match response.ad.url == 'http://statuscode.org/' And match response.data.first_name == 'Janet'

Pomocí cesty JSON vyhodnocujeme hodnoty parametrů.

Provádění operací po operaci

Dosud jsme pokryli základní scénáře testování API, když byla metoda „ DOSTAT'. Ale když pracujeme v reálném prostředí, musíme na server poslat spoustu informací, takže v takovém případě použijeme „ POŠTA' metoda .

V této části se dozvíte, jak pracovat se základním požadavkem POST.

Pojďme si udělat několik krátkých představ o parametrech, které potřebujeme pro odeslání požadavku POST.

# 1) Vytvoření požadavku POST, když je tělo JSON uvedeno v souboru * .feature

  • Vytvořte userDetailsPost.feature pomocí podobných kroků uvedených v předchozím kurzu.
  • Napište následující řádky kódu:
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

Jelikož se jedná o požadavek POST, který vždy musí být doprovázen tělem, které je třeba odeslat na server pro určitou odpověď, uvedli jsme to v následující komponentě:

žádost: Trvá tělo JSON jako požadavek, který je vyžadován metodou POST.

# 2) Vytvoření požadavku POST, když je tělo JSON uvedeno v externím souboru

Obvykle budeme mít obrovský orgán žádostí, což by bylo těžké zmínit v *.Vlastnosti soubor. Je tedy lepší ponechat to v externím souboru.

  • Je třeba vytvořit soubor PostBody.json v naší složce Project, jak je uvedeno níže. Vytvořte nový prostředek balíčku -> Vytvořte nový soubor PostBody.json a uložte tělo JSON do tohoto souboru a uložte jej.

Vytváření požadavku POST

když je tělo JSON uvedeno v externím souboru1

Poznámka: Ve výše uvedeném souboru JSON jsme zmínili tělo metody POST.

  • Ve svém userDetailsPost byste museli napsat následující kód .Vlastnosti soubor:
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

Čteme tělo JSON z PostBody.json pomocí následujících řádků kódu:

Given postBody=read('./resources/PostBody.json')

Poznámka: Všechny userDeatils.feature soubory, které jsme dosud vytvořili, budou vyžadovat základní TestRunner.java soubor k jejich provedení, který jsme vytvořili v našem tutoriálu Základní testovací skript, jak je uvedeno níže:

import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { }

Spouštějte testovací případy paralelně

Nyní, protože jsme se naučili kroky k vytvoření základního testovacího skriptu a provedli jsme některé základní operace s API, je čas začít s prací ve skutečném prostředí.

Obvykle musíme testovací případy spustit paralelně, abychom zrychlili provádění. Myšlenkou je v zásadě získat více výstupu za kratší dobu.

Toto je základní vlastnost rámce a nezávisí na JUnit, Maven nebo Grade. Umožňuje nám:

  • Jednoduše si vyberte funkce a značky pro spuštění testovacích sad.
  • Zobrazit výsledky Parallel ve složce surefire-plugin.
  • Můžeme dokonce integrovat zprávy JSON Cucumber pro lepší uživatelské rozhraní (které bude brzy probráno).

V Karate Framework nemusíme provádět mnoho kroků, abychom zahájili paralelní provádění našich testovacích případů. Musíme projít následujícími kroky:

1) Nyní musíme změnit TestRunner.java soubor, který jsme dosud používali. Kód pro paralelní spuštění je třeba zapsat do výše uvedeného souboru.

Při provádění kódu v Parallel mějte na paměti následující řádek:

čisté otázky a odpovědi pro nováčky

** Když se snažíme pracovat v paralelním prostředí, nemůžeme použít anotaci @RunWith (Karate.class).

Otevřete originál TestRunner.java soubor a nyní použijte následující kód:

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); } }

** Následující kód bude platit pro Závislost JUnit 4 Maven

Ve výše uvedeném fragmentu kódu jsme zahrnuli následující řádek kódu -

Výsledky výsledků = Runner.parallel (getClass (), 5);

Tento řádek dává pokyn ke spuštění instance testovacích případů paralelně dynamickým načítáním tříd za běhu.

dva) Vytvořte duplikát userDetails.feature soubor, jak je uvedeno níže pod src / test / java složku.

userDetails.feature

Nyní jsme všichni připraveni na paralelní provedení s dva . funkce soubor.

3) Jít do TestRunner.java soubor vytvořený v kroku výše a spusťte jej jako JUnit Test. S tímto provedeme naše testovací případy v paralelním formátu.

Pro snadnou čitelnost jsou některé informace prezentovány Karate Framework v konzole, kdykoli je dokončeno provedení testu.

Výsledek vypadá asi takto:

řídicí panel

S paralelním spuštěním budou všechny funkce spuštěny v Parallel a scénáře budou také spuštěny v paralelním formátu.

Podle výše uvedených kroků budete moci zahájit velmi základní Parallel Execution of the API Test, using the Karate Framework.

** O paralelním testování můžete studovat procházením různých filtrů na stránce Paralelní provedení

Integrujte plugin pro okurky pro hlášení

Jak používáme JUnit běžec pro provádění různých scénářů, které byly zmíněny v různých *.Vlastnosti automaticky vytvoří zprávu pro každý ze souborů funkcí, které jsou uloženy v cestě zprávy o cíli / surefire.

Integrace pluginu Cucumber pro hlášení

Generuje a Zpráva ve formátu základního uživatelského rozhraní za představení testovacích případů, které byly provedeny.

Zprávy, které se generují, však nejsou příliš příjemné z hlediska uživatelského rozhraní, a abychom mohli sdílet zprávy se zúčastněnými stranami, potřebujeme něco, co je uživatelsky přívětivější a snadno srozumitelné.

Aby bylo možné dosáhnout takového formátu hlášení, dává Karate Framework možnost integrace Plugin pro hlášení okurek což nám pomůže při generování graficky formátované zprávy, která bude více prezentovatelná.

Následují kroky k integraci stejné:

# 1) Přidejte následující Hlášení okurek závislost na vašem POM.xml

net.masterthought cucumber-reporting 3.8.0 test

#dva) Upravte soubor TestRunner.java, pokud existuje pouze jeden *.Vlastnosti soubor v projektu.

Musíme aktualizovat náš soubor TestRunner.java pomocí následující metody generateReport () pro plugin Cucumber.

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(); } }

V kódu uvedeném výše provádíme následující akce:

  • Vytváření nové instance souboru
  • Poskytnutí cesty k uložení souborů v cílové složce
  • Vytvoření objektu ReportBuilder, který vytvoří novou sestavu okurky

Poznámka : Výše ​​uvedený kód funguje dobře, když máme singl *. Vlastnosti soubor v našem projektu.

# 3) Pokud existují, upravte soubor TestRunner.java více * .funkce soubory v projektu.

Potřebovali bychom přidat řádek kódu (zvýrazněný tučně níže), abychom zajistili, že bude zajištěno paralelní provádění, zatímco scénáře jsou prováděny pro generování sestavy.

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(); } }

Po provedení výše uvedených kroků budeme moci pomocí nástroje úspěšně vytvořit dobře znázorněnou sestavu grafického uživatelského rozhraní Okurka - hlášení zapojit.

Sestavu můžeme najít na následující cestě v našem projektu, jak ukazuje obrázek níže:

Okurka - hlášení

Následující zpráva byla vygenerována pro náš projekt pro všechny operace, které jsme dosud prováděli v tomto výukovém programu Karate Framework:

Zpráva

Závěr

Abychom to shrnuli, v tomto tutoriálu jsme diskutovali o základních operacích, které jsou užitečné každý den při práci s Karate Framework a jak provést více * .feature souborů paralelně. Naučili jsme se také vytvářet grafickou zprávu pro uživatele pomocí Hlášení okurek zapojit.

Nejprve jsme probrali základní operace, které lze s API provádět. Diskutovali jsme o tom, jak můžeme odeslat tělo / požadavek POST na server, a to buď uvedením těla v samotném souboru * .feature (což obvykle není doporučený postup), nebo použitím externího souboru (doporučený postup, aby udržovat čistý kód).

Zadruhé, po provedení několika základních kroků jsme mohli úspěšně provést výsledek testu pro dva *.Vlastnosti soubory, které byly spuštěny paralelně, pouhým přidáním několika řádků kódu do souboru TestRunner.java soubor umožňující zahájení paralelního běhu.

Dále jsme se naučili, jak transformovat nativní sestavu testu JUnit na sestavu okurky integrací Hlášení okurek zapojit. Modul plug-in nám umožňuje generovat zprávy, které mají lepší uživatelské rozhraní, jsou pro uživatele mnohem srozumitelnější, a tudíž poskytují lepší uživatelskou zkušenost pro zúčastněné strany, s nimiž jsou tyto zprávy sdíleny.

Nyní byste měli být schopni provádět některé základní operace, paralelně spouštět testovací případy a generovat snadno čitelnou zprávu pro uživatele.

<

Doporučené čtení

^