Pengujian REST Client menggunakan Restito Tool: Apa itu Rest Client?

Oleh: Michael Thompson Michael Thompson
Hours Updated

Apa itu REST?

ISTIRAHAT singkatan dari “REpresentational State Transfer,” yang merupakan cara komunikasi baru antara dua sistem pada titik waktu tertentu. Salah satu sistem disebut 'REST Client' dan yang lainnya disebut 'REST Server'.

Sebelum mempelajari tentang Restito Framework untuk pengujian klien REST, mari kita pelajari beberapa dasar terlebih dahulu.

Apa itu Klien REST?

REST Client adalah metode atau alat untuk memanggil API layanan REST yang diekspos untuk komunikasi oleh sistem atau penyedia layanan mana pun. Misalnya: jika API diekspos untuk mendapatkan informasi lalu lintas waktu nyata tentang suatu rute dari Google, perangkat lunak/alat yang memanggil API lalu lintas Google disebut klien REST.

Apa itu Server REST?

Ini adalah metode atau API yang terkena komunikasi oleh sistem atau penyedia layanan apa pun. Misalnya, Google memaparkan API untuk mendapatkan informasi lalu lintas real-time pada rute tertentu.

Di sini, server Google harus aktif dan berjalan untuk mendengarkan permintaan apa pun ke API yang terekspos dari klien yang berbeda.

Contoh:

Sekarang saatnya untuk membuat skenario End-to-End yang lengkap dari definisi di atas.

Mari kita pertimbangkan aplikasi pemesanan taksi seperti Uber karena sebuah perusahaan memerlukan informasi real-time tentang situasi lalu lintas di sekitar rute di mana kendaraan tertentu berada.

Klien Istirahat:

Di sini klien adalah aplikasi seluler Uber yang telah digunakan oleh pengemudi. Aplikasi ini mengirimkan permintaan ke REST API yang diekspos oleh Google Maps untuk mendapatkan data waktu nyata. Misalnya, permintaan HTTP GET.

Server Istirahat:

Dalam contoh ini, Google adalah penyedia Layanan, dan API Google Maps merespons dengan rincian yang diperlukan terhadap permintaan aplikasi Uber.

Baik klien maupun server sama pentingnya dalam komunikasi REST.

Di sini, kami telah menerapkan contoh untuk pengujian otomatisasi hanya pada REST Client. Untuk menguji server REST, lihat https://www.guru99.com/top-6-api-testing-tool.html.

Apa itu Restito?

Restito adalah kerangka kerja yang dikembangkan oleh Mkotsur. Ini adalah aplikasi ringan untuk membantu Anda menjalankan segala jenis Permintaan HTTP. Anda dapat menggunakan Restito untuk menguji API REST Anda dan mencari masalah dalam aplikasi atau jaringan Anda.

Bagaimana cara menguji klien REST menggunakan Restito?

Mari kita bagi latihan ini menjadi 4 langkah berikut:

  1. Buat klien HTTP dan metode untuk mengirim permintaan HTTP GET ke titik akhir server mana pun. Untuk saat ini, pertimbangkan titik akhir http://localhost:9092/getevents.
  1. Mulai server Restito untuk mendengarkan dan menangkap permintaan yang dikirim ke titik akhir 'getevents' di localhost http://localhost:9092/getevents.
  1. Buat kelas pengujian untuk menguji klien di atas. Panggil metode 'sendGETRequest' klien HTTP untuk memulai permintaan GET ke API 'getevents'.
  1. Validasi panggilan HTTP GET menggunakan kerangka Restito.

Mari kita selami lebih dalam setiap langkah di atas.

Langkah 1) Buat klien HTTP dan metode untuk mengirim permintaan HTTP GET ke titik akhir server mana pun.

========== KODE JAVA Dimulai ===========

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

========== KODE JAVA Berakhir ===========

Langkah 2) Mulai server Restito untuk mendengarkan dan menangkap permintaan yang dikirim ke titik akhir 'getevents' di localhost http://localhost:9092/getevents.

========== KODE JAVA Dimulai ===========

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


}

========== KODE JAVA Berakhir ===========

Langkah 3) Buat kelas pengujian untuk menguji klien di atas. Panggil metode sendGETRequest klien HTTP untuk memulai permintaan GET ke 'getevents' API.

========== KODE JAVA Dimulai =========== 
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();
            }
		}	
	}

========== KODE JAVA Berakhir ===========

Langkah 4) Cara memvalidasi permintaan GET dengan Header dan permintaan POST dengan isi menggunakan kerangka Restito.

========== KODE JAVA Dimulai ===========

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

========== KODE JAVA Berakhir ===========

Keuntungan menggunakan Restito Framework untuk pengujian klien REST

Berikut adalah kelebihan/manfaat Restito Framework untuk pengujian klien ReST

  • Kami tidak memerlukan server REST yang sebenarnya untuk dikembangkan untuk menguji REST Client.
  • Restito menyediakan utilitas dan metode yang kuat dan beragam untuk meniru perilaku Server yang berbeda. Misalnya: Untuk menguji bagaimana perilaku klien REST ketika Server merespons dengan kesalahan HTTP 404 atau kesalahan HTTP 503.
  • Server Restito dapat diatur dalam beberapa milidetik dan dapat dihentikan setelah pengujian selesai.
  • Restito mendukung semua jenis konten metode HTTP seperti terkompresi, tidak terkompresi, terpadu, aplikasi/teks, aplikasi/JSON, dll.

Kekurangan menggunakan Restito Framework untuk pengujian klien REST

Berikut adalah kekurangan/kekurangan Restito Framework untuk pengujian klien ReST

  • Sumber klien REST harus diubah untuk mempertimbangkan 'localhost' sebagai mesin server.
  • Membuka server di port mana pun mungkin konflik jika kita menggunakan beberapa port yang umum digunakan seperti '8080' atau '9443' dll.
  • Disarankan untuk menggunakan port seperti 9092 atau 9099, yang tidak umum digunakan oleh alat lain.

Ringkasan

  • REST adalah singkatan dari “REpresentational State Transfer” yang merupakan cara komunikasi standar baru antara dua sistem pada titik waktu tertentu.
  • REST Client adalah metode atau alat untuk memanggil API layanan REST yang diekspos ke komunikasi oleh sistem atau penyedia layanan mana pun.
  • Dalam metode RestServer atau API yang diekspos untuk komunikasi oleh sistem atau penyedia layanan apa pun.
  • Restito adalah aplikasi ringan untuk membantu Anda menjalankan segala jenis Permintaan HTTP
  • Buat klien HTTP dan metode untuk mengirim permintaan HTTP GET ke titik akhir server mana pun
  • Mulai server Restito untuk mendengarkan dan menangkap permintaan yang dikirim ke titik akhir 'getevents'.
  • Mulai server Restito untuk mendengarkan dan menangkap permintaan yang dikirim ke titik akhir 'getevents' di localhost
  • Di sini, kami telah menerapkan contoh untuk pengujian otomatisasi hanya pada REST Client.
  • Kami tidak memerlukan server REST yang sebenarnya untuk dikembangkan untuk menguji REST Client.
  • Sumber klien REST harus diubah untuk mempertimbangkan 'localhost' sebagai mesin server.