Meny

Webbtjänsttestning med Apache HTTP-klient

  • Huvud
  • Övrig
  • Webbtjänsttestning med Apache HTTP-klient

web services testing using apache http client

Prova Vårt Instrument För Att Eliminera Problem

Denna handledning handlar om att utföra olika CRUD-operationer på webbtjänster och testa webbtjänster med hjälp av Apache HTTP-klient:

I denna Komplett API-testhandledningsserie har vi lärt oss att webbtjänster fungerar som ett kommunikationsmedium mellan klient- och servermaskiner som interagerar över ett nätverk. Vi förklarade allt om API-testning med POSTMAN i vår tidigare handledning.

I den här artikeln kommer vi att betona hur man testar webbtjänster med hjälp av Apache HTTP Client och utför olika CRUD-operationer på webbtjänster. De olika typerna av REST-klienter som är tillgängliga för backendtestning kommer också att diskuteras.

bästa programvaran för virtuell maskin för Windows 10

Webbtjänsttestning med Apache HTTP-klient

Vad du kommer att lära dig:

Vad är en webbtjänst?

Webbtjänster är ett kommunikationsmedium mellan klient- och servermaskiner som interagerar över ett nätverk med hjälp av HTTP-protokoll. Webbtjänster är vanligtvis API: er som inte installeras eller lagras lokalt men som finns i moln eller på vissa fjärrservrar.

Se exemplet nedan för att förstå hur webbtjänster fungerar.

MakeMyTrip och Goibibo.com är några av de berömda webbplatserna för flyg- och hotellbokningar och det finns olika flygleverantörer som Indigo, Air India och Etihad, etc.

Om en kund vill boka ett flyg från New York till London kan de antingen bläddra direkt på flygförsäljarportalen eller så kan de boka via tredjepartsleverantörer. Om de bokar via tredjepartsleverantörer som MakeMyTrip och andra bokningssidor, kommer de inom några sekunder att jämföra och visa resultat med flyginformation som lägsta pris, flygtid och mycket mer annan information.

Frågan uppstår här är, hur exakt, inom några sekunder förser de oss med informationen? Vad gör de exakt?

Från användargränssnittet tar de all nödvändig information och lagrar den i en JSON- eller XML-fil och ringer till sina leverantörs-API: er med en autentiseringstoken när de exponerar sina API: er, och som svar skickar flygleverantörens webbplats tillbaka JSON / XML-svar till MakeMyTrip och de konverterar det mottagna svaret och visar detaljer i användargränssnittet.

Gränssnitt för webbtjänster

Typer av webbtjänster

Det finns två typer av webbtjänster, nämligen

  • SOAP API
  • REST API

Låt oss se skillnaderna mellan dessa två webbtjänster som visas i bilden nedan.

Skillnader mellan tvål och vila

JSON / XML-filer i webbtjänsten

Låt S1-systemet returneras på J2EE-språk och S2-systemet returneras i .NET eller Python och vi vet att båda teknikerna skiljer sig helt från varandra med säkerhetsproblem också. Hur delar S2-systemet koden med ett annat system?

Så S2-systemet exponerar sina API: er för S1-systemet utan att exponera affärslogik, och S2-systemet delar API-namn, API-URL, API-format och autentiseringsnyckel / Token Key för att komma åt sitt system. Kommunikation sker mellan de två systemen med antingen JSON- eller XML-filer.

Varför bara JSON / XML-fil?

JSON / XML-filer används eftersom dessa är datainsamlare. All viss information lagras antingen i JSON- eller XML-format, eftersom de är lätta och de är standardspråk för att kommunicera mellan två olika gränssnitt / plattformar eller system.

Så API används alltid när två oberoende system interagerar med varandra, antingen lokalt, inom systemet eller över nätverket.

Vad är REST Client?

REST Client är ett verktyg som kallar API: er. Den används i backendtestning när det inte finns något användargränssnitt för att anropa API: er. Några populära REST-klienter är Apache HTTP-klient, POSTMAN, SOAP UI, Swagger och många fler.

Här, i den här artikeln, kommer vi bara att diskutera Apache HTTP-klient och vi kommer att täcka andra olika HTTP-klienter i våra framtida artiklar.

Http-klientinställning i förmörkelse

# 1) Öppna Eclipse och skapa ett nytt Maven-projekt.

Skapa ett nytt Maven-projekt

