Meny

REST API-testning med Spring RestTemplate och TestNG

  • Huvud
  • Övrig
  • REST API-testning med Spring RestTemplate och TestNG

rest api testing with spring resttemplate

Prova Vårt Instrument För Att Eliminera Problem

Denna fördjupade handledning förklarar hur man kommer igång med REST API-testning med Spring RestTemplate och TestNG med enkla exempel:

I den här artikeln kommer vi att se hur du kommer igång med REST API-testning med RestTemplate och TestNG-ramverk.

Innan vi utforskar REST API-testning med RestTemplate och TestNG-ramverk, låt oss förstå några av de grundläggande begreppen som är involverade i den.

Låt oss börja!!

REST API-testning med vår och TestNG

Vad du kommer att lära dig:

Vad är REST?

Numera har REST blivit ett ganska populärt val att bygga webbtjänster. Till exempel , Google har flera REST-tjänster som Kalender, Kart-API , etc.

RESTEN dvs. Representativ statlig överföring är en programvaruarkitekturstil. I den här stilen definieras en uppsättning begränsningar och byggda webbtjänster krävs för att uppfylla dessa begränsningar. Sådana webbtjänster som överensstämmer med REST-arkitektoniska stil kallas RESTful Web Services.

Termen ”representativ statlig överföring” framfördes först av Roy Fielding i sin doktorsexamen avhandling år 2000. Grundtanken med REST är att behandla objekten på serversidan som resurser som kan skapas eller tas bort.

Vad är JSON?

JSON dvs. JavaScript-objektnotation är en mycket vanlig syntax i REST-tjänster för lagring och utbyte av data mellan webbläsaren och servern.

Den största fördelen med JSON är dess lätta och för det andra dess läsbara format. Data lagras i nyckeln: värde-parformat. Till exempel, du kan ha medarbetardata lagrade i JSON-format så här: {“namn”: ”Emp1 ″,” lön ”:” 3000 ″, ”ålder”: ”23 ″,” id ”:” 52686 ″}.

Vad är REST API-testning?

När vi säger REST API-testning testar det i princip API genom att utföra Skapa, Redigera, Läs och Ta bort åtgärder på Resurs med fyra huvudmetoder, dvs POST, GET, PUT respektive DELETE

Vad är TestNG?

TestNG är ett testramverk som är inspirerat av JUnit och NUnit. Det är för Java-programmeringsspråket. TestNG täcker ett bredare utbud av testkategorier som enhet, funktionell, end-to-end, integration etc.

Det är en öppen källkodsram som faller under Apache-licensen. Det ger en rik uppsättning kommentarer som påskyndar utvecklingen av testskriptet.

Vad är vårens REST-mall?

Spring RestTemplate-klassen är en del av vårväven som introducerades våren 3

RestTemplate-klassen ger ett mycket bekvämt sätt att testa HTTP-baserade vilsam webbtjänster genom att tillhandahålla överbelastade metoder för HTTP-metoder som GET, POST, PUT, DELETE, etc. Vårramverket är också öppen källkod.

REST API-teststeg

Låt oss förstå stegen som vanligtvis följs i REST API-testning med några exempel för att få en klar förståelse.

I den här artikeln har jag beaktat ett exempel på REST API-anställdstjänst från den här källan.

Låt oss inledningsvis följa stegen manuellt med hjälp av POSTMAN-verktyget.

# 1) Känn först slutpunkten för API: et som du vill komma åt.

Till exempel, http://dummy.restapiexample.com/api/v1/create för att skapa en ny medarbetaresurs

#två) Ställ in rubriker och kropp om det behövs för HTTP-metoden.

I vårt exempel, när vi försöker skapa en ny resurs med hjälp av POST. För POST krävs en begäran.

Så vi kommer att ställa in kroppen enligt följande:

“Namn”: ”zozo100 ″,” lön ”:” 123 ″, ”ålder”: ”23 ″

Acceptera : applikation / JSON och Innehållstyp : applikation / JSON.

skillnad mellan belastning och prestandatestning

# 3) Ställ in lämplig HTTP-metod, dvs POST i det här fallet.

# 4) Skicka en förfrågan till resttjänsten.

# 5) Få svar från servern.

REST API-samtal med POSTMAN-verktyget

SKAPA anställd

# 6) Verifiera svaret som förväntat med hjälp av svarkoden T.ex. 200 OK som en framgång.

# 7) Verifiera svarsorganet som förväntat om det behövs genom att jämföra det med din referensfil.

Nu måste vi automatisera samma steg för vår Test Automation-svit. Låt oss börja med den inställning som krävs för automatisering.

Konfigurera TestNG Test Framework på Windows

