Menü

Führen Sie Testfälle parallel aus und erstellen Sie Berichte mit dem Karate-Tool

  • Haupt
  • Andere
  • Führen Sie Testfälle parallel aus und erstellen Sie Berichte mit dem Karate-Tool

run test cases parallel generate reports using karate tool

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Wo ist mein Netzwerksicherheitsschlüssel?

In diesem Tutorial wird erklärt, wie Sie einige grundlegende Vorgänge an der API ausführen, Testfälle parallel ausführen und Berichte mit Karate Framework erstellen:

Wir haben in unserem vorherigen Tutorial gelernt, wie man ein grundlegendes Testskript erstellt. Jetzt können wir einige grundlegende Operationen erlernen, die während der Arbeit mit der API und dem Karate Framework ausgeführt werden können. Es gibt viele solcher Operationen, und wir werden in diesem Tutorial einige häufig verwendete Operationen diskutieren.

Wir werden uns auch mit dem parallelen Ausführen von Testfällen befassen, indem wir einen schrittweisen Ansatz verfolgen. Wir werden auch den aktuellen Bericht diskutieren, der automatisch generiert wird, und ihn mit dem Gurkenbericht vergleichen, den wir durch Integration eines Plugins generieren können.

Verschiedene Vorgänge ausführen, Testfälle parallel ausführen und Berichte erstellen

Was du lernen wirst:

Arbeiten mit API und Karate Testing Tool

Wie im vorherigen Tutorial beschrieben, in der .Merkmal In der von uns erstellten Datei konnten wir verschiedene Schlüsselwörter verwenden, um verschiedene Operationen an der API auszuführen. Karate Das Framework stellt uns mehrere Schlüsselwörter zur Verfügung, mit denen verschiedene Aktionen ausgeführt werden können.

=> Empfohlene Lektüre: API-Tests mit Karate Framework

Verschiedene Operationen ausführen

# 1) Drucken der Antwort in der Konsole

Drucken ist ein Schlüsselwort, das vom Karate Framework bereitgestellt wird, um das Ergebnis in der Konsole oder in der Datei zu drucken. Eine der häufigsten Anwendungen ist das Drucken der Antwort der API. Dies kann für den Benutzer sehr nützlich sein.

Wir können dies tun, indem wir die folgenden Codezeilen verwenden:

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

Die obigen Codezeilen geben die folgende Ausgabe aus:

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

Auf diese Weise können wir die Antwort der API in der Konsole zum Lesen drucken, die zum Zeitpunkt des Debuggens verwendet werden kann.

# 2) Deklarieren der Variablen

Wir können die Variablen mit dem Schlüsselwort deklarieren def im Karate-Framework und verwenden Sie dann die deklarierten Variablen im Code, wo immer dies erforderlich ist.

Im folgenden Beispiel haben wir dem vorhandenen einige weitere Codezeilen hinzugefügt userDetails.feature Datei, um die Variablen im Skript zu deklarieren.

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) Bestätigen der tatsächlichen Antwort auf die erwartete Antwort

Karate Framework hilft bei der Ausführung der Assertion-bezogenen Operationen mit dem Spiel Stichwort. Das Spiel ist klug, weil Leerzeichen keine Rolle spielen und die Reihenfolge der Schlüssel nicht wichtig ist.

Zum Benutzen Stichwort übereinstimmen, Wir müssen das Doppelgleichheitszeichen '==' verwenden, das einen Vergleich darstellt.

Jetzt werden wir versuchen, einige Verwendungszwecke von näher zu erläutern Spiel Stichwort.

a) Wenn die gesamte erwartete Antwort in der .feature-Datei selbst erwähnt wird.

Zu bestimmten Zeiten haben wir einige Daten, die wir sofort validieren möchten, in der Datei selbst. Normalerweise werden solche Daten beim Debuggen des Codes erwähnt.

Wir könnten dasselbe in der .feature-Datei selbst tun, wie unten gezeigt:

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

Wenn Sie eine Anfrage an die URL senden 'Https://reqres.in/api/users/2' dann im Browser Sie erhalten folgende Antwort:

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

Wir versuchen, die oben genannte Antwort mithilfe der * .feature-Datei zu validieren.

Wir haben das benutzt Spiel Schlüsselwort, das vom Karate Framework bereitgestellt wird und bei der Ausführung verschiedener Arten von Behauptungen in der API-Antwort.

Hinweis : Wir müssten die API-Antwort in eine Zeile umwandeln, um den obigen Schritt auszuführen. Sie können jedes der verfügbaren Tools verwenden online.

