Teste de cliente REST usando a ferramenta Restito

Índice:

Anonim

O que é REST?

REST significa "REpresentational State Transfer", que é uma nova forma de comunicação entre dois sistemas em um determinado ponto do tempo. Um dos sistemas é denominado 'Cliente REST' e o outro é denominado 'Servidor REST'.

Neste tutorial REST, você aprenderá:

  • O que é REST?
  • O que é o cliente REST?
  • O que é o servidor REST?
  • O que é Restito?
  • Como testar o cliente REST usando Restito?
  • Vantagens de usar Restito Framework para teste de cliente REST
  • Desvantagens de usar Restito Framework para teste de cliente REST

Antes de aprender sobre Restito Framework para teste de cliente REST, vamos primeiro aprender alguns princípios básicos.

O que é o cliente REST?

Cliente REST é um método ou ferramenta para invocar uma API de serviço REST que é exposta para comunicação por qualquer sistema ou provedor de serviços. Por exemplo: se uma API é exposta para obter informações de tráfego em tempo real sobre uma rota do Google, o software / ferramenta que invoca a API de tráfego do Google é chamado de cliente REST.

O que é o servidor REST?

É um método ou API exposto à comunicação por qualquer sistema ou provedor de serviços. Por exemplo, o Google expõe uma API para obter informações de tráfego em tempo real em uma determinada rota.

Aqui, o servidor do Google precisa estar instalado e funcionando para ouvir quaisquer solicitações à API exposta de diferentes clientes.

Exemplo:

É hora de estabelecer um cenário de ponta a ponta completo a partir das definições acima.

Vamos considerar um aplicativo de reserva de táxi como o Uber, pois uma empresa precisa de informações em tempo real sobre a situação do tráfego nas rotas em que um determinado veículo está localizado.

Cliente de descanso:

Aqui, o cliente é um aplicativo móvel Uber ao qual o motorista se conectou. Este aplicativo envia uma solicitação à API REST exposta pelo Google Maps para obter os dados em tempo real. Por exemplo, uma solicitação HTTP GET.

Servidor de descanso:

Neste exemplo, o Google é o provedor de serviços e a API do Google maps responde com os detalhes necessários à solicitação do aplicativo Uber.

Tanto o cliente quanto o servidor são igualmente importantes na comunicação REST.

Aqui, implementamos exemplos para teste de automação apenas do cliente REST. Para testar o servidor REST, consulte https://www.guru99.com/top-6-api-testing-tool.html.

O que é Restito?

Restito é um framework desenvolvido pela Mkotsur. É um aplicativo leve para ajudá-lo a executar qualquer tipo de solicitação HTTP. Você pode usar o Restito para testar suas APIs REST e pesquisar problemas em seu aplicativo ou rede.

Como testar o cliente REST usando Restito?

Vamos dividir o exercício nas seguintes 4 etapas:

  1. Crie um cliente HTTP e um método para enviar uma solicitação HTTP GET a qualquer ponto de extremidade do servidor. Por enquanto, considere o ponto de extremidade como http: // localhost: 9092 / getevents.
  1. Inicie um servidor Restito para ouvir e capturar as solicitações enviadas ao endpoint 'getevents' em localhost http: // localhost: 9092 / getevents.
  1. Crie uma classe de teste para testar o cliente acima. Invoque o método 'sendGETRequest' do cliente HTTP para iniciar uma solicitação GET para a API 'getevents'.
  1. Valide a chamada HTTP GET usando a estrutura Restito.

Vamos mergulhar fundo em cada uma das etapas acima.

Etapa 1) Crie um cliente HTTP e um método para enviar uma solicitação HTTP GET para qualquer ponto de extremidade do servidor.

