Menü

REST-API-Tests mit Spring RestTemplate und TestNG

  • Haupt
  • Andere
  • REST-API-Tests mit Spring RestTemplate und TestNG

rest api testing with spring resttemplate

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

In diesem ausführlichen Tutorial wird erläutert, wie Sie mit REST-API-Tests mit Spring RestTemplate und TestNG anhand einfacher Beispiele beginnen:

In diesem Artikel erfahren Sie, wie Sie mit dem Testen von REST-APIs mit RestTemplate und TestNG-Framework beginnen.

Bevor Sie sich mit dem Testen von REST-APIs mit RestTemplate und dem TestNG-Framework befassen, sollten Sie einige der grundlegenden Konzepte verstehen, die damit verbunden sind.

Lasst uns beginnen!!

REST-API-Tests mit Spring und TestNG

Was du lernen wirst:

Was ist REST?

Heutzutage ist REST eine sehr beliebte Wahl beim Erstellen von Webdiensten. Zum Beispiel , Google hat mehrere REST-Dienste wie Kalender, Karten-API , usw.

SICH AUSRUHEN d.h. Repräsentative Staatsübertragung ist ein Software-Architekturstil. In diesem Stil wird eine Reihe von Einschränkungen definiert, und es sind Webdienste erforderlich, um diese Einschränkungen zu erfüllen. Solche Webdienste, die dem REST-Architekturstil entsprechen, werden als RESTful Web Services bezeichnet.

Der Begriff „Repräsentativer Staatstransfer“ wurde erstmals von vorgeschlagen Roy Fielding in seinem Ph.D. Dissertation im Jahr 2000. Die Grundidee von REST besteht darin, serverseitige Objekte als Ressourcen zu behandeln, die erstellt oder gelöscht werden können.

Was ist JSON?

JSON d.h. JavaScript-Objekt-Notation ist eine sehr häufig verwendete Syntax in REST-Diensten zum Speichern und Austauschen von Daten zwischen Browser und Server.

Der Hauptvorteil von JSON ist sein geringes Gewicht und zweitens auch sein lesbares Format. Die Daten werden im Format Schlüssel: Wert-Paar gespeichert. Zum Beispiel, Sie können die Mitarbeiterdaten im JSON-Format wie folgt speichern lassen: {'Name': 'Emp1', 'Gehalt': '3000', 'Alter': '23', 'ID': '52686'}.

Was ist REST-API-Test?

Wenn wir von REST-API-Tests sprechen, werden APIs im Wesentlichen getestet, indem Aktionen zum Erstellen, Bearbeiten, Lesen und Löschen von Ressourcen mit vier Hauptmethoden ausgeführt werden, d. H. POST, GET, PUT bzw. DELETE

Was ist TestNG?

TestNG ist ein Testframework, das von JUnit und NUnit inspiriert ist. Es ist für die Programmiersprache Java. TestNG deckt ein breiteres Spektrum von Testkategorien ab, z. B. Einheit, Funktion, End-to-End, Integration usw.

Es handelt sich um ein Open-Source-Framework, das unter die Apache-Lizenz fällt. Es bietet eine Vielzahl von Anmerkungen, die die Entwicklung des Testskripts beschleunigen.

Was ist eine Spring REST-Vorlage?

Die Spring RestTemplate-Klasse ist Teil des Spring-Web, das in Spring 3 eingeführt wurde

Die RestTemplate-Klasse bietet eine sehr bequeme Möglichkeit, die HTTP-basierten Restful-Webdienste zu testen, indem überladene Methoden für HTTP-Methoden wie GET, POST, PUT, DELETE usw. bereitgestellt werden. Das Spring-Framework ist ebenfalls Open Source.

REST-API-Testschritte

Lassen Sie uns die Schritte, die normalerweise beim Testen von REST-APIs ausgeführt werden, anhand einiger Beispiele verstehen, um ein klares Verständnis zu erhalten.

In diesem Artikel habe ich einen Beispiel-REST-API-Mitarbeiterservice von betrachtet diese Quelle.

Lassen Sie uns zunächst die Schritte manuell mit dem POSTMAN-Tool ausführen.

# 1) Kennen Sie zunächst den Endpunkt der API, auf die Sie zugreifen möchten.

Zum Beispiel, http://dummy.restapiexample.com/api/v1/create zum Erstellen einer neuen Mitarbeiterressource

#zwei) Legen Sie bei Bedarf für die HTTP-Methode Header und Body fest.

In unserem Beispiel versuchen wir, mithilfe von POST eine neue Ressource zu erstellen. Für POST ist ein Anforderungshauptteil erforderlich.

Also werden wir den Körper wie folgt einstellen:

'Name': 'zozo100', 'Gehalt': '123', 'Alter': '23'

Akzeptieren : application / JSON und Inhaltstyp : application / JSON.

etl testet interviewfragen und antworten für erfahrene

#3) Stellen Sie in diesem Fall die entsprechende HTTP-Methode ein, d. H. POST.

# 4) Senden Sie eine Anfrage an den Rest Service Server.

# 5) Erhalten Sie eine Antwort vom Server.

REST-API-Aufruf mit dem POSTMAN-Tool

Mitarbeiter ERSTELLEN

# 6) Überprüfen Sie die Antwort wie erwartet mit Hilfe des Antwortcodes Z.B. 200 OK als Erfolg.

# 7) Überprüfen Sie den Antworttext bei Bedarf wie erwartet, indem Sie ihn mit Ihrer Benchmark-Datei vergleichen.

Jetzt müssen wir die gleichen Schritte für unsere Test Automation Suite automatisieren. Beginnen wir mit dem für die Automatisierung erforderlichen Setup.

Einrichten von TestNG Test Framework unter Windows

# 1) Installation

  • Wir werden Java für die Entwicklung von Testskripten verwenden. Also, erster Download JDK-Installationsprogramm für Windows und Installieren Sie Java auf Ihrem Computer.
  • IDE (Integrierte Entwicklungsumgebung) : Ich habe Eclipse als IDE für meine Entwicklung der Automation Test Suite verwendet. Klicken Hier um es herunterzuladen.
  • Holen Sie sich das Eclipse-Plug-In für TestNG: Beachten Sie, dass Java 1.7+ erforderlich ist, um TestNG für das Eclipse-Plug-In auszuführen. Eclipse 4.2 und höher ist erforderlich. (Referenz: TestNG ). Befolgen Sie die folgenden Schritte in Eclipse:
    • Wählen Sie Hilfe / Neue Software installieren.
    • Klicken Sie auf Hinzufügen -> Geben Sie http://beust.com/eclipse/ ein.
    • Aktivieren Sie das Kontrollkästchen neben der URL und klicken Sie auf die Schaltfläche Weiter.

TestNG-Installation

TestNG

    • Klicken Sie weiter auf die Schaltfläche Weiter, bis Sie zum folgenden Bildschirm gelangen.

Endbildschirm der TestNG-Installation

TestNG-Installation Abschlussbildschirm

Akzeptieren Sie abschließend die Apache-Lizenzvereinbarung und klicken Sie auf die Schaltfläche Fertig stellen, um die Installation abzuschließen.

Starten Sie Eclipse neu, um die Plug-In-Installation zu aktivieren.

  • Frühlingsgläser: Jetzt noch eine letzte Sache, wir werden die RestTemplate-Klasse aus dem Spring-Framework verwenden. Sie können Frühlingsgläser herunterladen und speichern Sie es in einem lokalen Ordner, Zum Beispiel ,C: / projectJar
  • JSON-einfache Gläser: Wir müssen JSON-Parsing durchführen. Dafür werden wir eine leichte Json-einfache API verwenden. Laden Sie Json-simple-1.1.jar in C: / projectJar herunter

Jetzt haben wir die notwendigen Installationen abgeschlossen. Lassen Sie uns also unser Testautomatisierungsprojekt erstellen.

# 2) Projekteinrichtung

  • Datei erstellen -> Neu -> Java-Projekt -> Nennen Sie es als ‘ EmployeeTestSuite “.
  • Erstellen Sie jetzt ein neues Java-Paket com.demo ::
  • Konfigurationspfad konfigurieren:
    • Wie Sie im vorherigen Abschnitt gesehen haben, haben wir TestNG installiert, Spring- und JSON-einfache Gläser heruntergeladen. Jetzt müssen wir unserem Projekt einen Build-Pfad hinzufügen, um diese zu nutzen. Erstellen Sie dazu eine lib Ordner in die EmployeeTestSuite Ordner und kopieren Sie nun alle Gläser aus dem C: / projectJar in den lib Mappe.
    • Klicken Sie mit der rechten Maustaste auf ' EmployeeTestSuite ’’ -> Erstellungspfad -> Erstellungspfad konfigurieren.
    • Klicke auf das lib Tab.
    • Klicke auf das Bibliothek hinzufügen Schaltfläche -> Wählen Sie TestNG. Dadurch wird dem Erstellungspfad TestNG hinzugefügt.
    • Klicke auf Gläser hinzufügen Schaltfläche -> Alle Gläser aus lib auswählen. Dadurch werden alle Springgläser und JSON-einfachen Gläser zu Ihrem Projekterstellungspfad hinzugefügt.