b) Wenn die erwartete Ausgabe in einer externen JSON-Datei gespeichert wird.

Im obigen Beispiel haben wir ein Szenario besprochen, in dem wir nur begrenzte Daten und dieselbe Antwort hatten, die einfach zu handhaben war. In den realen Szenarien werden wir jedoch gigantische Sätze von JSON-Antworten haben, die wir möglicherweise auswerten müssen.

In diesen Fällen ist es daher besser, die Antwort in der externen Datei zu belassen und diese dann zu überprüfen.

Im folgenden Beispiel werden wir dasselbe weiter diskutieren:

  • Müssen Sie eine erstellen ExpectedOutput.json Datei in unserem Projektordner wie im folgenden Bild gezeigt.

Neue Paketressource erstellen -> Neue Datei erstellen ExpectedOutput.json

Speichern Sie die JSON-Antwort in dieser Datei und speichern Sie sie.

ExpectedOutput.json1

Erstellen Sie neue Paketressourcen

Sie müssten den folgenden Code in Ihr schreiben userDetails.feature Datei:

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

Im obigen Beispiel lesen wir zuerst die Datei ExpectedOutput.json und Speichern der Antwort davon in der Variablen erwartetes Ergebnis Verwendung der folgende Codezeilen:

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

Dann setzen wir die Assertion mit den folgenden Codezeilen, in denen wir die übereinstimmen Tatsächliche Antwort mit dem erwartetes Ergebnis Antwort mit dem “ == ' Operator.

And match response == expectedResult

c) Abgleichen / Überprüfen bestimmter Werte aus der Antwort

Bisher haben wir die gesamte Antwort der API überprüft, aber jedes Mal möchten Sie nicht die gesamte Antwort überprüfen. Manchmal möchten Sie nur einen Teil der Antwort auswerten. Normalerweise machen wir dasselbe, wenn wir die anderen Tools für API-Tests oder beim Erstellen eines Frameworks verwenden.

Nehmen wir zum besseren Verständnis die folgende JSON-Antwort als Beispiel:

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

Wenn wir überprüfen wollen, dass der Parameter Unternehmen sollte den Wert als haben StatusCode Weekly, dann müssen wir einen JSON-Pfad erstellen. Dies kann durch Durchlaufen der JSON-Datei und Verwenden des '.' (Punktoperator)

Der JSON-Pfad für die obige Antwort lautet:

ad.company == 'StatusCode Weekly'

Unten finden Sie das Code-Snippet, das uns bei der Bewertung der Werte für den jeweiligen Parameter hilft. Dieser Code gehört zum .Merkmal Datei.

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'

Unten finden Sie die Codezeile, in der die parametrischen Zusicherungen ausgeführt werden.

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

Mit dem JSON-Pfad werten wir die Werte für die Parameter aus.

Nachoperationen durchführen

Bis jetzt haben wir die grundlegenden Szenarien zum Testen einer API behandelt, als die Methode „ ERHALTEN'. Wenn wir jedoch in der realen Umgebung arbeiten, müssen wir viele Informationen an den Server senden. In diesem Fall verwenden wir die Option „ POST' Methode .

In diesem Abschnitt erhalten Sie einen Einblick in die Arbeit mit der grundlegenden POST-Anforderung.

Lassen Sie uns einige kurze Ideen zu den Parametern geben, die wir zum Senden der POST-Anfrage benötigen.

# 1) Erstellen einer POST-Anforderung, wenn der JSON-Body in der * .feature-Datei erwähnt wird

  • Erstellen Sie eine userDetailsPost.feature mit den ähnlichen Schritten, die im vorherigen Lernprogramm beschrieben wurden.
  • Schreiben Sie die folgenden Codezeilen:
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 es sich um eine POST-Anforderung handelt, die immer von einem Text begleitet werden muss, der für eine bestimmte Antwort an den Server gesendet werden muss, haben wir dies unter der folgenden Komponente erwähnt:

Anfrage: Als Anforderung wird ein JSON-Body verwendet, der für die POST-Methode erforderlich ist.

# 2) Erstellen einer POST-Anforderung, wenn der JSON-Body in einer externen Datei erwähnt wird

Normalerweise werden wir eine riesige Anforderungsstelle haben, die in der schwer zu erwähnen ist *.Merkmal Datei. Es ist also besser, es in der externen Datei zu behalten.

  • Sie müssen eine PostBody.json-Datei in unserem Projektordner erstellen, wie unten gezeigt. Erstellen Sie eine neue Paketressource -> Erstellen Sie eine neue Datei PostBody.json, speichern Sie den JSON-Body in dieser Datei und speichern Sie ihn.

