REST Client Testing using Restito Tool: What is Rest Client?
What is REST?
REST stands for “REpresentational State Transfer,” which is a new way of communication between any two systems at a given point of time. One of the systems is called ‘REST Client,’ and the other is called ‘REST Server’.
Before learning about Restito Framework for REST client testing, let us first learn a few basics.
What is REST Client?
REST Client is a method or a tool to invoke a REST service API that is exposed for communication by any system or service provider. For example: if an API is exposed to get real time traffic information about a route from Google, the software/tool that invokes the Google traffic API is called the REST client.
What is REST Server?
It is a method or an API that is exposed to communication by any system or service provider. For example, Google exposes an API to get real time traffic information on a given route.
Here, the Google server needs to be up and running to listen to any requests to the exposed API from different clients.
Example:
It is time to establish a complete End-to-End scenario from the above definitions.
Let us consider a taxi booking applications like Uber as a company needs real time information on the traffic situation around the routes that a given vehicle is located in.
Rest Client:
Here the client is an Uber mobile application the driver has logged on to. This app sends a request to the REST API exposed by Google maps to get the real time data. For example, A HTTP GET request.
Rest Server:
In this example, Google is the Service provider, and Google maps’ API responds with the required details to Uber app’s request.
Both the client and server are equally important in REST communication.
Here, we have implemented examples for automation testing of only the REST Client. For testing REST server, refer to https://www.guru99.com/top-6-api-testing-tool.html.
What is Restito?
Restito is a framework developed by Mkotsur. It is a lightweight app to help you execute any kind of HTTP Request. You can use Restito to test your REST APIs and to search problems in your application or your network.
How to test REST client using Restito?
Let us divide the exercise into the following 4 steps:
- Create a HTTP client and method to send a HTTP GET request to any server endpoint. For now, consider the endpoint to be
http://localhost:9092/getevents
.
- Start a Restito server to listen and capture the requests sent to the endpoint ‘getevents’ in localhost
http://localhost:9092/getevents
.
- Create a test class to test the above client. Invoke the HTTP client ‘sendGETRequest’ method to initiate a GET request to the API ‘getevents’.
- Validate the HTTP GET call using Restito framework.
Let us deep dive into each of the above steps.
Step 1) Create a HTTP client and method to send HTTP GET request to any server endpoint.
========== JAVA CODE Starts ===========
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 CODE Ends ===========
Step 2) Start a Restito server to listen and capture the requests sent to the endpoint ‘getevents’ in localhost http://localhost:9092/getevents
.
========== JAVA CODE Starts ===========
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 CODE Ends ===========
Step 3) Create a test class to test the above client. Invoke the HTTP client sendGETRequest method to initiate a GET request to the API ‘getevents’.
========== JAVA CODE Starts ===========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 CODE Ends ===========
Step 4) How to validate GET request with Headers and POST request with the body using Restito framework.
========== JAVA CODE Starts ===========
/** * 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 CODE Ends ===========
Advantages of using Restito Framework for REST client testing
Here are pros/benefits of Restito Framework for ReST client testing
- We do not need the actual REST server to be developed to test the REST Client.
- Restito provides strong and varied utilities and methods to mock different behavior of a Server. For example: To test how the REST client behaves when Server responds with HTTP 404 error or HTTP 503 error.
- Restito servers can be set up in few milliseconds and can be terminated after the tests are completed.
- Restito supports all types of HTTP method contents like compressed, non-compressed, unified, application/text, application/JSON, etc.
Disadvantages of using Restito Framework for REST client testing
Here are cons/drawback of Restito Framework for ReST client testing
- The REST client source should be tweaked to consider ‘localhost’ as a server machine.
- Opening server in any port may conflict if we use some commonly used port like ‘8080’ or ‘9443’ etc.
- It is advised to use ports like 9092 or 9099, which are not commonly used by other tools.
Summary
- REST stands for “REpresentational State Transfer” which is a new standard way of communication between any two systems at a given point of time.
- REST Client is a method or a tool to invoke a REST service API that is exposed to communication by any system or service provider.
- In RestServer method or an API that is exposed for communication by any system or service provider.
- Restito is a lightweight app to help you execute any kind of HTTP Request
- Create a HTTP client and method to send a HTTP GET request to any server endpoint
- Start a Restito server to listen and capture the requests sent to the endpoint ‘getevents.’
- Start a Restito server to listen and capture the requests sent to the endpoint ‘getevents’ in localhost
- Here, we have implemented examples for automation testing of only the REST Client.
- We do not need the actual REST server to be developed to test the REST Client.
- The REST client source should be tweaked to consider ‘localhost’ as a server machine.