========== 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;/ *** Esta classe cria um cliente HTTP e tem um método para enviar solicitação HTTP GET:* sendGETRequest (...)* /public class RestClient {/ *** Construtor para a classe RestClient* /public RestClient () {System.out.println ("Criando construtor RestClient");}/ *** Método para enviar solicitação GET para http: // localhost: <
> / getevents* @param port* @return true se a solicitação GET for enviada com sucesso. Falso, caso contrário.* /public static boolean sendGETRequest (int port) {tentar {Cliente HttpClient = HttpClientBuilder.create (). Build ();HttpGet getRequest = new HttpGet ("http: // localhost: + port + "/ getevents");// Resposta HttpResponse = client.execute (request);client.execute (getRequest);System.out.println ("Solicitação HTTP enviada com sucesso."+ "Retornando True");return true;}catch (Exceção e) {e.printStackTrace ();}System.out.println ("Ocorreu alguma exceção durante a criação do cliente HTTP."+ "Retornando falso");retorna falso;}}

========== Fim do CÓDIGO JAVA ===========

Etapa 2) Inicie um servidor Restito para ouvir e capturar as solicitações enviadas ao endpoint 'getevents' em 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;/ *** Esta classe de utilitário contém vários métodos de utilitário como:* restartRestitoServerForGETRequests (…)* restartRestitoServerForPOSTRequests (…)* waitAndGetCallList (...)** @author cham6* @email: [email protected]* @fork: https://github.com/cham6/restfultesting.git** /public class TestUtil {/ *** Método utilitário para iniciar o servidor stub restito para aceitar solicitações GET* servidor @param* @param port* @param status* /public static void restartRestitoServerForGETRequests (servidor StubServer, porta int, status HttpStatus){// Mate o servidor Restitoif (servidor! = nulo) {server.stop ();}// Inicialize e configure uma instância mais recente do servidor stubservidor = novo StubServer (porta) .run ();whenHttp (server) .match (get ("/ getevents")). then (status (status));}/ *** Método utilitário para iniciar o servidor stub restito para aceitar solicitações POST* servidor @param* @param port* @param status* /public static void restartRestitoServerForPOSTRequests (servidor StubServer, porta int, status HttpStatus){// Mate o servidor Restitoif (servidor! = nulo) {server.stop ();}// Inicialize e configure uma instância mais recente do servidor stubservidor = novo StubServer (porta) .run ();whenHttp (servidor) .match (post ("/ postevents")). then (status (status));}/ *** Para um determinado servidor de stub do Restito, faça um loop por um determinado período de segundos e* interromper e retornar a lista de chamadas do servidor.** servidor @param* @param waitTimeInSeconds* @Retorna* @throws InterruptedException* /public static List  waitAndGetCallList (servidor StubServer, int waitTimeInSeconds)lança InterruptedException{int timeoutCount = 0;Listar  callList = server.getCalls ();while (callList.isEmpty ()) {Thread.sleep (1000);timeoutCount ++;if (timeoutCount> = waitTimeInSeconds) {intervalo;}callList = server.getCalls ();}// Aguarde 2 segundos para obter todas as chamadas em callList para eliminar qualquer falkyness.Thread.sleep (2000);return server.getCalls ();}}

========== Fim do CÓDIGO JAVA ===========

Etapa 3) Crie uma classe de teste para testar o cliente acima. Invoque o método sendGETRequest do cliente HTTP para iniciar uma solicitação GET para a 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;/ *** Esta classe contém vários testes junit para validar as operações RestClient como:* enviar pedido(… )* sendRequestWithCustomHeaders (...)* sendPOSTRequestWithJSONBody (…)** /public class RestClientTester extends TestCase {privado estático final inteiro PORT = 9098;privado estático final inteiro PORT2 = 9099;privado estático final inteiro PORT3 = 9097;public RestClientTester () {System.out.println ("Iniciando o teste RestClientTester");}/ *** Teste Junit para validar a solicitação GET do RestClient* Degraus:* 1) Crie um servidor stub usando a estrutura Restito e configure-o para escutar em determinada porta* 2) Invoque o método sendGETRequest (…) do RestClient* 3) Restito captura as solicitações GET correspondentes enviadas, se houver.* 4) Valide se Restito capturou alguma solicitação GET em determinado endpoint* Comportamento esperado:*> Restito deve ter capturado a solicitação GET e deve ter capturado apenas uma solicitação GET.* Finalmente:*> Pare o servidor stub iniciado com o restito.* /public void testGETRequestFromClient () {StubServer server = null;tentar {// Isso iniciará o servidor stub em 'PORT' e responde com HTTP 202 'ACCEPTED_202'TestUtil.restartRestitoServerForGETRequests (servidor, PORT, ACCEPTED_202);RestClient.sendGETRequest (PORT);List  callList = TestUtil.waitAndGetCallList (servidor, 30);assertTrue ("A solicitação GET não foi recebida do RestClient. O teste falhou.",(callList! = null) && (callList.size () == 1));}catch (Exceção e) {e.printStackTrace ();fail ("Teste falhou devido a exceção: + e);}finalmente {if (servidor! = nulo) {server.stop ();}}}

========== Fim do CÓDIGO JAVA ===========

Etapa 4) Como validar a solicitação GET com cabeçalhos e a solicitação POST com o corpo usando a estrutura Restito.

========== JAVA CODE Starts ===========

/ *** Teste Junit para validar a solicitação GET com cabeçalhos do RestClient* Degraus:* 1) Crie um servidor stub usando a estrutura Restito e configure-o para escutar em determinada porta* 2) Invoque o método sendGETRequestWithCustomHeaders (…) de RestClient* 3) Restito captura as solicitações GET correspondentes enviadas, se houver.* 4) Valide se Restito capturou alguma solicitação GET em um determinado endpoint* Comportamento esperado:*> Restito deve ter capturado a solicitação GET e deve ter capturado apenas uma solicitação GET.*> Obtenha os cabeçalhos da solicitação GET capturada* e certifique-se de que os cabeçalhos correspondem aos configurados.* Finalmente:*> Pare o servidor stub iniciado com o restito.* /public void testGETRequestWithHeadersFromClient () {StubServer server = null;tentar {// Isso iniciará o servidor stub em 'PORT' e responde com HTTP 202 'ACCEPTED_202'TestUtil.restartRestitoServerForGETRequests (servidor, PORT2, ACCEPTED_202);RestClient.sendGETRequestWithCustomHeaders (PORT2);List  callList = TestUtil.waitAndGetCallList (servidor, 30);assertTrue ("A solicitação GET não foi recebida do RestClient. O teste falhou.",(callList! = null) && (callList.size () == 1));// Valide os cabeçalhos da solicitação GET do cliente RESTMap > headersFromRequest = callList.get (0) .getHeaders ();assertTrue ("A solicitação GET contém o cabeçalho Aceitar e seu valor",headersFromRequest.get ("Aceitar"). contains ("text / html"));assertTrue ("solicitação GET contém autorização de cabeçalho e seu valor",headersFromRequest.get ("Autorização"). contains ("Bearer 1234567890qwertyuiop"));assertTrue ("A solicitação GET contém o cabeçalho Cache-Control e seu valor",headersFromRequest.get ("Cache-Control"). contains ("no-cache"));assertTrue ("A solicitação GET contém o cabeçalho de Conexão e seu valor",headersFromRequest.get ("Connection"). contains ("keep-alive"));assertTrue ("A solicitação GET contém o tipo de conteúdo do cabeçalho e seu valor",headersFromRequest.get ("Content-Type"). contains ("application / json"));}catch (Exceção e) {e.printStackTrace ();fail ("Teste falhou devido a exceção: + e);}finalmente {if (servidor! = nulo) {server.stop ();}}}
/ *** Teste Junit para validar a solicitação POST com corpo e cabeçalhos do RestClient* Degraus:* 1) Crie um servidor stub usando a estrutura Restito e configure-o para escutar em determinada porta* 2) Invoque o método sendPOSTRequestWithJSONBody (…) do RestClient* 3) Restito captura as solicitações POST correspondentes enviadas, se houver.* 4) Valide se Restito capturou qualquer solicitação POST em determinado endpoint* Comportamento esperado:*> Restito deve ter capturado a solicitação POST e deve ter capturado apenas uma solicitação POST.*> Obtenha o corpo da solicitação POST capturada e valide os valores JSON* Finalmente:*> Pare o servidor stub iniciado com o restito.* /public void testPOSTRequestWithJSONBody () {StubServer server = null;tentar {// Isso iniciará o servidor stub em 'PORT' e responde com HTTP 202 'ACCEPTED_202'TestUtil.restartRestitoServerForPOSTRequests (servidor, PORT3, ACCEPTED_202);RestClient.sendPOSTRequestWithJSONBody (PORT3);List  callList = TestUtil.waitAndGetCallList (servidor, 30);assertTrue ("A solicitação POST não foi recebida do RestClient. O teste falhou.",(callList! = null) && (callList.size () == 1));// Valide os cabeçalhos da solicitação GET do cliente RESTString requestBody = callList.get (0) .getPostBody ();JSONObject postRequestJSON = novo JSONObject (requestBody);assertTrue ("O timeUpdated em json está incorreto",postRequestJSON.get ("timeUpdated"). toString (). equalsIgnoreCase ("1535703838478"));assertTrue ("O access_token em json está incorreto",postRequestJSON.get ("access_token"). toString ().equalsIgnoreCase ("abf8714d-73a3-42ab-9df8-d13fcb92a1d8"));assertTrue ("O refresh_token em json está incorreto",postRequestJSON.get ("refresh_token"). toString ().equalsIgnoreCase ("d5a5ab08-c200-421d-ad46-2e89c2f566f5"));assertTrue ("O token_type em json está incorreto",postRequestJSON.get ("token_type"). toString (). equalsIgnoreCase ("portador"));assertTrue ("O expires_in em json está incorreto",postRequestJSON.get ("expires_in"). toString (). equalsIgnoreCase ("1024"));assertTrue ("O escopo em json está incorreto",postRequestJSON.get ("escopo"). toString (). equalsIgnoreCase (""));}catch (Exceção e) {e.printStackTrace ();fail ("Teste falhou devido a exceção: + e);}finalmente {if (servidor! = nulo) {server.stop ();}}}}

========== Fim do CÓDIGO JAVA ===========

Vantagens de usar Restito Framework para teste de cliente REST

Aqui, estão os prós / benefícios do Restito Framework para teste de cliente ReST

  • Não precisamos que o servidor REST real seja desenvolvido para testar o Cliente REST.
  • Restito fornece utilitários e métodos fortes e variados para simular diferentes comportamentos de um servidor. Por exemplo: Para testar como o cliente REST se comporta quando o servidor responde com o erro HTTP 404 ou HTTP 503.
  • Os servidores Restito podem ser configurados em alguns milissegundos e podem ser encerrados após a conclusão dos testes.
  • Restito oferece suporte a todos os tipos de conteúdo de método HTTP, como compactado, não compactado, unificado, aplicativo / texto, aplicativo / JSON, etc.

Desvantagens de usar Restito Framework para teste de cliente REST

Aqui, estão os contras / desvantagem do Restito Framework para teste de cliente ReST

  • A origem do cliente REST deve ser ajustada para considerar 'localhost' como uma máquina servidor.
  • A abertura do servidor em qualquer porta pode entrar em conflito se usarmos alguma porta comumente usada como '8080' ou '9443' etc.
  • É aconselhável usar portas como 9092 ou 9099, que não são comumente usadas por outras ferramentas.

Resumo:

  • REST significa "REpresentational State Transfer", que é uma nova forma padrão de comunicação entre dois sistemas em um determinado ponto do tempo.
  • Cliente REST é um método ou ferramenta para chamar uma API de serviço REST que é exposta à comunicação por qualquer sistema ou provedor de serviços.
  • No método RestServer ou em uma API que é exposta para comunicação por qualquer sistema ou provedor de serviços.
  • Restito é um aplicativo leve para ajudá-lo a executar qualquer tipo de solicitação HTTP
  • Crie um cliente HTTP e um método para enviar uma solicitação HTTP GET para qualquer ponto de extremidade do servidor
  • Inicie um servidor Restito para ouvir e capturar as solicitações enviadas para o endpoint 'getevents'.
  • Inicie um servidor Restito para ouvir e capturar as solicitações enviadas para o endpoint 'getevents' em localhost
  • Aqui, implementamos exemplos para teste de automação apenas do cliente REST.
  • Não precisamos que o servidor REST real seja desenvolvido para testar o Cliente REST.
  • A origem do cliente REST deve ser ajustada para considerar 'localhost' como uma máquina servidor.

Este artigo é uma contribuição de Chandrasekhar Muttineni