POST-Anfrage erstellen

wenn der JSON-Body in der externen Datei1 erwähnt wird

Hinweis: Wir haben den Body der POST-Methode in der obigen JSON-Datei erwähnt.

  • Sie müssten den folgenden Code in Ihren userDetailsPost schreiben .Merkmal Datei:
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

Wir lesen den JSON-Body aus PostBody.json mit den folgenden Codezeilen:

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

Hinweis: All die userDeatils.feature Dateien, die wir bisher erstellt haben, benötigen die Basis TestRunner.java Datei, um sie auszuführen, die wir in unserem Basic Test Script-Tutorial wie unten gezeigt erstellt haben:

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

Führen Sie Testfälle parallel aus

Nachdem wir nun die Schritte zum Erstellen eines grundlegenden Testskripts gelernt und einige grundlegende Vorgänge für die API ausgeführt haben, ist es an der Zeit, mit der Arbeit in der tatsächlichen Umgebung zu beginnen.

Normalerweise müssen wir die Testfälle parallel ausführen, um die Ausführung zu beschleunigen. Grundsätzlich besteht die Idee darin, mehr Leistung in kürzerer Zeit zu erzielen.

Dies ist ein Kernmerkmal des Frameworks und hängt nicht von JUnit, Maven oder Grade ab. Es erlaubt uns:

  • Wählen Sie einfach die Funktionen und Tags aus, um Testsuiten auf einfache Weise auszuführen.
  • Zeigen Sie die parallelen Ergebnisse im Ordner 'safefire-plugin' an.
  • Wir können sogar die Cucumber JSON-Berichte für eine bessere Benutzeroberfläche integrieren (auf die in Kürze eingegangen wird).

In Karate Framework müssen wir nicht viele Schritte ausführen, um die parallele Ausführung unserer Testfälle zu starten. Wir müssen nur die folgenden Schritte ausführen:

1) Wir müssen jetzt das ändern TestRunner.java Datei, die wir bisher verwendet haben. Der Code für die parallele Ausführung muss in die obige Datei geschrieben werden.

Beachten Sie beim parallelen Ausführen Ihres Codes die folgende Zeile:

So öffnen Sie Bin-Dateien in Windows

** Wir können die Annotation @RunWith (Karate.class) nicht verwenden, wenn wir versuchen, in einer parallelen Umgebung zu arbeiten.

Öffnen Sie das Original TestRunner.java Datei und verwenden Sie jetzt den folgenden Code:

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

** Der folgende Code gilt für JUnit 4 Maven-Abhängigkeit

Im obigen Code-Snippet haben wir die folgende Codezeile eingefügt:

Ergebnisse Ergebnisse = Runner.parallel (getClass (), 5);

Diese Zeile weist an, die Instanz der Testfälle parallel auszuführen, indem die Klassen zur Laufzeit dynamisch abgerufen werden.

zwei) Erstellen Sie ein Duplikat userDetails.feature Datei wie unten unter dem erwähnt src / test / java Mappe.

userDetails.feature

Jetzt sind wir alle bereit für die parallele Ausführung mit zwei . Eigenschaften Datei.

3) Gehe zu TestRunner.java Datei im Schritt oben und erstellt Führen Sie es als JUnit-Test aus. Damit führen wir unsere Testfälle parallel aus.

Zur besseren Lesbarkeit werden einige Informationen vom Karate Framework in der Konsole angezeigt, sobald die Testausführung abgeschlossen ist.

Das Ergebnis sieht ungefähr so ​​aus:

Konsole

Bei der parallelen Ausführung werden alle Funktionen parallel ausgeführt, und auch die Szenarien werden in einem parallelen Format ausgeführt.

Wenn Sie die obigen Schritte ausführen, können Sie die grundlegende parallele Ausführung des API-Tests mithilfe des Karate-Frameworks starten.

** **. Sie können sich mit parallelen Tests befassen, indem Sie die verschiedenen Filter auf der Seite durchlaufen Parallele Ausführung

Integrieren Sie das Gurken-Plugin für die Berichterstellung

Da benutzen wir die JUnit Läufer für die Ausführung verschiedener Szenarien, die in den verschiedenen erwähnt wurden *.Merkmal Dateien erstellt es automatisch einen Bericht für jede der Feature-Dateien, die im Pfad gespeichert sind Ziel- / todsichere Berichte.