Java-Erstellungspfad

Java-Erstellungspfad

Ihre Projektstruktur wird jetzt im Eclipse Package Explorer wie folgt angezeigt.

Paketstruktur

Paketstruktur

# 3) Testklasse

Wir müssen eine Testklasse erstellen, die CRUD-Operationen (Create-Read-Update-Delete) abdecken kann.

Erstellen Sie eine neue Klassendatei -> Neu -> TestNG-Klasse und nennen Sie sie TestCRUD.java

# 4) Testmethode

Lassen Sie uns separate Testmethoden erstellen:

  1. addEmployee (): Testmethode zum Testen der API zum Erstellen mithilfe der HTTP-POST-Methode.
  2. getEmployee (): Testmethode zum Testen der Lese-API mithilfe der HTTP-GET-Methode.
  3. updateEmployee (): Testmethode zum Testen der Update-API mithilfe der HTTP-PUT-Methode.
  4. deleteEmployee (): Testmethode zum Testen der Lösch-API mit der HTTP-DELETE-Methode.

Sie können eine Testmethode wie jede Java-Methode nur mit der @ Test-Annotation von TestNG erstellen, um sie vom TestNG-Framework als Testmethode zu identifizieren

Zum Beispiel,Das Folgende ist die addEmployee-Testmethode.

@Test public void addEmployee () {}

In unserem Beispiel habe ich a verwendet Beispiel für einen REST-Service.

Lassen Sie uns nun den POST-Aufruf automatisieren. Dazu müssen wir unseren Code den Schritten zuordnen, die wir manuell im Abschnitt 'REST-API-Testschritte' nacheinander ausgeführt haben.

Selenium Automation Testing Interview Fragen und Antworten für erfahrene

# 1) Kennen Sie zunächst den Endpunkt der API, auf die Sie zugreifen möchten.

String addURI = 'http://dummy.restapiexample.com/api/v1/create';

#zwei) Legen Sie Header für die HTTP-Methode fest.

HttpHeaders headers = new HttpHeaders();

// Header hinzufügen

headers.add('Accept', 'application/json'); headers.add('Content-Type', 'application/json');

Legen Sie Body für die HTTP-Methode fest.

String jsonBody = '{'name':'zozo100','salary':'123','age':'23'}';

// Erstellen Sie ein HttpEntity-Objekt, indem Sie body und headers festlegen.

HttpEntity entity = new HttpEntity(jsonBody, headers);

Die folgenden Schritte werden in einer Anweisung automatisiert.

#3) Stellen Sie in diesem Fall die entsprechende HTTP-Methode ein, d. H. POST.

# 4) Senden Sie eine Anfrage an den RESTful-Service-Server.

# 5) Erhalten Sie eine Antwort vom Server.

RestTemplate restTemplate = new RestTemplate(); ResponseEntity response =restTemplate.postForEntity(addURI, entity, String.class);

Wir benutzen postForEntity um die POST-Methode an den Server zu senden. Wir erhalten die Antwort vom Server ResponseEntity-Objekt.

# 6) Überprüfen Sie die Antwort wie erwartet mit Hilfe des Antwortcodes.

Assert.assertEquals(response.getStatusCode(), HttpStatus.OK);

Hier verwenden wir die Assert-Toolklasse von TestNG, um die Statuscode-Methode assertEquals zu überprüfen, die den tatsächlichen Wert, d. H. Response.getStatusCode (), mit dem erwarteten Wert HttpStatus.OK vergleicht.

Hier führen wir jedoch eine weitere Überprüfung durch, d. H. Überprüfen, ob der hinzugefügte Mitarbeiter im Antworttext vorhanden ist oder nicht.