# 1) Installation

  • Vi ska använda Java för utveckling av testskript. Så, första nedladdningen JDK-installationsprogram för Windows och installera Java på din maskin.
  • IDE (integrerad utvecklingsmiljö) : Jag har använt Eclipse som IDE för min utveckling av Automation Test Suite. Klick här för att ladda ner den.
  • Hämta Eclipse Plug-in för TestNG: Observera att Java 1.7+ krävs för att köra TestNG för Eclipse-plugin-programmet. Förmörkelse 4.2 och högre krävs. (Referens: TestNG ). Följ stegen nedan i Eclipse:
    • Välj Hjälp / Installera ny programvara.
    • Klicka på Lägg till -> Gå in på http://beust.com/eclipse/
    • Markera kryssrutan bredvid webbadressen och klicka på knappen Nästa.

TestNG Installation

TestNG

    • Fortsätt att klicka på Nästa-knappen tills du kommer till följande skärm.

TestNG Installation Slutlig skärm

TestNG-installation Slutlig skärm

Slutligen acceptera Apache-licensavtalet och klicka på Slutför-knappen för att slutföra installationen.

Starta om Eclipse för att aktivera plugin-installationen.

  • Vårburkar: Nu en sista sak, vi ska använda klassen RestTemplate från vårramen. Du kan ladda ner vårburkar och spara den i en lokal mapp, Till exempel ,C: / projectJar
  • JSON-enkla burkar: Vi måste utföra JSON-parsning. För det kommer vi att använda ett lätt Json-enkelt API. Så ladda ner Json-simple-1.1.jar till C: / projectJar

Nu har vi slutfört de nödvändiga installationerna. Så, låt oss skapa vårt testautomatiseringsprojekt.

# 2) Projektinställning

  • Skapa fil -> Ny -> Java-projekt -> Namnge den som ‘ EmployeeTestSuite ’.
  • Skapa nu ett nytt Java-paket com.demo :
  • Konfigurera Build Path:
    • Som du har sett i det tidigare avsnittet har vi installerat TestNG, nedladdade vår- och JSON-enkla burkar. Så nu måste vi lägga till byggvägen i vårt projekt för att konsumera dem. För det, skapa en lib mapp i EmployeeTestSuite mappen och kopiera nu alla burkar från C: / projectJar till lib mapp.
    • Högerklicka på “ EmployeeTestSuite '' -> Bygg väg -> Konfigurera byggväg.
    • Klicka på lib flik.
    • Klicka på Lägg till bibliotek knapp -> Välj TestNG. Detta kommer att lägga TestNG till byggvägen.
    • Klicka på Lägg till burkar knapp -> Välj alla burkar från lib. Detta lägger till alla vårburkar och JSON-enkel burk i din projektbyggnadsväg.

Java Build Path

Java-byggsökväg

Din projektstruktur visas enligt följande i Eclipse Package Explorer nu.

Paketstruktur

Paketstruktur

# 3) Testklass

Vi måste skapa en testklass som kan täcka CRUD-operationer (Create-Read-Update-Delete).

Skapa ny klass Arkiv -> Ny -> TestNG-klass och ge den namnet TestCRUD.java

# 4) Testmetod

Låt oss skapa separata testmetoder:

  1. addEmployee (): Testmetod för att testa Skapa API med HTTP POST-metoden.
  2. getEmployee (): Testmetod för att testa Läs API med HTTP GET-metoden.
  3. updateEmployee (): Testmetod för att testa Update API med HTTP PUT-metoden.
  4. deleteEmployee (): Testmetod för att testa Ta bort API med HTTP DELETE-metoden.

Du kan skapa en testmetod som vilken Java-metod som helst endast med @Test-kommentar av TestNG för att få den identifierad som testmetod genom TestNG-ramverket.

Till exempel,följande är testmetoden addEmployee.

@Test public void addEmployee () {}

I vårt exempel har jag använt a prov REST Service.

Låt oss automatisera POST-samtalet. För det måste vi mappa vår kod med stegen som vi följde manuellt i avsnittet ”REST API Testing Steps” en efter en.

# 1) Först känner du till slutpunkten för API: t som du vill komma åt.

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

#två) Ställ in rubriker för HTTP-metoden.

HttpHeaders headers = new HttpHeaders();

// Lägg till rubriker

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

Ställ in Body för HTTP-metoden.

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

// Skapa ett HttpEntity-objekt genom att ställa in body och headers.

HttpEntity entity = new HttpEntity(jsonBody, headers);

Vi kommer att ha följande steg automatiserade i ett uttalande.

# 3) Ställ in lämplig HTTP-metod, dvs POST i det här fallet.

# 4) Skicka en förfrågan till RESTful-tjänstservern.

# 5) Få svar från servern.

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

Vi använder postForEntity för att skicka POST-metoden till servern. Vi får svaret från servern ResponseEntity-objekt.