#två) Ta bort dummypaket som tillhandahålls av MAVEN, dvs. “Src / main / java” och “Src / test / java”

Ta bort dummypaket som tillhandahålls av MAVEN

# 3) Gå till pom.xml-filen och ta bort JUnit-beroendet eftersom vi inte behöver det.

# 4) Sedan kräver vi HTTP-klientbiblioteket, HTTP-kärnbiblioteket, JSON Parser-biblioteket, TestNG-biblioteket, Jackson-data bind-biblioteket

# 5) Lägg till ovanstående beroenden (bibliotek) i pom.xml-filen.

HTTP-klientbibliotek:

HTTP-klientbibliotek

HTTP-kärnbibliotek:

HTTP-kärnbibliotek

JSON Parser-bibliotek:

JSON Parser-bibliotek

TestNG-bibliotek:

TestNG-bibliotek

# 6) Ladda ner de senaste och stabila versionerna. Vi kommer inte att lägga till Selenburk i vårt projekt, eftersom vi gör fullständig backendtestning. Den slutliga pom.xml-filen ser ut som i bilden nedan:

Slutlig POM.xml-fil

# 7) Skapa sedan en ram för ditt API-test

till) Skapa ett paket “com.qa.config” -> Skapa en fil 'config.properties' och lagra alla webbadresser.

Skapa ett paket “com.qa.config”

b) Skapa ett annat paket “qa.com.base” -> Skapa en klass 'testBase.java' som kommer att vara en överordnad klass för alla klasser. Den innehåller vanliga funktioner som ska användas av alla metoder.

Ett annat paket “qa.com.base”

c) Skapa ett annat paket 'com.qa.client' och klass 'restClient.java'. Denna innehåller kod för att hämta GET, POST, DELETE, PUT-samtal.

d) Skapa ett annat paket 'com.qa.data' och klass 'user.java' som definierar olika användaregenskaper.

paketet

är) Slutligen skapa ett paket 'com.qa.Test' under 'src / test / java' och förklara en huvudmetod och funktioner för att testa alla GET, PUT, POST och Delete-metoder.

f) Den slutliga ramstrukturen ser ut som visas nedan:

Slutlig ramstruktur

g) Använd dummy API från denna webbplats REQ RES .

HTTP-metoder eller CRUD-operationer

Låt oss se olika HTTP-metoder eller CRUD-operationer som vi automatiserar.

Nedan listade operationer kallas CRUD-operationer:

  • C : Skapa (betyder POST-samtal)
  • R : Hämta (betyder GET-samtal)
  • U : Uppdatering (betyder PUT-samtal)
  • D : Radera (betyder Radera samtal)

Parametrar i REST Web Services

Validera eller betona nedanstående parametrar i REST Web Services:

(i) URI: URI är kombinationen av parametern URL + Path och frågeparametern.

Exempel: http://api.com/service/account/1

Här, api.com är URL: en för S2-servern, service är innehavaren. I denna tjänst går innehavaren till konto klass, och från denna kontoklass kallar den metoden konto = 1. I varje samtal passerar vi URI.

(ii) Nyttolast: JSON / XML-data som vi matar till systemet.

(iii) Statuskod: För varje svar får vi statuskoderna.

Här är några koder listade nedan:

  • 200: Okej, allt fungerar bra.
  • 201: Skapades framgångsrikt, närhelst du gör POST-samtal eller skapar en ny enhet.
  • 400: Nyttolasten är fel, slutadressen är fel, visar dålig begäran.
  • 404: Uppdatera eller ta bort en enhet och den enheten är inte tillgänglig, då får vi resultat som en begäran som inte hittades.
  • 500: Antag att S2-servern är nere, vi får ett internt serverfel.
  • 401: Verifieringsfel

Klick här för att få alla statuskoder.

(iv) Rubriker: Som autentiseringstoken, användar-id / lösenord, innehållstyp, etc.

slumpgenerator 0-1

Rubriker

CRUD-operationer med hjälp av Apache HTTP-klient

# 1) FÅ RING

Hur beter sig GET Call-funktionen?

Get Call skickar begäran och får tillbaka svaret. Vi skickar inte någon JSON eller nyttolasten här, vi skickar en URI, i vilken URL (endpoint path parameter, query parameter) tillsammans med rubriken, om tillgänglig.

hur man ställer in selen