Assert.assertTrue(responseBody.contains(employeeId));

Wie haben wir die employeeId bekommen?

Hierfür verwenden wir die Hilfe der JSON-Parser-API, d. H. Json-simple.

Wir verwenden den JSON-Parser, da das JSON-Format zum Speichern und Austauschen der Daten zwischen dem Client und unserem Server in unserem Mitarbeiter-REST-Service verwendet wird. Wie bereits erwähnt, werden JSON-Daten in gespeichert Schlüsselwert Format. Hier wollen wir das bekommen 'Ich würde' Wert.

Wir werden es erhalten, indem wir den Antwortkörper wie folgt analysieren:

JSONParser parser = new JSONParser(); // Instantiate JSONParser object JSONObject jsonResponseObject = new (JSONObject) parser.parse(jsonString); //Parse jsonString i.e. Response body string in json format to JSON object String employeeId = jsonResponseObject.get('id').toString(); // Get id attribute

Hier dreht sich alles um den Create-Methodentest.

Methoden aktualisieren, abrufen und löschen

  • Erstellen Sie separate Testmethoden und legen Sie die entsprechenden Header fest.
  • In ähnlicher Weise erfolgt auch die Überprüfung des Statuscodes.
  • Der Hauptunterschied besteht in den Methoden zum Senden einer Anforderung an die Server.

Sie können die folgenden Methoden verwenden:

# 1) Mitarbeiter aktualisieren : Dies ist die HTTP-PUT-Anforderung. Die RestTemplate PUT-Methode, die Sie verwenden können, lautet:

public void put(String url,Object request, Object... urlVariables) throws RestClientException

# 2) Mitarbeiter holen: Dies ist die HTTP-GET-Anforderung. Die RestTemplate GET-Methode, die Sie verwenden können, lautet wie folgt:

public ResponseEntity getForEntity(String url, Class responseType, Object... urlVariables) throws RestClientException

# 3) Mitarbeiterressource löschen: Dies ist die HTTP-DELETE-Anforderung. Die RestTemplate DELETE-Methode, die Sie verwenden können, lautet:

public void delete(String url, Object... urlVariables) throws RestClientException

Neben diesen Methoden gibt es die nützlichen Methoden exchange () und execute ().

Zum Beispiel, Wenn Sie bemerken, ist die Löschmethode ungültig. Wenn Sie jedoch den Antworttext überprüfen möchten, benötigen Sie eine Antwort von der Methodenausführung. Zu diesem Zweck können Sie die exchange () -Methode verwenden, die ResponseEntity zurückgibt. Siehe die Frühlingsrahmen für mehr Details.

# 5) Ausführen der Tests

Jetzt haben wir unsere Aufgabe zur Entwicklung von Testskripten abgeschlossen. Lassen Sie uns also unsere Tests ausführen. Klicken Sie einfach mit der rechten Maustaste auf TestCRUD.java und wählen Sie die Option ‘Als TestNG-Test ausführen’ .

Dadurch werden die Ergebnisse der Testausführung wie folgt angezeigt.

Konsolenausgabe

Konsolenausgabe

Hinweis: Sie können Ihre Testsuite in definieren testng.xml Datei auch. In unserem Beispiel ist es nur ein Testskript. Im realen Szenario handelt es sich jedoch immer um eine Sammlung mehrerer Skripte.

Ihre testg.xml-Datei sieht also wie folgt aus:

# 6) Berichte

Wir haben das Ergebnis auf der Konsole gesehen. TestNG bietet jedoch Testergebnisse in einem ansehnlicheren HTML-Format, das mit Ihren Stakeholdern geteilt werden kann. Öffnen Testausgabe -> emailable-report.html im Browser.

Sie sehen den Testbericht wie folgt. Auf der Berichtsseite sehen Sie den Testnamen als TestCRUD, mehrere bestandene Tests, d. H. 4, Anzahl der übersprungenen und fehlgeschlagenen Tests, die in diesem Fall 0 sind. Außerdem wird die Gesamtzeit angezeigt, die für jede Ausführung der Testmethode erforderlich ist.

Testergebnis im HTML-Format

Testergebnis im HTML-Format

Vollständiger TestCRUD-Dateicode