# 6) Verifiera svaret som förväntat med hjälp av svarkoden.

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

Här använder vi Assert-verktygsklassen för TestNG för att verifiera statuskoden assertEquals-metoden som jämför det verkliga värdet, d.v.s. respons.getStatusCode (), med det förväntade värdet HttpStatus.OK.

Men här gör vi ytterligare en verifiering, dvs. verifierar om den tillagda medarbetaren är närvarande i svarsorganet eller inte.

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

Hur fick vi anställd-id?

För detta tar vi hjälp av JSON parser API, dvs Json-enkel.

Vi använder JSON-parser, eftersom JSON-format används för att lagra och utbyta data mellan klienten och vår server i vår anställds REST-tjänst. Som tidigare nämnts lagras JSON-data i nyckelvärde formatera. Här vill vi få “Id” värde.

applikationer för att spionera på mobiltelefoner

Vi kommer att få det genom att analysera svarsorganet enligt följande:

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

Så det här handlar om testmetoden Skapa.

Uppdatera, hämta och ta bort metoder

  • Skapa separata testmetoder och ställ in rubriker efter behov.
  • Verifiering av statuskoden görs också på samma sätt.
  • Huvudskillnaden är metoderna för att skicka en begäran till servrarna.

Du kan använda följande metoder:

# 1) Uppdatera anställd : Det är HTTP PUT-begäran. RestTemplate PUT-metoden som du kan använda är:

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

# 2) Få anställd: Det är HTTP GET-begäran. RestTemplate GET-metoden som du kan använda är som följer:

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

# 3) Ta bort anställdes resurs: Det är HTTP DELETE-begäran. RestTemplate DELETE-metoden som du kan använda är:

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

Förutom dessa metoder finns det utbyte () och exekvera () användbara metoder.

Till exempel, om du märker är borttagningsmetoden ogiltig. Men om du vill verifiera svarsorganet, behöver du ett svar tillbaka från metodkörningen. För det ändamålet kan du använda exchange () -metoden som returnerar ResponseEntity. Referera till Vårens ram för mer detaljer.

# 5) Köra testerna

Nu har vi slutfört vår utvecklingsuppgift för testskript, så låt oss köra våra tester. Högerklicka bara på TestCRUD.java och välj alternativet 'Kör som TestNG-test' .

Detta visar testkörningsresultaten enligt följande.

Konsolutgång

Konsolutgång

Notera: Du kan definiera din testsvit i testng.xml fil också. I vårt exempel är det bara ett testskript. Men i det verkliga scenariot är det alltid en samling av flera skript.

Så din testg.xml-fil ser ut som följer:

# 6) Rapporter

Vi har sett resultatet på konsolen. Men TestNG ger testresultat i ett mer presentabelt html-format som kan delas med dina intressenter. Öppen testutgång -> emailable-report.html i webbläsaren.

Du kommer att se testrapporten enligt följande. På rapportsidan kan du se testnamnet som TestCRUD, flera godkända tester, dvs. 4, antal överhoppade och misslyckade som är 0 i det här fallet. Den visar också den totala tid som krävs för varje testmetodkörning.

Testresultat i HTML-format

Testresultat i HTML-format

Komplett TestCRUD-filkod

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

Slutsats

Vi har sammanfattat inlärningsresultatet för den här artikeln nedan. Vi såg alla steg från början för att skapa ett REST API Test Automation Framework.

I detta lärde vi oss följande:

  • För testautomatisering valde vi Java som programmeringsspråk.
  • Vi valde TestNG som testram för att skapa ett testskript där vi konsumerade TestNG-kommentarer som @Test.
  • För att skicka faktiska HTTP-förfrågningar till servern konsumerade vi vårens ramverk RestTemplate-klass.
  • För att konsumera dessa API: er installerade vi TestNG, laddade ned Spring-burkar och Json-enkel burk för parser-API.
  • Slutligen körde vi testklassen och såg resultatet på konsolen såväl som i ett mer presentabelt och mer läsbart HTML-format.

I ett nötskal, i den här artikeln, lärde vi oss hur vi kommer igång med REST API-testautomatisering med Spring RestTemplate. Vi täckte upp installationen av vårt testautomatiseringsramverk med start från installation av all nödvändig programvara, projektinstallation, utveckling av testskript till testkörning och visning av genererade rapporter.

Detta är ganska tillräckligt för alla automatiserings-QA för att komma igång med ditt testautomatiseringsramverk. Men vi har bara sett de nödvändiga delarna från var och en, till exempel har vi använt TestNG-installation, testmetod med @Test-kommentar, rapporter. TestNG har dock många fler funktioner som DataProvider för datadriven testning etc.

Är du redo att komma igång med REST API-testautomatisering med Spring RestTemplate?

Rekommenderad läsning

^