Innan du skriver GET-anropskoden, tänk på följande:

  • Behöver en GET-metod
  • Behöver sedan en URL
  • När du trycker på skicka-knappen får du svaret. Lagra sedan svaret.
  • Behöver statuskod, rubriker.

Se skärmdumpen nedan av POSTMAN-klienten som visar GET-samtalssvar:

POSTMAN-klient

I restClient.java-klass,

(i) Skapa GET-metoden som kommer att ringa URL: en och få svaret i form av JSON-objekt utan rubrik.

package com.qa.Client; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.util.HashMap; import java.util.Map; import org.apache.http.Header; import org.apache.http.client.ClientProtocolException; import org.apache.http.client.methods.CloseableHttpResponse; import org.apache.http.client.methods.HttpDelete; import org.apache.http.client.methods.HttpGet; import org.apache.http.client.methods.HttpPost; import org.apache.http.client.methods.HttpPut; import org.apache.http.entity.StringEntity; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.apache.http.util.EntityUtils; import org.json.JSONException; import org.json.JSONObject; public class restClient { // create GET Method, which will call the URL and get the response in the form of JSON object without Header public CloseableHttpResponse getMethod(String Url) throws ClientProtocolException, IOException, JSONException{ /*Call HTTPClients class from HTTPClient library added in POM.xml. Call createDefault() method present in HTTPClients class, which will create a client connection. And this createDefault() method returns 'CloseableHttpClient' object which is an abstract class. And we are creating a reference to that abstract class */ CloseableHttpClient httpClient=HttpClients.createDefault(); /*create an object for HttpGet class, which is used for HTTP GET Request. And pass the URL which is to be loaded*/ HttpGet htttpGet = new HttpGet(Url); /*execute the HTTP GET Request, means it will hit the GET API call as we click SEND button from POSTMAN client. httpClient.execute() method returns the response 'CloseableHttpResponse' interface and store it in reference variable So the complete response is stored in CloseableHttpResponse And fetch all the details, in our test case/test method */ CloseableHttpResponse closeableHttpResponse = httpClient.execute(htttpGet); return closeableHttpResponse; } }

(ii) Skapa huvudklass “getAPITest.java” under “src / test / java”

Produktion
Produktion

# 2) POST-samtal

POST Call skapar ett konto eller skapar en ny enhet.
Exempel - Skicka dessa uppgifter som namn, jobb och rubrik till JSON-nyttolasten. S2-servern kommer att länkas till någon databas, säg Oracle och har något tabellnamn som heter Kontotabell. POST-metoden skapar en post i databasen och S2-servern skickar informationen till S1-klienten. Kom ihåg att POST-samtalsfunktionen alltid används för att skapa en ny enhet.

POST Call skapar ett konto eller skapar en ny enhet

I POST-metoden måste vi skicka URL och nyttolast.

Ladda ner detta beroende eftersom vi behöver konvertera Java-klass till Java-objekt än till JSON-objekt.

beroende

I restClient.java-klass,

(i) Skapa POST-metod, som anropar URL: en och skickar svaret.

public class restClient { public CloseableHttpResponse POST(String url,String entityString,HashMap headermap) throwsClientProtocolException, IOException{ /*Call HTTPClients class from HTTPClient library added in POM.xml and createDefault() method present in HTTPClients class, which will create a client connection and this createDefault() method returns 'CloseableHttpClient' object which is an abstract class and we are creating reference to that abstract class */ CloseableHttpClient httpClient=HttpClients.createDefault(); /*create an object for HttpPost class, which is used for HTTP POST Request and pass the URL which is to be loaded */ HttpPost htttpPost = new HttpPost(url); /*define pay load, use setEnity method present in HTTPPOST class and pass the payload entity */ htttpPost.setEntity(new StringEntity(entityString)); //Create a for loop and iterate the hashmap, and store the header for(Map.Entry entry : headermap.entrySet()){ htttpPost.addHeader(entry.getKey(),entry.getValue()); } //Execute the POST request CloseableHttpResponse closeableHttpResponse = httpClient.execute(htttpPost); return closeableHttpResponse; } }

(ii) Skapa huvudklassen “postAPI_Test.java” under “src / test / java”.

//Inherit testBase class public class postAPI_Test extends testBase { //Create global methods testBase testbase; String serviceURL; String apiURL; String URL; restClient restClient; HttpResponse closeableHttpResponse; // In before method call the properties file @BeforeMethod public void setUp() throws ClientProtocolException, IOException, JSONException{ //call the constructor of base class and execute the properties file testbase = new testBase(); serviceURL = prop.getProperty('URL'); apiURL = prop.getProperty('serviceURL'); URL = serviceURL+apiURL; } //Main method which calls the GET method @Test public void POSTAPITest() throws ClientProtocolException, IOException, JSONException{ restClient = new restClient(); //Pass the Request Header HashMap headrMap = new HashMap(); headrMap.put('Content-Type', 'application/json'); /*Use Jackson API for doing marshaling, means converting java to java object to JSON Object and vice versa Use ObjectMapper class */ ObjectMapper mapper = new ObjectMapper(); //Create object of Users class, expected users users user = new users('John','Manager'); //Convert java object 'user' to JSON Object using writeValue(), pass the path where to store the JSON file and the object to be converted */ mapper.writeValue(new File('.\data\users.json'), user ); //convert java object to json in string String userJsonString = mapper.writeValueAsString(user); System.out.println(userJsonString); //Call the POST Method closeableHttpResponse = restClient.POST(URL, userJsonString, headrMap); //Fetches status, header, and JSON response from CloseableHttpResponse //1.Fetch Status Code int statusCode = closeableHttpResponse.getStatusLine().getStatusCode();//Get the Status code System.out.println('Status Code --->' +statusCode); //Validate the status code using Assert class Assert.assertEquals(statusCode, response_Status_Code_201,'Status is not 200'); /*2.Fetch the JSON String use EntityUtils class and call to String method, where we have to pass entity and format entity is available in closeableHttpResponse and pass UTF-8 format because we want pure string so complete JSON will be stored in a String, so we need to convert an entire string into a JSON object */ String responseString = EntityUtils.toString(closeableHttpResponse.getEntity(), 'UTF-8'); /*as we added one JSON library, from that library call JSON class and pass the response string. So this JSON object converts the string into JSON */ JSONObject responseJson = new JSONObject(responseString); System.out.println('Response JSONfrom API --->'+responseJson); /*Convert JSON to java actual User Object we are getting */ users userResObj = mapper.readValue(responseString, users.class); Assert.assertTrue(user.getName().equals(userResObj.getName())); Assert.assertTrue(user.getJob().equals(userResObj.getJob()));} }

Produktion:
Output_POST-samtal

# 3) PUT Ring

Med PUT-samtalsfunktionen kan du skapa en ny enhet och uppdatera en befintlig enhet.

I restClient.java-klass,

(i) Skapa PUT-metod, som anropar URL: en och uppdaterar svaret.

public class restClient { public CloseableHttpResponse PUT(String url,String entityString,HashMap headermap) throwsClientProtocolException, IOException{ /*Call HTTPClients class from HTTPClient library added in POM.xml. Call createDefault() method present in HTTPClients class, which will create a client connection and this createDefault() method returns 'CloseableHttpClient' object which is an abstract class and we are creating reference to that abstract class*/ CloseableHttpClient httpClient=HttpClients.createDefault(); /*create an object for HttpPut class, which is used for HTTP PUT Request and pass the URL which is to be loaded */ HttpPut htttpPut = new HttpPut(url); /*define pay load, use setEnity method present in HTTPPUT class and pass the payload entity */ htttpPut.setEntity(new StringEntity(entityString)); /*create a for loop, iterate and store the header */ for(Map.Entry entry : headermap.entrySet()){ htttpPut.addHeader(entry.getKey(),entry.getValue()); } //Execute the PUT request CloseableHttpResponse closeableHttpResponse = httpClient.execute(htttpPut); return closeableHttpResponse; } }

(ii) Skapa huvudklassen 'putAPI_Test.java' under 'src / test / java'

//Inherit testBase class public class putAPI_Test extends testBase { //Create global methods testBase testbase; String serviceURL; String apiURL; String URL; restClient restClient; HttpResponse closeableHttpResponse; // in before method call the properties file @BeforeMethod public void setUp() throws ClientProtocolException, IOException, JSONException{ //Call the constructor of the base class and execute the properties file testbase = new testBase(); serviceURL = prop.getProperty('URL'); apiURL = prop.getProperty('serviceURL'); URL = serviceURL+apiURL; } //Main method which calls PUT method @Test public void PUTAPITest() throws ClientProtocolException, IOException, JSONException{ restClient = new restClient(); //Pass the Request Header HashMap headrMap = new HashMap(); headrMap.put('Content-Type', 'application/json'); /*use Jackson API, for doing marshaling means converting java to java object to JSON Object and vice versa, use ObjectMapper class */ ObjectMapper mapper = new ObjectMapper(); //Create object of Users class, new users users user = new users('JohnMarry Dicosta','HRManager'); /*Convert java object 'user' to JASON Object using writeValue() and pass the path where to store the JSON file and the object to be converted */ mapper.writeValue(new File('.\data\users.json'), user ); //convert java object - > JSON - >String String userJsonString = mapper.writeValueAsString(user); System.out.println(userJsonString); //Call the PUT Method closeableHttpResponse = restClient.PUT(URL, userJsonString, headrMap); /*fetch status, header, JSON response from CloseableHttpResponse Fetch Status Code */ int statusCode = closeableHttpResponse.getStatusLine().getStatusCode(); System.out.println('Status Code --->' +statusCode); //Validate the status code using Assert class Assert.assertEquals(statusCode, response_Status_Code_200,'Status is 200'); /*2.Fetch the JSON String, use EntityUtils class and call to String method where we have to pass entity and format entity is available in closeableHttpResponse and pass UTF-8 format because we want a pure string. So complete JSON will be stored in a String, so we need to convert an entire string into a JSON object */ String responseString = EntityUtils.toString(closeableHttpResponse.getEntity(), 'UTF-8'); /* From JSON library, call JSON class and pass the response string. This JSON object converts the string to JSON */ JSONObject responseJson = new JSONObject(responseString); System.out.println('Response JSONfrom API --->'+responseJson);}

Produktion

Putcall-output

# 4) Ta bort samtal

Radera samtalsfunktioner är enkla, dvs. ta bort konto-ID-100 och skicka informationen i en JSON-fil.

I restClient.java-klass,

(i) Skapa Radera Metod, som kommer att ringa URL och ta bort posten.

public CloseableHttpResponse Delete(String url) throws ClientProtocolException, IOException{ /*Call HTTPClients class from HTTPClient library added in POM.xml and createDefault() method present in HTTPClients class, which will create a client connection and this createDefault() method returns 'CloseableHttpClient' object which is an abstract class and we are creating reference to that abstract class */ CloseableHttpClient httpClient=HttpClients.createDefault(); /*create an object for HttpDelete class, which is used for HTTP Delete Request, and pass the URL to be loaded*/ HttpDelete htttpDelete = new HttpDelete(url); //execute Delete request CloseableHttpResponse closeableHttpResponse =httpClient.execute(htttpDelete); return closeableHttpResponse; }

(ii) Skapa huvudklassen 'deleteAPI_Test.java' under 'src / test / java'.

public class deleteAPI_Test extends testBase { //Create global methods testBase testbase; String serviceURL; String deleteuserUrl; String URL; restClient restClient; HttpResponse closeableHttpResponse; // In before method call the properties file @BeforeMethod public void setUp() throws ClientProtocolException, IOException, JSONException{ //call the constructor of the base class and execute the properties file testbase = new testBase(); serviceURL = prop.getProperty('URL'); deleteuserUrl = prop.getProperty('deleteuser'); URL = serviceURL+deleteuserUrl; } //The Main method which calls the Delete method @Test public void deleteAPI() throws ClientProtocolException, IOException, JSONException{ restClient = new restClient(); //Method returns closeableHttpResponse type closeableHttpResponse = restClient.Delete(URL); /*fetch status code, header, JSON response from CloseableHttpResponse -Fetch Status Code */ int statusCode = closeableHttpResponse.getStatusLine().getStatusCode(); System.out.println('Status Code --->' +statusCode); //Validate the status code using Assert class Assert.assertEquals(statusCode, response_Status_Code_204,'Status is 204 No Content'); }

Produktion
Ta bort samtalsutgång

Innan du validerar något svar får du rätt URL från utvecklaren och kontrollerar sedan om du får förväntat svar från servern, förbereder testfall för varje scenario och ordnar testfall i följd w.r.t-funktionalitet.

Slutsats

I den här artikeln har vi beskrivit hur man använder Apache HTTP-klient för automatisering av POST-, PUT-, GET- och Radera-samtal i detalj med kodexempel. Vi har också diskuterat webbtjänsttyper och vikten av JSON / XML-filer och varför de används.

PREV-handledning | FÖRSTA självstudier

Rekommenderad läsning

^