package com.demo; import java.io.IOException; import java.text.ParseException; import org.json.simple.JSONObject; import org.json.simple.parser.JSONParser; import org.springframework.http.HttpEntity; import org.springframework.http.HttpHeaders; import org.springframework.http.HttpMethod; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.web.client.RestTemplate; import org.testng.Assert; import org.testng.annotations.AfterTest; import org.testng.annotations.BeforeTest; import org.testng.annotations.Test; import org.testng.log4testng.Logger; /** * This test class has test methods for CRUD actions on REST API * REST Service http://dummy.restapiexample.com/api * * It has test methods for Create , Edit , Get and Delete Employee items * https://docs.spring.io/spring-framework/docs/current/javadoc- api/org/springframework/web/client/RestTemplate.html * https://docs.spring.io/autorepo/docs/spring/3.2.3.RELEASE/javadoc- api/org/springframework/web/client/RestTemplate.html * @author * */ public class TestCRUD { private String responseBody; public String responseBodyPOST; final static Logger logger = Logger.getLogger(TestCRUD.class); //RESTTemplate Object private RestTemplate restTemplate; //Employee ID private String employeeId; // Create Response Entity - Stores HTTPStatus Code, Response Body, etc private ResponseEntity response; @BeforeTest public void beforeTest() throws IOException, ParseException { logger.info('Setting up prerequisite for test execution'); logger.info('Creating RestTemplate object before tests'); this.restTemplate = new RestTemplate(); } /** * Test Method to add employee using HTTP POST request * * Verifies POST action Status Code * * @throws IOException * @throws ParseException */ @Test public void addEmployee() throws IOException, ParseException { String addURI = 'http://dummy.restapiexample.com/api/v1/create'; HttpHeaders headers = new HttpHeaders(); headers.add('Accept', 'application/json'); headers.add('Content-Type', 'application/json'); logger.info('Add URL :'+addURI); String jsonBody = '{'name':'zozo100','salary':'123','age':'23'}'; System.out.println(' ' + jsonBody); HttpEntity entity = new HttpEntity(jsonBody, headers); //POST Method to Add New Employee response = this.restTemplate.postForEntity(addURI, entity, String.class); 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.assertTrue(responseBody.contains(employeeId)); // System.out.println(propertyFile.get('EmployeeAddResBody')); // Check if the status code is 201 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); logger.info('Employee is Added successfully employeeId:'+employeeId); } /** * Method to get Employee ID from REsponse body * I have used Json Simple API for Parsing the JSON object * * @param json * @return */ public static String getEmpIdFromResponse(String json) { JSONParser parser = new JSONParser(); JSONObject jsonResponseObject = new JSONObject(); Object obj = new Object(); try { obj = parser.parse(json); } catch (org.json.simple.parser.ParseException e) { e.printStackTrace(); } jsonResponseObject = (JSONObject) obj; String id = jsonResponseObject.get('id').toString(); return id; } /** * Test Method to Update employee using HTTP PUT request * * Verifies PUT action Status Code * Verifies Updated Name exists in Response Body * * @throws IOException * @throws ParseException */ @Test(dependsOnMethods = 'addEmployee', enabled = true) public void updateEmployee() throws IOException, ParseException { String updateURI = 'http://dummy.restapiexample.com/api/v1/update/'+employeeId; logger.info('Update URL :'+updateURI); String jsonBody = responseBodyPOST; jsonBody = jsonBody.replace('zozo100', 'update_zozo100'); HttpHeaders headers = new HttpHeaders(); headers.add('Accept', 'application/json'); headers.add('Content-Type', 'application/json'); HttpEntity entity = new HttpEntity(jsonBody, headers); //PUT Method to Update the existing Employee //NOTE that I have Not used restTemplate.put as it's void and we need response for verification response = restTemplate.exchange(updateURI, HttpMethod.PUT, entity, String.class); responseBody = response.getBody().toString(); System.out.println('Update Response Body :'+responseBody); // Check if the updated Employee is present in the response body. Assert.assertTrue(responseBody.contains('update_zozo100')); // Check if the status code is 200 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); logger.info('Employee Name is Updated successfully employeeId:'+employeeId); } /** * Test Method to Get employee using HTTP GET request * * Verifies GET action Status Code * Verifies Name exists in Response Body * * @throws IOException * @throws ParseException */ @Test(dependsOnMethods = 'updateEmployee', enabled = true) void getEmployee() throws IOException, ParseException { String getURI = 'http://dummy.restapiexample.com/api/v1/employee/'+this.employeeId; logger.info('Get URL :'+getURI); HttpHeaders headers = new HttpHeaders(); HttpEntity entity = new HttpEntity(headers); //GET Method to Get existing Employee response = restTemplate.getForEntity(getURI,String.class); // Write response to file responseBody = response.getBody().toString(); //Suppressing for log diffs System.out.println('GET Response Body :'+responseBody); // Check if the added Employee ID is present in the response body. Assert.assertTrue(responseBody.contains('update_zozo100')); // Check if the status code is 200 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); logger.info('Employee is retrieved successfully employeeId:'+employeeId); } /** * Test Method to Delete employee using HTTP DELETE request * * Verifies DELETE action Status Code * Verifies Success Message Text in Response Body * * @throws IOException * @throws ParseException */ @Test(dependsOnMethods = 'getEmployee', enabled = true) public void deleteEmployee() throws IOException, ParseException { String delURI = 'http://dummy.restapiexample.com/api/v1/delete/'+this.employeeId; HttpHeaders headers = new HttpHeaders(); HttpEntity entity = new HttpEntity(headers); //DELETE Method to Delete existing Employee response = restTemplate.exchange(delURI, HttpMethod.DELETE, entity, String.class); // Check if the status code is 204 Assert.assertEquals(response.getStatusCode(), HttpStatus.OK); responseBody = response.getBody(); Assert.assertEquals(getMessageFromResponse(responseBody), 'successfully! deleted Records'); logger.info('Employee is Deleted successfully employeeId:'+employeeId); } /** * Gets 'text' key value from Response body text for verification * I have used Json Simple API for Parsing the JSON object * * @param json * @return text string */ public static String getMessageFromResponse(String json) { String successMessageText = null; try { JSONParser parser = new JSONParser(); JSONObject jsonResponseObject = new JSONObject(); jsonResponseObject = (JSONObject) (parser.parse(json)); String successMessage = jsonResponseObject.get('success').toString(); jsonResponseObject = (JSONObject) (parser.parse(successMessage)); successMessageText = jsonResponseObject.get('text').toString(); } catch (org.json.simple.parser.ParseException e) { e.printStackTrace(); } return successMessageText; } @AfterTest public void afterTest() { logger.info('Clean up after test execution'); logger.info('Creating RestTemplate object as Null'); this.restTemplate = new RestTemplate(); } }

Fazit

Wir haben das Lernergebnis dieses Artikels unten zusammengefasst. Wir haben von Anfang an alle Schritte zum Einrichten eines REST API Test Automation Framework gesehen.

Darin haben wir folgendes gelernt:

  • Für die Testautomatisierung haben wir Java als Programmiersprache ausgewählt.
  • Wir haben TestNG als Testframework für die Erstellung eines Testskripts ausgewählt, in dem wir TestNG-Anmerkungen wie @Test verwendet haben.
  • Zum Senden tatsächlicher HTTP-Anforderungen an den Server haben wir die Spring Framework RestTemplate-Klasse verwendet.
  • Um diese APIs zu nutzen, haben wir TestNG installiert, Spring-Jars und Json-simple-JAR für die Parser-API heruntergeladen.
  • Schließlich haben wir die Testklasse ausgeführt und das Ergebnis auf der Konsole sowie in einem besser darstellbaren und lesbareren HTML-Format gesehen.

Kurz gesagt, in diesem Artikel haben wir gelernt, wie Sie mit der REST-API-Testautomatisierung mit Spring RestTemplate beginnen. Wir haben die Einrichtung unseres Testautomatisierungs-Frameworks von der Installation aller wichtigen Software, der Projekteinrichtung, der Entwicklung von Testskripten bis zur Testausführung und der Anzeige der generierten Berichte behandelt.

Dies ist ziemlich ausreichend, damit jede QS für die Automatisierung mit Ihrem Testautomatisierungsframework beginnen kann. Wir haben jedoch nur die erforderlichen Teile von jedem gesehen. Beispielsweise haben wir die TestNG-Installation, die Testmethode mit @ Test-Annotation und Berichte verwendet. TestNG bietet jedoch viele weitere Funktionen wie DataProvider für datengesteuerte Tests usw.

Sind Sie bereit, mit der REST-API-Testautomatisierung mit Spring RestTemplate zu beginnen?

Literatur-Empfehlungen

^