rest api testing with cucumber using bdd approach
In diesem Tutorial werden REST-API-Tests mit Gurken unter Verwendung des BDD-Ansatzes erläutert. Es umfasst Softwareinstallation, Projekteinrichtung, TestScript-Ausführung und Berichte.
In diesem Artikel erfahren Sie, wie Sie mit REST-API-Tests im BDD-Stil mit dem Cucumber-Framework beginnen.
Bevor wir uns eingehend mit dem Thema befassen, lassen Sie uns die damit verbundenen wichtigen Konzepte verstehen.
Lasst uns beginnen!!
Was du lernen wirst:
- Wichtige Konzepte in der REST-API
- Wie funktioniert Gurke?
- Einrichten des Gurkentest-Frameworks unter Windows
- Fazit
- Literatur-Empfehlungen
Wichtige Konzepte in der REST-API
SICH AUSRUHEN
Dies ist ein Software-Architekturstil. Die vollständige Form von REST ist Representational State Transfer . Es definiert eine Reihe von Einschränkungen, die zum Erstellen von Webdiensten verwendet werden sollen. Webdienste, die dem REST-Architekturstil entsprechen, werden als RESTful-Webdienste bezeichnet.
REST-API-Test
Beim Testen der REST-API wird die API unter Verwendung von 4 Hauptmethoden getestet, d. H. POST, GET, PUT und DELETE.
REST-Vorlage
RestTemplate ist eine Open-Source-Spring-Framework-Klasse, die eine bequeme Möglichkeit zum Testen der HTTP-basierten Restful-Webdienste bietet, indem überladene Methoden für die HTTP-Methoden bereitgestellt werden.
Hinweis : Weitere Informationen zum REST-API-Testkonzept finden Sie in unserem früheren Lernprogramm. REST-API-Tests mit Spring RestTemplate und TestNG Hier haben wir erläutert, wie REST-API-Tests zusammen mit dem Konzept von JSON manuell durchgeführt werden.
BDD
BDD ist der verhaltensorientierte Entwicklungsansatz. Dies ist eine der Softwareentwicklungstechniken, die aus der testgetriebenen Entwicklung hervorgegangen sind, d. H. Dem TDD-Stil.
Das Prinzip des BDD-Testens besteht darin, dass Testfälle in einer natürlichen Sprache geschrieben sind, die auch für Nicht-Programmierer leicht lesbar ist.
Gurke
Gurke ist ein Werkzeug, das verhaltensorientierte Entwicklung unterstützt
Wie funktioniert Gurke?
Mal sehen, wie Gurke funktioniert.
Gurke besteht aus Feature-Dateien, Schrittdefinitionsdateien und Runner-Klasse.
Feature-Dateien
Feature-Dateien werden von Ihrem Business Analyst oder möglicherweise Ihrem Sponsor geschrieben. Diese sind in natürlicher Sprache mit den darin beschriebenen Spezifikationen geschrieben und bestätigen, dass die Anwendung gemäß den Spezifikationen funktioniert.
In diesen Spezifikationen sind mehrere Szenarien oder Beispiele aufgeführt. Jedes Szenario enthält eine Liste bestimmter Schritte, die Cucumber ausführen muss.
Betrachten wir ein Szenario, in dem sich der Benutzer beim System anmelden möchte.
Um zu überprüfen, ob dies gemäß den Spezifikationen funktioniert, muss dieses Szenario beschrieben werden. Hier sind die Schritte aufgeführt, die zusammen mit dem gewünschten Ergebnis gemäß den Spezifikationen ausgeführt werden müssen.
Um sich ein Bild zu machen, sieht ein Beispielszenario folgendermaßen aus:
Scenario: Login to the system Given User launches Login screen When User enters username, password and submit Then Login Successful message appears
Sie sehen, jedes Szenario ist eine Art Liste der Schritte, die Cucumber ausführen muss. Damit Cucumber die Szenarien versteht, müssen sie einige grundlegende Syntaxregeln befolgen, die aufgerufen werden Gurke .
Schrittdefinitionsdateien
Schrittdefinitionsdateien ordnen jeden in einer Feature-Datei erwähnten Gherkin-Schritt dem Implementierungscode zu. Dadurch kann Cucumber die Aktion ausführen, die für den Schritt ausgeführt werden muss.
Das Cucumber Framework unterstützt viele Programmiersprachen zum Schreiben von Schrittdefinitionen wie Java, .net und Ruby.
Hinweis : Im Artikel ' REST-API-Tests mit Spring RestTemplate und TestNG Wir haben das TestNG-Testprojekt mit der Spring-Vorlage entwickelt.
Jetzt werden wir das Test Framework für denselben REST-Service und RestTemplate entwickeln, jedoch mithilfe von Cucumber für verhaltensgesteuerte Entwicklungsteststile.
Beginnen wir mit der Einrichtung unseres Automatisierungstest-Frameworks mit Cucumber!
Einrichten des Gurkentest-Frameworks unter Windows
# 1) Installation
(ich) Wir werden Java für die Entwicklung von Schrittdefinitionen verwenden. Laden Sie zuerst das JDK-Installationsprogramm für Windows von herunter Orakel und installieren Sie Java auf Ihrem Computer.
(ii) IDE (Integrierte Entwicklungsumgebung) : Ich habe Eclipse als IDE für meine Entwicklung der Automation Test Suite verwendet. Sie können es von herunterladen Finsternis
(iii) Holen Sie sich das Eclipse-Plug-In für Gurken:
Befolgen Sie diese Schritte in der Eclipse:
- Wählen Sie im Menü Option Hilfe -> Neue Software installieren.
- Eingeben 'Gurkenfinsternis' im Suchtextfeld.
- Klicke auf das Installieren Taste.
Installation des Gurken-Plug-Ins in Eclipse
- Klicken Sie weiter auf die Schaltfläche Weiter, bis Sie die erreichen Lizenz überprüfen Bildschirm.
Klicken Sie abschließend auf das Kontrollkästchen, um die Lizenzvereinbarung zu akzeptieren, und klicken Sie auf Fertig Taste. Damit ist die Installation abgeschlossen. Starten Sie nun die Eclipse-IDE neu. Dies ist erforderlich, damit die Plug-In-Installation wirksam wird.
(iv) Frühlingsgläser: Da wir die RestTemplate-Klasse verwenden, die zum Spring Framework gehört, benötigen Sie Spring Framework-Gläser. Sie können Frühlingsgläser von der herunterladen Frühlingsrahmen und speichern Sie es im lokalen Ordner. Zum Beispiel, C: / projectJar
(v) JSON-einfache Gläser: Wir müssen JSON-Parsing durchführen. Daher werden wir eine leichte JSON-einfache API verwenden. Laden Sie also JSON-simple-1.1.jar herunter und speichern Sie es in C: / projectJar
(vi) Gurkengläser:
Sie benötigen die folgenden Gurkengläser, um das Gurkenprojekt auszuführen:
- Gurkenkern
- Gurken-Java
- Gurken-JUnit
- Gurke-JVM-Deps
- Gurkenberichterstattung
- Gurke
- JUnit
- mockito-all
- Abdeckung
- Gurken-HTML [Für Berichte in HTML]
Sie können diese Dateien mit der Datei pom.xml herunterladen. Am einfachsten ist es jedoch, diese JAR-Dateien von der Website herunterzuladen Zentrales Repository und speichern Sie diese JAR-Dateien im lokalen Ordner. Zum Beispiel, C: / projectJar
Damit haben wir alle notwendigen Installationen abgeschlossen. Lassen Sie uns also unser BDD Test Automation-Projekt erstellen.
# 2) Projekteinrichtung
- Datei erstellen -> Neu -> Java-Projekt -> Nennen Sie es als ‘ CRUD_Cucumber ’.
- Erstellen Sie jetzt ein neues Java-Paket Demo.
- Konfigurieren Sie BuildPath des Projekts:
- Wie Sie im vorherigen Abschnitt gesehen haben, haben wir das Cucumber-Plug-In, die heruntergeladene Feder und JSON-einfache Gläser installiert. Es ist also an der Zeit, einen Build-Pfad in unser Projekt aufzunehmen, um diese zu nutzen. Erstellen Sie dazu eine lib Ordner in Ordner CRUD_Cucumber und kopieren Sie nun alle Gläser aus dem C: / projectJar nach lib / Gurke, lib / Frühling Mappe.
- Klicken Sie mit der rechten Maustaste auf ' CRUD_Cucumber ’ -> Erstellungspfad -> Erstellungspfad konfigurieren.
- Klicke auf das Bibliotheken Tab.
- Klicke auf Gläser hinzufügen button-> Alle Gläser aus auswählen lib / Gurke Ordner und lib / Frühling Mappe. Dadurch werden alle Gurken-, Frühlings- und JSON-einfachen Gläser zu Ihrem Projekterstellungspfad hinzugefügt.
Ihre Projektstruktur wird im Eclipse Package Explorer wie folgt angezeigt.
Paketstruktur des Testprojekts
qa Fragen und Antworten zu Managerinterviews
# 3) Funktionsdatei
Lassen Sie uns nun unsere Feature-Datei erstellen DemoFeature.feature mit der Funktion CRUD-Operationen für den Mitarbeiterservice ausführen.
In unserem Beispiel habe ich einen Dummy-REST-Service für http://dummy.restapiexample.com/api verwendet.
Diese Feature-Datei beschreibt die Szenarien zum Ausführen der CRUD-Operationen, d. H. Zum Abdecken von CRUD (Create-Read-Update-Delete).
- Definieren wir zuerst das Feature. In unserem Fall handelt es sich um das Testen von CRUD-Methoden, die wie folgt beschrieben werden können.
Feature: Test CRUD methods in Sample Employee REST API testing
- Dies hat verschiedene Szenarien wie Erstellen, Aktualisieren, Lesen und Löschen des Mitarbeiterdatensatzes. Schauen Sie sich also das POST-Szenario an:
Scenario: Add Employee record
- Beschreiben Sie die Voraussetzung für den Test, bei dem die URL des Mitarbeiterdienstes festgelegt wird.
Given I Set POST employee service api endpoint
- Geben Sie den tatsächlichen Testschritt zum Senden einer Post-Anfrage an.
When I Set request HEADER And Send a POST HTTP request
- Beschreiben Sie nun die Überprüfung des Antwortkörpers.
Then I receive valid Response
In unserer Feature-Datei sieht das Szenario also wie folgt aus:
Unterschied zwischen Teststrategie und Testplan
Scenario: Add Employee record Given I Set POST employee service api endpoint When I Set request HEADER And Send a POST HTTP request Then I receive valid Response
Ebenso können Sie die verbleibenden Szenarien wie unten gezeigt schreiben.
DemoFeature.feature
# 4) Implementierung der Schritte
Für die in den obigen Szenarien verwendeten Funktionsschritte müssen Sie programmatische Implementierungen schreiben. In diesem Fall handelt es sich um Java.
Eine Schrittdefinition ist eine in Java geschriebene Methode mit einem Ausdruck. Es verknüpft seine Methode mit einem oder mehreren Schritten. Wenn Cucumber die in einem Szenario der Feature-Datei beschriebenen Schritte ausführt, sucht es zunächst nach einer Übereinstimmung Schrittdefinition ausführen.
Zum Beispiel, Wenn die Schrittdefinition für Mitarbeiter mit POST hinzufügen wie folgt geschrieben werden kann.
Für den gegebenen Schritt wird die Implementierung wie folgt geschrieben:
@Given('^I Set POST employee service api endpoint$') public void setPostEndpoint(){ addURI = 'http://dummy.restapiexample.com/api/v1/create'; System.out.println('Add URL :'+addURI); }
In ähnlicher Weise ist für den Schritt When die folgende Definitionsmethode:
@When ('^Send a POST HTTP request$') public void sendPostRequest(){ doublename_id = Math.random(); emp_name = 'zozo_'+name_id;//Just to avoid Duplicate Name entry String jsonBody'{'name':''+emp_name+'','salary':'123','age':'23'}'; System.out.println('
' + jsonBody); HttpEntityentity = new HttpEntity(jsonBody, headers); //POST Method to Add New Employee restTemplate = newRestTemplate (); response = restTemplate.postForEntity(addURI, entity, String.class); }
Hier ist nun der Teil des Verifizierungsschritts, d. H. Die Implementierung des Dann-Schritts:
@Then ('^I receive valid Response$') Public void verifyPostResponse(){ responseBodyPOST = response.getBody(); // Write response to file responseBody = response.getBody().toString(); System.out.println('responseBody --->' + responseBody); // Get ID from the Response object employeeId = getEmpIdFromResponse(responseBody); System.out.println('empId is :' + employeeId); // Check if the added Employee is present in the response body. Assert.hasText(responseBody,employeeId); // Check if the status code is 201 Assert.isTrue(response.getStatusCode()==HttpStatus.OK); System.out.println('Employee is Added successfully employeeId:'+employeeId); }
Hinweis: Hier verwenden wir die RestTemplate-Methode zum Senden von Anforderungen. Dies ist die gleiche Methode wie in „ REST-API-Tests mit Spring RestTemplate und TestNG ' . Weitere Informationen zu Rest Template-Methoden finden Sie im Tutorial.
Daher sieht Ihre Schrittdefinition wie folgt aus.
StepDefinition.java
Sie können die Schrittdefinitionen für die verbleibenden Szenarien Mitarbeiter auf dieselbe Weise aktualisieren, lesen und löschen implementieren.
# 5) Ausführen der Tests
Jetzt haben wir unsere Szenario- und Schritt-Skriptentwicklungsaufgabe abgeschlossen. Lassen Sie uns also unsere Tests ausführen. Dazu müssen wir eine JUnit-Runner-Klasse schreiben.
publicclassRunner { }
Hier müssen Sie die folgenden Anmerkungen über dem Klassennamen hinzufügen:
@ RunWith (Cucumber.class): Als Testläuferklasse für Gurke ausführen.
@CucumberOptions: Hier geben Sie den Speicherort der Features-Datei und den Speicherort der Schrittdefinitionsdatei an, die das Cucumber-Framework während der Ausführung untersuchen soll.
features='' glue=''
Plug-in: Hiermit werden verschiedene Formatierungsoptionen für den Bericht angegeben, der als Ausgabe generiert wird.
Daher wird Ihre Läuferklasse so aussehen.
TestRunner.java
Klicken Sie einfach mit der rechten Maustaste auf TestRunner.java und wählen Sie die Option „ Als JUnit-Test ausführen . Dadurch wird das Ergebnis der Testausführung wie folgt angezeigt.
Junit Tab-Ausgabe
In der Konsole werden die folgenden Meldungen angezeigt.
Konsolenausgabe
# 6) Berichte
Wir haben das Ergebnis auf der Konsole gesehen. Cucumber bietet jedoch Testergebnisse in einem ansehnlicheren HTML-Format, das mit Ihren Stakeholdern geteilt werden kann.
Öffnen Ziel -> Gurkenberichte im Browser.
Hinweis : Erinnerst du dich an die Junit Runner Klasse CucucmberOptions?
@CucumberOptions (features='Features',glue={'demo'},plugin={'pretty', 'html:target/cucumber-reports'})
Hier ist das Plugin die Option, die wir für Berichte im HTML-Format zusammen mit dem Ordner angeben.
target/cucumber-reports
Öffnen Sie nun die Seite target cucumber-reports index.html. Die Berichtsseite ist die HTML-Seite, auf der Sie den Funktionsnamen mit Szenarien sehen können, die erfolgreich ausgeführt wurden.
Ihr Bericht sieht also wie folgt aus.
CucumberTest-Ergebnis im HTML-Format
Fazit
Lassen Sie uns zum Abschluss dieses Tutorials zusammenfassen, was wir bisher gelernt haben.
Wir haben von Anfang an alle Schritte zum Einrichten des BDD Cucumber REST API Test Automation Frameworks gesehen.
In diesem Prozess haben wir Folgendes gelernt:
- Für die Testautomatisierung haben wir Java als Programmiersprache ausgewählt.
- Wir haben Cucumber als Testframework für die Erstellung einer Testsuite im Testverfahren 'Behavior Driven Development' ausgewählt.
- Zum Senden tatsächlicher HTTP-Anforderungen an den Server haben wir die Spring Framework RestTemplate-Klasse verwendet.
- Um diese APIs zu nutzen, haben wir das Cucumber-Plug-In installiert und die Cucumber-Abhängigkeits-JAR-Dateien, Spring-Jars und JSON-Simple-JAR für Parser-API heruntergeladen.
- Wir haben die Feature-Datei erstellt, um Szenarien in einfachem Englisch zu beschreiben, die Schrittdefinitionsdatei zum Zuordnen von Schritten und die JUnit Runner-Klasse zum Ausführen der Feature-Datei.
- Schließlich haben wir die Test Runner-Klasse ausgeführt und das Ergebnis auf der Konsole in einem besser darstellbaren und lesbaren HTML-Format angezeigt.
Kurz gesagt, in diesem Artikel wurde erläutert, wie Sie mit der REST-API-Testautomatisierung mit Cucumber beginnen. Wir haben die Einrichtung unseres Testautomatisierungs-Frameworks von der Installation aller wichtigen Software, der Projekteinrichtung, der TestScript-Entwicklung bis zur Testausführung und dem Anzeigen generierter Berichte behandelt.
Dies ist ausreichend, damit jede QS für die Automatisierung mit dem Testautomatisierungsframework beginnen kann. Aber wenn jemand im Detail verstehen möchte, wie Gurke intern funktioniert, wie die Gurkensprache funktioniert, kann sie weiter untersucht werden Gurke.
Ich hoffe, Sie sind bereit, mit dem Testen der REST-API im BDD-Stil mit Gurke zu beginnen!
Literatur-Empfehlungen
- 10 besten API-Testtools im Jahr 2021 (SOAP- und REST-API-Testtools)
- Beste Software-Test-Tools 2021 [QA Test Automation Tools]
- REST-API-Tests mit Spring RestTemplate und TestNG
- Testen von Primer eBook Download
- Top 20 der wichtigsten Fragen und Antworten zu API-Tests
- SaaS-Tests: Herausforderungen, Tools und Testansatz
- API-Tests mit Katalon Studio vereinfachen
- Automatisierungstests mit Gurkenwerkzeug und Selen - Selen-Tutorial Nr. 30