Gurken-Plugin für die Berichterstellung integrieren

Es erzeugt eine Grundlegender UI-formatierter Bericht zur Darstellung der ausgeführten Testfälle.

Die Berichte, die erstellt werden, sind jedoch in Bezug auf die Benutzeroberfläche nicht sehr ansprechend. Um Berichte mit den Stakeholdern zu teilen, benötigen wir etwas, das benutzerfreundlicher und leicht verständlich ist.

Um ein solches Berichtsformat zu erreichen, bietet Karate Framework die Möglichkeit zur Integration Gurken-Reporting-Plugin Dies hilft uns bei der Erstellung eines grafisch formatierten Berichts, der präsentabler ist.

Es folgen die Schritte, um dasselbe zu integrieren:

# 1) Fügen Sie Folgendes hinzu Gurkenberichterstattung Abhängigkeit von Ihrer POM.xml

net.masterthought cucumber-reporting 3.8.0 test

#zwei) Bearbeiten Sie die Datei TestRunner.java, wenn nur eine vorhanden ist *.Merkmal Datei im Projekt.

Wir müssen unsere TestRunner.java-Datei mit der folgenden generateReport () -Methode für das Cucumber-Plugin aktualisieren.

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

In dem oben erwähnten Code führen wir die folgenden Aktionen aus:

  • Erstellen einer neuen Dateiinstanz
  • Geben Sie den Pfad zum Speichern der Dateien im Zielordner an
  • Erstellen eines ReportBuilder-Objekts, mit dem ein neuer Gurkenbericht erstellt wird

Hinweis : Der obige Code funktioniert gut, wenn wir Single haben *. Merkmal Datei in unserem Projekt.

#3) Bearbeiten Sie die Datei TestRunner.java, wenn vorhanden mehrfache * .Funktion Dateien im Projekt.

Wir müssten eine Codezeile hinzufügen (unten fett hervorgehoben), um sicherzustellen, dass die parallele Ausführung gewährleistet ist, während die Szenarien für die Berichterstellung ausgeführt werden.

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

Nachdem Sie die oben genannten Schritte ausgeführt haben, können Sie mit dem erfolgreich einen gut dargestellten grafischen UI-Bericht erstellen Gurke - Berichterstattung Plugin.

Wir finden den Bericht unter folgendem Pfad in unserem Projekt, wie in der Abbildung unten gezeigt:

Gurke - Berichterstattung

Der folgende Bericht wurde für unser Projekt für alle Operationen erstellt, die wir bisher in diesem Karate Framework-Tutorial durchgeführt haben:

Bericht

Fazit

Zusammenfassend haben wir in diesem Tutorial die grundlegenden Operationen besprochen, die im Alltag bei der Arbeit mit dem nützlich sind Karate Framework und wie man ausführt mehrere * .feature-Dateien parallel zu. Wir haben auch gelernt, einen grafischen Bericht für die Benutzer mit dem zu erstellen Gurkenberichterstattung Plugin.

Zuerst haben wir die grundlegenden Operationen besprochen, die an der API ausgeführt werden können. Wir haben besprochen, wie wir den POST-Body / die POST-Anfrage an den Server senden können, indem wir entweder den Body in der * .feature-Datei selbst erwähnen (was normalerweise keine empfohlene Vorgehensweise ist) oder eine externe Datei verwenden (eine empfohlene Vorgehensweise, um dies zu tun) einen sauberen Code pflegen).

Zweitens konnten wir nach einigen grundlegenden Schritten das Testergebnis für zwei erfolgreich ausführen *.Merkmal Dateien, die parallel ausgeführt wurden, nur durch Hinzufügen einiger Codezeilen in der TestRunner.java Datei, die die Initiierung des parallelen Laufs ermöglicht.

Darüber hinaus haben wir gelernt, wie der native JUnit-Testbericht durch Integration von in einen Gurkenbericht umgewandelt wird Gurkenberichterstattung Plugin. Mit dem Plugin können wir Berichte erstellen, die eine bessere Benutzeroberfläche haben, für den Benutzer viel verständlicher sind und somit den Stakeholdern, mit denen diese Berichte geteilt werden, eine bessere Benutzererfahrung bieten.

Inzwischen sollten Sie in der Lage sein, einige grundlegende Vorgänge auszuführen, die Testfälle parallel auszuführen und einen einfach zu lesenden Bericht für die Benutzer zu erstellen.

<

Literatur-Empfehlungen

^