REST Client tesztelése Restito eszközzel: Mi az a Rest Client?

By: Michael Thompson Michael Thompson
Hours korszerűsített

Mi az a REST?

REST a „REpresentational State Transfer” rövidítése, amely a két rendszer közötti kommunikáció új módja egy adott időpontban. Az egyik rendszer neve „REST Client”, a másik pedig „REST Server”.

Mielőtt megismerné a Restito Framework for REST klienstesztelést, először tanuljunk meg néhány alapvetést.

Mi az a REST kliens?

A REST Client egy módszer vagy eszköz egy REST szolgáltatás API meghívására, amely bármely rendszer vagy szolgáltató által elérhető kommunikációra. Például: ha egy API valós idejű forgalmi információkat kap egy útvonalról a Google-tól, akkor a Google forgalmi API-t meghívó szoftvert/eszközt REST-kliensnek nevezik.

Mi az a REST szerver?

Ez egy olyan módszer vagy API, amely bármely rendszer vagy szolgáltató kommunikációjának van kitéve. Például a Google egy API-t tesz közzé, hogy valós idejű forgalmi információkat kapjon egy adott útvonalon.

Itt a Google-szervernek működnie kell, hogy meghallgathassa a különböző kliensektől érkező kéréseket a kitett API-ra.

Példa:

Itt az ideje, hogy a fenti definíciók alapján létrehozzunk egy teljes végponttól végpontig tartó forgatókönyvet.

Tekintsünk egy taxi foglaló alkalmazást, mint például az Uber, mivel egy vállalatnak valós idejű információra van szüksége az adott jármű által elhelyezett útvonalak forgalmi helyzetéről.

Rest Client:

Itt a kliens egy Uber mobilalkalmazás, amelybe a sofőr bejelentkezett. Ez az alkalmazás kérést küld a Google Maps által közzétett REST API-nak, hogy megkapja a valós idejű adatokat. Például egy HTTP GET kérés.

Rest Server:

Ebben a példában a Google a szolgáltató, és a Google Maps API válaszol a szükséges adatokkal az Uber alkalmazás kérésére.

A kliens és a szerver egyaránt fontosak a REST kommunikációban.

Itt példákat implementáltunk csak a REST kliens automatizálási tesztelésére. A REST szerver teszteléséhez lásd: https://www.guru99.com/top-6-api-testing-tool.html.

Mi az a Restito?

A Restito az Mkotsur által kifejlesztett keretrendszer. Ez egy könnyű alkalmazás, amely segít bármilyen HTTP-kérés végrehajtásában. A Restito segítségével tesztelheti a REST API-kat, és kereshet problémákat az alkalmazásban vagy a hálózaton.

Hogyan teszteljük a REST klienst a Restito használatával?

Osszuk fel a gyakorlatot a következő 4 lépésre:

  1. Hozzon létre egy HTTP-ügyfelet és egy metódust, amellyel HTTP GET-kérést küldhet bármely kiszolgálóvégpontra. Egyelőre tekintse a végpontnak azt http://localhost:9092/getevents.
  1. Indítson el egy Restito-kiszolgálót, hogy figyelje és rögzítse a localhost „getevents” végpontjára küldött kéréseket http://localhost:9092/getevents.
  1. Hozzon létre egy tesztosztályt a fenti ügyfél teszteléséhez. Hívja meg a HTTP-kliens „sendGETRequest” metódusát, hogy GET-kérést kezdeményezzen a „getevents” API-hoz.
  1. Érvényesítse a HTTP GET hívást a Restito keretrendszer segítségével.

Merüljünk el mélyen a fenti lépések mindegyikében.

Step 1) Hozzon létre egy HTTP-ügyfelet és egy metódust a HTTP GET-kérés bármely kiszolgálóvégponthoz történő küldéséhez.

========== JAVA KÓD indul ===========

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

========== A JAVA KÓD vége ===========

Step 2) Indítson el egy Restito-kiszolgálót, hogy figyelje és rögzítse a localhost „getevents” végpontjára küldött kéréseket http://localhost:9092/getevents.

========== JAVA KÓD indul ===========

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


}

========== A JAVA KÓD vége ===========

Step 3) Hozzon létre egy tesztosztályt a fenti ügyfél teszteléséhez. Hívja meg a HTTP-kliens sendGETRequest metódusát, hogy GET-kérést kezdeményezzen az API „getevents”-hez.

========== JAVA KÓD indul =========== 
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();
            }
		}	
	}

========== A JAVA KÓD vége ===========

Step 4) Hogyan érvényesíthető a GET kérés fejlécekkel és POST kérés a törzstel a Restito keretrendszer használatával.

========== JAVA KÓD indul ===========

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

========== A JAVA KÓD vége ===========

A Restito Framework használatának előnyei a REST kliens teszteléséhez

Íme a Restito Framework előnyei/előnyei a ReST kliens teszteléséhez

  • A REST Client teszteléséhez nincs szükségünk a tényleges REST szerverre.
  • A Restito erős és változatos segédprogramokat és módszereket kínál a kiszolgálók különböző viselkedésének kigúnyolására. Például: Annak tesztelése, hogy a REST kliens hogyan viselkedik, amikor a szerver HTTP 404 vagy HTTP 503 hibával válaszol.
  • A Restito szerverek néhány ezredmásodperc alatt beállíthatók, és a tesztek befejezése után leállíthatók.
  • A Restito minden típusú HTTP-módszer-tartalmat támogat, például tömörített, nem tömörített, egyesített, alkalmazás/szöveg, alkalmazás/JSON stb.

A Restito Framework alkalmazásának hátrányai a REST kliens teszteléséhez

Íme a Restito Framework hátrányai/hátrányai a ReST kliens teszteléséhez

  • A REST kliens forrását úgy kell módosítani, hogy a „localhost” kiszolgálógépnek minősüljön.
  • A szerver megnyitása bármely porton ütközhet, ha valamilyen gyakran használt portot használunk, például '8080' vagy '9443' stb.
  • Javasoljuk, hogy olyan portokat használjon, mint a 9092 vagy 9099, amelyeket más eszközök általában nem használnak.

Összegzésként

  • A REST a „REpresentational State Transfer” rövidítése, amely egy új szabványos kommunikációs mód bármely két rendszer között egy adott időpontban.
  • A REST Client egy módszer vagy eszköz egy REST szolgáltatás API meghívására, amely bármely rendszer vagy szolgáltató kommunikációjának van kitéve.
  • RestServer metódusban vagy olyan API-ban, amely bármely rendszer vagy szolgáltató által kommunikációra elérhető.
  • A Restito egy könnyű alkalmazás, amely segít bármilyen HTTP-kérés végrehajtásában
  • Hozzon létre egy HTTP-ügyfelet és egy metódust, amellyel HTTP GET-kérést küldhet bármely kiszolgálóvégpontra
  • Indítson el egy Restito-kiszolgálót a „getevents” végpontnak küldött kérések figyeléséhez és rögzítéséhez.
  • Indítson el egy Restito-kiszolgálót, hogy figyelje és rögzítse a localhost „getevents” végpontjára küldött kéréseket
  • Itt példákat implementáltunk csak a REST kliens automatizálási tesztelésére.
  • A REST Client teszteléséhez nincs szükségünk a tényleges REST szerverre.
  • A REST kliens forrását úgy kell módosítani, hogy a „localhost” kiszolgálógépnek minősüljön.

Talán tetszene: