Tecnologia

Automação de API REST utilizando Java e RestAssured

Por: , janeiro 25, 2018

Cada vez mais estamos utilizando API’s REST para fazer o meio de campo entre nossas aplicações e o servidor, então porquê não automatizar essas tarefas de teste?
Manualmente é possivel realizar testes em APIs REST utilizando o POSTMAN.
Há também uma extensão do google chrome que possibilita os testes, mas nem todas as funcionalidades da aplicação estão disponiveis na extensão. (E ela está sendo descontinuada, por isso sugiro que utilize a aplicação).
Ah, o POSTMAN também possibilita que os testes de API sejam automatizados, mas a liberdade de criar e gerenciar seus casos de testes é bem mais restrito. Tendo isso em mente, vou mostrar como fazer isso utilizando Java + Junit + RestAssured
No final do post vou colocar alguns links sobre o POSTMAN e um “tutorial” legal deles falando (e mostrando na prática) sobre automação utilizando a ferramenta (Em inglês).
Dito isso, vamos ao que interessa:
A primeira coisa que vamos precisar é configurar o ambiente para desenvolver os testes
Essas são as ferramentas que vamos utilizar:

Após ter baixado o eclipse e “instalado” o JDK e o Maven, vamos abrir nossa IDE e:
Criar um novo projeto Maven
File > New > Project > Maven > Maven Project
01

  • Precisamos agora adicionar as dependencias abaixo no nosso arquivo POM.xml

Nota: A última versão de cada dependência pode ser encontrada AQUI
01.1
02

  • Agora dentro do package br.com.automation.APIRest vamos criar uma classe java TestAPI e já realizar alguns imports que iremos utilizar no decorrer do desenvolvimento

Imports:
import static io.restassured.RestAssured.*;
import io.restassured.http.ContentType;
import static org.hamcrest.Matchers.*;
import org.junit.Test;

03
Para o nosso teste vamos utilizar uma API que o postman disponibiliza aqui.
Automatizaremos uma API de GET, mas nesse mesmo link tem várias outras APIs que podemos utilizar para brincar com os demais métodos HTTP. (GET, POST, PUT, DELETE, etc)
URI: https://postman-echo.com/get?foo1=bar1&foo2=bar2
Algumas premissas são importantes e devemos nos atentar a elas antes de iniciarmos nosso teste:
1- Nosso request será feito através do método GET (Vamos recuperar os recursos existentes no servidor)
2- Essa URI possui parametros que são setados logo após o “?”, esses parametros são foo1=bar1&foo2=bar2, onde “foo1” é nosso primeiro parametro com valor “bar1” e “foo2” é nosso segundo parametro com valor “bar2”
3- Essa URI utiliza protoloco https (Hyper Text Transfer Protocol Secure)
Bem, a primeira coisa que devemos fazer antes de colocar a mão no código é saber qual será o retorno dessa API (response, status http), para isso podemos utilizar o POSTMAN (ou até mesmo acessar a URI através do navegador web padrão), exemplo abaixo:
04
Nessa requisição temos informações importantes que precisaremos utilizar, por exemplo o response e o status code
Status code = 200
Response
"args": {
"foo1": "bar1",
"foo2": "bar2"
},
"headers": {
"host": "postman-echo.com",
"accept": "*/*",
"accept-encoding": "gzip, deflate",
"cache-control": "no-cache",
"cookie": "sails.sid=s%3AcTbadPltX_A_nHkwTUZ3wENmVScId_mc.R6TqTL5G2sdh5gUAIq%2FeQjXoflW55PF3RjbRHBwtIUA",
"postman-token": "61898fbb-ae42-477f-a582-a955048ecaca",
"user-agent": "PostmanRuntime/3.0.11-hotfix.2",
"x-forwarded-port": "443",
"x-forwarded-proto": "https"
},
"url": "https://postman-echo.com/get?foo1=bar1&foo2=bar2"
}

Agora sim vamos por a mão na massa:
O nosso teste vai validar que:

  • O status http retornado foi 200
  • O response foi retornado no formato JSON
  • A chave “host” possui exatamente o valor “postman-echo.com”,
  • A chave “foo1” contém o valor “bar”



