REST-asiakastestaus Restito-työkalulla: Mikä on Rest Client?
Michael Thompson
Mikä on REST?
REST tarkoittaa "REpresentational State Transfer", joka on uusi tapa kommunikoida minkä tahansa kahden järjestelmän välillä tiettynä ajankohtana. Toinen järjestelmistä on nimeltään "REST Client" ja toinen "REST Server".
Ennen kuin opit tutustumaan Restito Framework for REST -asiakastestaukseen, meidän on ensin opittava muutama perusasia.
Mikä on REST-asiakas?
REST Client on menetelmä tai työkalu, jolla voidaan kutsua REST-palvelun API, joka on kaikkien järjestelmien tai palveluntarjoajien käytettävissä viestintää varten. Esimerkki: jos API altistetaan saamaan reaaliaikaisia liikennetietoja Googlelta, Googlen liikennesovellusliittymää kutsuvaa ohjelmistoa/työkalua kutsutaan REST-asiakkaaksi.
Mikä on REST-palvelin?
Se on menetelmä tai API, joka on alttiina minkä tahansa järjestelmän tai palveluntarjoajan kommunikaatiolle. Google esimerkiksi paljastaa API:n saadakseen reaaliaikaisia liikennetietoja tietyllä reitillä.
Tässä Google-palvelimen on oltava käynnissä, jotta se voi kuunnella eri asiakkaiden paljastetun API:n pyyntöjä.
Esimerkiksi:
On aika luoda täydellinen päästä päähän -skenaario yllä olevista määritelmistä.
Ajatellaanpa Uberin kaltaisia taksivaraussovelluksia, sillä yritys tarvitsee reaaliaikaista tietoa liikennetilanteesta reiteillä, joilla tietty ajoneuvo sijaitsee.
Rest Client:
Tässä asiakas on Uber-mobiilisovellus, johon kuljettaja on kirjautunut. Tämä sovellus lähettää pyynnön Google Mapsin paljastamalle REST API:lle reaaliaikaisten tietojen saamiseksi. Esimerkiksi HTTP GET -pyyntö.
Lepopalvelin:
Tässä esimerkissä Google on palveluntarjoaja, ja Google Mapsin API vastaa vaadituilla tiedoilla Uber-sovelluksen pyyntöön.
Sekä asiakas että palvelin ovat yhtä tärkeitä REST-viestinnässä.
Tässä olemme toteuttaneet esimerkkejä vain REST-asiakasohjelman automaatiotestaukseen. Katso REST-palvelimen testaamisesta https://www.guru99.com/top-6-api-testing-tool.html.
Mikä on Restito?
Restito on Mkotsurin kehittämä kehys. Se on kevyt sovellus, jonka avulla voit suorittaa kaikenlaisia HTTP-pyyntöjä. Restiton avulla voit testata REST-sovellusliittymiäsi ja etsiä ongelmia sovelluksessasi tai verkossasi.
Kuinka testata REST-asiakasta Restiton avulla?
Jaetaan harjoitus seuraavaan neljään vaiheeseen:
- Luo HTTP-asiakas ja menetelmä HTTP GET -pyynnön lähettämiseksi mihin tahansa palvelimen päätepisteeseen. Pidä päätepisteenä toistaiseksi
http://localhost:9092/getevents.
- Käynnistä Restito-palvelin kuunnellaksesi ja siepataksesi pyynnöt, jotka lähetetään päätepisteeseen "getevents" localhostissa
http://localhost:9092/getevents.
- Luo testiluokka testataksesi yllä olevaa asiakasta. Kutsu HTTP-asiakas "sendGETRequest" -menetelmä GET-pyynnön käynnistämiseksi API "getevents" -liittymään.
- Vahvista HTTP GET -kutsu Restito-kehyksen avulla.
Sukellaanpa syvästi jokaiseen yllä olevaan vaiheeseen.
Vaihe 1) Luo HTTP-asiakas ja menetelmä HTTP GET -pyynnön lähettämiseksi mihin tahansa palvelimen päätepisteeseen.
========== JAVA-KOODI Alkaa ============
package com.chamlabs.restfulservices.client;
import java.util.HashMap;
import java.util.Map;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.json.JSONObject;
/**
* This class creates a HTTP Client and has a method to send HTTP GET request:
* sendGETRequest(..)
*/
public class RestClient {
/**
* Constructor for the class RestClient
*/
public RestClient() {
System.out.println("Creating RestClient constructor");
}
/**
* Method to Send GET request to http://localhost:<<port>>/getevents
* @param port
* @return true if GET request is successfully sent. False, otherwise.
*/
public static boolean sendGETRequest(int port) {
try {
HttpClient client = HttpClientBuilder.create().build();
HttpGet getRequest = new HttpGet("http://localhost:" + port + "/getevents");
//HttpResponse response = client.execute(request);
client.execute(getRequest);
System.out.println("HTTP request is sent successfully."
+ "Returning True");
return true;
}
catch (Exception e) {
e.printStackTrace();
}
System.out.println("Some exception has occurred during the HTTP Client creation."
+ "Returning false");
return false;
}
}
========== JAVA-KOODI päättyy ============
Vaihe 2) Käynnistä Restito-palvelin kuunnellaksesi ja siepataksesi pyynnöt, jotka lähetetään päätepisteeseen "getevents" localhostissa http://localhost:9092/getevents.
========== JAVA-KOODI Alkaa ============
package com.chamlabs.restfultesting.util;
import static com.xebialabs.restito.builder.stub.StubHttp.whenHttp;
import static com.xebialabs.restito.semantics.Action.status;
import static com.xebialabs.restito.semantics.Condition.get;
import static com.xebialabs.restito.semantics.Condition.post;
import java.util.List;
import org.glassfish.grizzly.http.util.HttpStatus;
import com.xebialabs.restito.semantics.Call;
import com.xebialabs.restito.server.StubServer;
/**
* This utility class contains several utility methods like :
* restartRestitoServerForGETRequests(..)
* restartRestitoServerForPOSTRequests(..)
* waitAndGetCallList(..)
*
* @author cham6
* @email: paperplanes.chandra@gmail.com
* @fork: https://github.com/cham6/restfultesting.git
*
*/
public class TestUtil {
/**
* Utility method to start restito stub server to accept GET requests
* @param server
* @param port
* @param status
*/
public static void restartRestitoServerForGETRequests (StubServer server, int port, HttpStatus status)
{
// Kill the restito server
if (server != null) {
server.stop();
}
// Initialize and configure a newer instance of the stub server
server = new StubServer(port).run();
whenHttp(server).match(get("/getevents")).then(status(status));
}
/**
* Utility method to start restito stub server to accept POST requests
* @param server
* @param port
* @param status
*/
public static void restartRestitoServerForPOSTRequests (StubServer server, int port, HttpStatus status)
{
// Kill the restito server
if (server != null) {
server.stop();
}
// Initialize and configure a newer instance of the stub server
server = new StubServer(port).run();
whenHttp(server).match(post("/postevents")).then(status(status));
}
/**
* For a given restito stub server, loop for the given amount of seconds and
* break and return the call list from server.
*
* @param server
* @param waitTimeInSeconds
* @return
* @throws InterruptedException
*/
public static List<Call> waitAndGetCallList (StubServer server, int waitTimeInSeconds)
throws InterruptedException
{
int timeoutCount = 0;
List<Call> callList = server.getCalls();
while (callList.isEmpty()) {
Thread.sleep(1000);
timeoutCount++;
if (timeoutCount >= waitTimeInSeconds) {
break;
}
callList = server.getCalls();
}
// Wait for 2 seconds to get all the calls into callList to Eliminate any falkyness.
Thread.sleep(2000);
return server.getCalls();
}
}
========== JAVA-KOODI päättyy ============
Vaihe 3) Luo testiluokka testataksesi yllä olevaa asiakasta. Kutsu HTTP-asiakas sendGETRequest -menetelmä käynnistääksesi GET-pyynnön API 'getevents'ille.
========== JAVA-KOODI Alkaa ============import junit.framework.TestCase;
import com.chamlabs.restfulservices.client.RestClient;
import com.chamlabs.restfultesting.util.TestUtil;
import com.xebialabs.restito.semantics.Call;
import com.xebialabs.restito.server.StubServer;
import static org.glassfish.grizzly.http.util.HttpStatus.ACCEPTED_202;
import org.json.JSONObject;
import java.util.List;
import java.util.Map;
/**
* This class contains several junit tests to validate the RestClient operations like:
* sendRequest(..)
* sendRequestWithCustomHeaders(..)
* sendPOSTRequestWithJSONBody(..)
*
*/
public class RestClientTester extends TestCase {
private static final Integer PORT = 9098;
private static final Integer PORT2 = 9099;
private static final Integer PORT3 = 9097;
public RestClientTester() {
System.out.println("Starting the test RestClientTester");
}
/**
* Junit test to validate the GET request from RestClient
* Steps:
* 1) Create a stub server using Restito framework and configure it to listen on given port
* 2) Invoke the sendGETRequest(..) method of RestClient
* 3) Restito captures the matching GET requests sent, if any.
* 4) Validate if Restito has captured any GET requests on given endpoint
* Expected Behavior:
* > Restito should have captured GET request and it should have captured only one GET request.
* Finally:
* > Stop the stub server started using restito.
*/
public void testGETRequestFromClient() {
StubServer server = null;
try {
//This will start the stub server on 'PORT' and responds with HTTP 202 'ACCEPTED_202'
TestUtil.restartRestitoServerForGETRequests(server, PORT, ACCEPTED_202);
RestClient.sendGETRequest(PORT);
List<Call> callList = TestUtil.waitAndGetCallList(server, 30);
assertTrue("GET request is not received from the RestClient. Test failed.",
(callList != null) && (callList.size() == 1));
}
catch(Exception e) {
e.printStackTrace();
fail("Test Failed due to exception : " + e);
}
finally {
if(server != null) {
server.stop();
}
}
}
========== JAVA-KOODI päättyy ============
Vaihe 4) Kuinka vahvistaa GET-pyyntö otsikoilla ja POST-pyyntö rungon kanssa Restito-kehyksen avulla.
========== JAVA-KOODI Alkaa ============
/**
* Junit test to validate the GET request with headers from RestClient
* Steps:
* 1) Create a stub server using Restito framework and configure it to listen on given port
* 2) Invoke the sendGETRequestWithCustomHeaders(..) method of RestClient
* 3) Restito captures the matching GET requests sent, if any.
* 4) Validate if Restito has captured any GET requests on a given endpoint
* Expected Behavior:
* > Restito should have captured GET request, and it should have captured only one GET request.
* > Get the headers of the captured GET request
* and make sure the headers match to the ones configured.
* Finally:
* > Stop the stub server started using restito.
*/
public void testGETRequestWithHeadersFromClient() {
StubServer server = null;
try {
//This will start the stub server on 'PORT' and responds with HTTP 202 'ACCEPTED_202'
TestUtil.restartRestitoServerForGETRequests(server, PORT2, ACCEPTED_202);
RestClient.sendGETRequestWithCustomHeaders(PORT2);
List<Call> callList = TestUtil.waitAndGetCallList(server, 30);
assertTrue("GET request is not received from the RestClient. Test failed.",
(callList != null) && (callList.size() == 1));
//Validate the headers of the GET request from REST Client
Map<String, List<String>> headersFromRequest = callList.get(0).getHeaders();
assertTrue("GET request contains header Accept and its value ",
headersFromRequest.get("Accept").contains("text/html"));
assertTrue("GET request contains header Authorization and its value ",
headersFromRequest.get("Authorization").contains("Bearer 1234567890qwertyuiop"));
assertTrue("GET request contains header Cache-Control and its value ",
headersFromRequest.get("Cache-Control").contains("no-cache"));
assertTrue("GET request contains header Connection and its value ",
headersFromRequest.get("Connection").contains("keep-alive"));
assertTrue("GET request contains header Content-Type and its value ",
headersFromRequest.get("Content-Type").contains("application/json"));
}
catch(Exception e) {
e.printStackTrace();
fail("Test Failed due to exception : " + e);
}
finally {
if(server != null) {
server.stop();
}
}
}
/**
* Junit test to validate the POST request with body and headers from RestClient
* Steps:
* 1) Create a stub server using Restito framework and configure it to listen on given port
* 2) Invoke the sendPOSTRequestWithJSONBody(..) method of RestClient
* 3) Restito captures the matching POST requests sent, if any.
* 4) Validate if Restito has captured any POST requests on given endpoint
* Expected Behavior:
* > Restito should have captured POST request and it should have captured only one POST request.
* > Get the body of the captured POST request and validate the JSON values
* Finally:
* > Stop the stub server started using restito.
*/
public void testPOSTRequestWithJSONBody() {
StubServer server = null;
try {
//This will start the stub server on 'PORT' and responds with HTTP 202 'ACCEPTED_202'
TestUtil.restartRestitoServerForPOSTRequests(server, PORT3, ACCEPTED_202);
RestClient.sendPOSTRequestWithJSONBody(PORT3);
List<Call> callList = TestUtil.waitAndGetCallList(server, 30);
assertTrue("POST request is not received from the RestClient. Test failed.",
(callList != null) && (callList.size() == 1));
//Validate the headers of the GET request from REST Client
String requestBody = callList.get(0).getPostBody();
JSONObject postRequestJSON = new JSONObject(requestBody);
assertTrue("The timeUpdated in json is incorrect",
postRequestJSON.get("timeUpdated").toString().equalsIgnoreCase("1535703838478"));
assertTrue("The access_token in json is incorrect",
postRequestJSON.get("access_token").toString().
equalsIgnoreCase("abf8714d-73a3-42ab-9df8-d13fcb92a1d8"));
assertTrue("The refresh_token in json is incorrect",
postRequestJSON.get("refresh_token").toString().
equalsIgnoreCase("d5a5ab08-c200-421d-ad46-2e89c2f566f5"));
assertTrue("The token_type in json is incorrect",
postRequestJSON.get("token_type").toString().equalsIgnoreCase("bearer"));
assertTrue("The expires_in in json is incorrect",
postRequestJSON.get("expires_in").toString().equalsIgnoreCase("1024"));
assertTrue("The scope in json is incorrect",
postRequestJSON.get("scope").toString().equalsIgnoreCase(""));
}
catch(Exception e) {
e.printStackTrace();
fail("Test Failed due to exception : " + e);
}
finally {
if(server != null) {
server.stop();
}
}
}
}
========== JAVA-KOODI päättyy ============
Restito Frameworkin käytön edut REST-asiakastestaukseen
Tässä on Restito Frameworkin edut/edut ReST-asiakastestaukseen
- Emme tarvitse varsinaista REST-palvelinta kehittääksemme REST-asiakkaan testaamiseen.
- Restito tarjoaa vahvoja ja monipuolisia apuohjelmia ja menetelmiä palvelimen erilaisen käyttäytymisen pilkkaamiseen. Esimerkki: Testaa, kuinka REST-asiakas toimii, kun palvelin vastaa HTTP 404 -virheellä tai HTTP 503 -virheellä.
- Restito-palvelimet voidaan asentaa muutamassa millisekunnissa ja ne voidaan lopettaa testien päätyttyä.
- Restito tukee kaikentyyppisiä HTTP-menetelmien sisältöjä, kuten pakattu, pakkaamaton, yhdistetty, sovellus/teksti, sovellus/JSON jne.
Restito Frameworkin käytön haitat REST-asiakastestaukseen
Tässä on Restito Frameworkin haitat / haitat ReST-asiakastestaukseen
- REST-asiakaslähdettä tulee säätää niin, että 'localhost' voidaan pitää palvelinkoneena.
- Palvelimen avaaminen missä tahansa portissa voi olla ristiriidassa, jos käytämme jotakin yleisesti käytettyä porttia, kuten '8080' tai '9443' jne.
- On suositeltavaa käyttää portteja, kuten 9092 tai 9099, joita muut työkalut eivät yleensä käytä.
Yhteenveto
- REST on lyhenne sanoista "REpresentational State Transfer", joka on uusi standardi tapa kommunikoida minkä tahansa kahden järjestelmän välillä tiettynä ajankohtana.
- REST Client on menetelmä tai työkalu, jolla voidaan kutsua REST-palvelun API, joka on alttiina minkä tahansa järjestelmän tai palveluntarjoajan kommunikaatiolle.
- RestServer-menetelmässä tai API:ssa, joka on alttiina minkä tahansa järjestelmän tai palveluntarjoajan kommunikaatiolle.
- Restito on kevyt sovellus, jonka avulla voit suorittaa kaikenlaisia HTTP-pyyntöjä
- Luo HTTP-asiakas ja menetelmä HTTP GET -pyynnön lähettämiseksi mihin tahansa palvelimen päätepisteeseen
- Käynnistä Restito-palvelin kuunnellaksesi ja siepataksesi päätepisteeseen "getevents" lähetettyjä pyyntöjä.
- Käynnistä Restito-palvelin kuunnellaksesi ja siepataksesi pyynnöt, jotka lähetetään päätepisteeseen "getevents" localhostissa
- Tässä olemme toteuttaneet esimerkkejä vain REST-asiakasohjelman automaatiotestaukseen.
- Emme tarvitse varsinaista REST-palvelinta kehittääksemme REST-asiakkaan testaamiseen.
- REST-asiakaslähdettä tulee säätää niin, että 'localhost' voidaan pitää palvelinkoneena.