1º Passo: Criar o método de teste que vai receber nosso bloco de instruções
@Test
public void Teste() {

}
2º Passo: Definir nossa URI base para ser acessada
@Test
public void Teste() {

String uriBase = “https://postman-echo.com/get”;
}
3º Passo: Como comentado acima, a nossa URI utiliza o protoloco HTTPS, para conseguirmos acessar uma URI https através do método, precisamos dizer para o nosso teste ignorar o uso do https e acessar a URI
Nota: Todas as configurações que precisamos fazer antes de enviar o nosso request (GET) devem ser passadas no nosso método given().
@Test
public void Teste() {

String uriBase = “https://postman-echo.com/get”;
given()
.relaxedHTTPSValidation();
}
4º Passo: Outro ponto que também comentamos anteriormente é que essa URI possui parametros, se você prestar atenção, vai perceber que nossa String uriBase, não possui os parametros foo1=bar1&foo2=bar2, eles devem ser definidos também no nosso given()
@Test
public void Teste() {

String uriBase = “https://postman-echo.com/get”;
given()
.relaxedHTTPSValidation()
.param(“foo1”, “bar1”)
.param(“foo2”, “bar2”);
}
5º Passo: Aqui já cuidamos de todos os pré requisitos para que o nosso request seja enviado, vamos então propriamente enviar a nossa requisição para o endereço definido:
Nota: O método when() é onde definimos a nossa ação, GET no caso – (Quando eu realizar um GET na uriBase) […]
given()
.relaxedHTTPSValidation()
.param("foo1", "bar1")
.param("foo2", "bar2")
.when()
.get(uriBase)

Passo 6: No passo 5 enviamos o request para nossa URI e nesse momento temos o retorno dela, então (then()) queremos validar algumas informações que voltaram nesse response, aqui entra a parte de validações que citei lá em cima:
@Test
public void Teste() {

String uriBase = “https://postman-echo.com/get”;
given()
.relaxedHTTPSValidation()
.param(“foo1”, “bar1”)
.param(“foo2”, “bar2”)
.when()
.get(uriBase)
.then()
.statusCode(200) // O status http retornado foi 200
.contentType(ContentType.JSON) // O response foi retornado no formato JSON
.body(“headers.host”, is(“postman-echo.com”)) // A chave “host” possui exatamente o valor “postman-echo.com”
.body(“args.foo1”, containsString(“bar”)); //A chave “foo1” contém o valor “bar”
}
Se pararmos para analisar as duas ultimas validações .body(“headers.host”, is(“postman-echo.com”)) e .body(“args.foo1”, containsString(“bar”)); vamos perceber que na primeira utilizamos a verificação is(“postman-echo.com”) que garante que o valor da chave “headers.host” é exatamente “postman-echo.com”.
A segunda validação garante que a chave “args.foo1” possui a String “bar”, o retorno exato da chave “args.foo1” foi “bar1”, porém o metodo containsString() valida que o valor “bar1” possui a String “bar”, sendo isso verdadeiro o teste passa.
Vamos então rodar nosso Teste e verificar o resultado:
Botão Direito no método Teste() >> Run As >> Junit Test
05
Podemos ver que nosso teste ficou verde indicando que passou 🙂
Agora para validarmos se ele realmente vai falhar se passarmos algo errado, vou alterar o trecho
.body(“args.foo1”, containsString(“bar”)); para .body(“args.foo1”, containsString(“bar123”));
E nosso teste vai ter que falhar, pois o valor da chave args.foo1 é bar1 é “bar1” e “bar1” não contém “bar123”
06
Falhou!
E o motivo foi este:
java.lang.AssertionError: 1 expectation failed.
JSON path args.foo1 doesn't match.
Expected: a string containing "bar123"
Actual: bar1

Passamos a String “bar123” mas a String contida na chave args.foo1 é “bar1”, logo nosso teste não passou. 🙂
Bem pessoal, é isso, esse é um teste simples dentro da infinidade de coisas que dá para fazer utilizando RestAssured.
A parte que mais gosto da ferramenta é a possíbilidade de escrever os testes de API no formato BDD, deixa o código bem legivel e de fácil entendimento, permitindo que qualquer pessoa com conhecimento básico de Java crie testes rapidamente.
Links e Referências:
Download Postman https://www.getpostman.com/
Blog Postman http://blog.getpostman.com
Writing tests in Postman http://blog.getpostman.com/2017/10/25/writing-tests-in-postman/
Rest Status Code http://www.restapitutorial.com/httpstatuscodes.html
Hamcrest Validations https://code.google.com/archive/p/hamcrest/wikis/Tutorial.wiki
RestAssured Usage Guide https://github.com/rest-assured/rest-assured/wiki/Usage

  • Receba nosso conteúdo em primeira mão.