O uso de inteligência artificial (IA) tem impactado como os testes automatizados de API Rest são concebidos e executados. Certamente, ao aplicar técnicas de Machine Learning (ML) e processamento de linguagem natural, a IA pode analisar vastos conjuntos de dados e especificações de API para gerar automaticamente casos de testes abrangentes e relevantes. Sendo assim, isso agiliza o processo de teste e aumenta sua eficácia, identificando áreas ainda não exploradas no quesito qualidade.
Dessa forma, você irá aprender como usar o assistente de código contextualizado da StackSpot AI para criar testes automatizados de API Rest, para facilitar na criação e codificação de projetos de automação.
Conhecendo a StackSpot AI
Em primeiro lugar, é importante salientar que a StackSpot é um plataforma de desenvolvimento que empodera equipes de engenharia a modernizar sistemas legados e entregar valor mais rápido, centralizando e reutilizando padrões de tecnologia, gerando códigos altamente contextualizados por meio de IA e otimizando a jornada na nuvem. Por outro lado, ela é dividida em três ofertas: StackSpot EDP, StackSpot Cloud Services e StackSpot AI, esta última foco deste artigo.
A StackSpot AI é capaz de usar seu contexto, bases de conhecimento e decisões tecnológicas para gerar, sobretudo, sugestões mais assertivas e de alta qualidade. Além disso, o assistente de AI oferece a possibilidade de criar comandos rápidos para automatizar tarefas repetitivas. Portanto, diga adeus a sugestões genéricas e adote uma geração de código hiper-contextualizada!
E o melhor: a StackSpot AI possui um plano freemium. Basta usar a versão Web ou baixar as extensões para IDE (IntelliJ ou Visual Code) e começar!
Testes automatizados de API Rest: primeiros passos com a StackSpot AI
Em primeiro lugar, vamos criar um projeto de automação de testes de API Rest, usando em conjunto Java + Restassued + Cucumber + Maven.
Posteriormente, usaremos uma conta pessoal (GitHub) para acessar o portal StackSpot AI, baixar o Plugin da assistente de assistente de código contextualizado AI e adicionar a ferramenta de desenvolvimento (IntelliJ).
O assistente de código contextualizado AI, ajudará na geração de código inicial do projeto conforme perguntas e contexto dado, sugerindo códigos gerados para adicionarmos ao projeto.
Por fim, vamos adicionar novos cenários de testes e refatorar o código, deixando nosso projeto mais completo e reutilizável para a comunidade de software.
Então vamos lá:
Para começar, basta autenticar na página de Login da StackSpot AI, É necessário já ter uma conta criada no GitHub para este passo.
Sendo assim, você vai ver essa tela inicial dentro do ambiente da StackSpot AI:
Definindo a instalação
Dessa forma, para a instalação, basta seguir as orientações recomendadas para a construção da automação de testes:
IDE
Plugin IDE
Linguagem
Dependência
Bibliotecas Maven
- Restassured (versão 4.3.3)
- Cucumber-Java (versão 6.10.4)
- Cucumber-JUnit (versão 6.10.4)
- JUnit (versão 4.13.2)
- JavaFaker (versão 1.02)
Consuma inovação, comece a transformação
Assine nosso boletim informativo para se manter atualizado sobre as práticas recomendadas mais recentes para aproveitar a tecnologia para gerar impacto nos negócios
Criando o projeto para automação de testes de API Rest
Em resumo, para criação e execução do projeto para automação de testes de API Rest, basta seguir as orientações.
1 – Criando um novo projeto para testes automatizados de API Rest
Com as instalações já feitas (passo anterior), basta:
- Acessar IDE IntelliJ.
- Acionar o menu File a opção “New -> Project”.
- Clique em New Project a opção “Java“.
- Preencher o campo Name com o nome do projeto.
- Clique em Build System a opção “Maven”.
Pronto, o projeto para automação de testes de API Rest será criado.
2 – Fazendo a autenticação na StackSpot AI
Com a IDE IntelliJ já aberta e projeto já criado (passo anterior), basta:
- Acessar o Plugin StackSpot AI.
- Preencher o campo email da sua conta GitHub.
- Clicar no botão “Continue with GitHub“.
- Clicar no botão “Sim” na tela que será aberta. Após receber confirmação, voltar para IntelliJ.
Pronto, depois da autenticação vai ser possível usar a StackSpot AI.
3 – Fazendo a geração de código
Com o projeto já criado na IDE IntelliJ e com login já feito na StackSpot AI (passo anterior), basta:
- Acessar o Plugin StackSpot AI.
- Fazer perguntas para a AI: Gerar exemplo para teste POST de API Rest, usando Java 11, Maven, Rest Assured e Cucumber – saiba neste artigo como criar um bom prompt na StackSpot AI.
- Copiar código criado e criar pastas/arquivos sugeridos para o projeto.
Depois disso, o código é gerado e podemos adicionar ao projeto criado para uso.
Adicionando o código gerado pela StackSpot AI ao projeto
Vamos adicionar o código gerado ao projeto para testes automatizados de API Rest, seguindo os passos abaixo:
1. Configurar do projeto com Maven
No arquivo pom.xml do seu projeto, adicione as seguintes dependências para Cucumber, JUnit e RestAssured.
pom.xml
<dependencies>
<!-- RestAssured -->
<dependency>
<groupId>io.rest-assured</groupId>
<artifactId>rest-assured</artifactId>
<version>4.3.3</version>
<scope>test</scope>
</dependency>
<!-- Cucumber -->
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-java</artifactId>
<version>6.10.4</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-junit</artifactId>
<version>6.10.4</version>
<scope>test</scope>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
</dependencies>
2.Criar o cenário de teste com Cucumber
Crie um arquivo de feature para o Cucumber.
src/test/resources/features/postFeature.feature
Feature: Test POST API endpoint
Scenario: Post new data to the API
Given I set POST API endpoint
When I send POST HTTP request
Then I receive valid HTTP response code 201
3. Implementar o teste com RestAssured
Posteriormente, implemente os passos de teste usando RestAssured. Crie uma classe de teste correspondente ao seu cenário Cucumber.
src/test/java/stepDefinitions/PostApiSteps.java
package com.example.steps;
import io.cucumber.java.en.Given;
import io.cucumber.java.en.When;
import io.cucumber.java.en.Then;
import io.restassured.RestAssured;
import io.restassured.response.Response;
import static org.junit.Assert.*;
public class PostApiSteps {
private Response response;
@Given("I set POST API endpoint")
public void i_set_post_api_endpoint() {
RestAssured.baseURI = "http://yourapi.com/api";
}
@When("I send POST HTTP request")
public void i_send_post_http_request() {
response = RestAssured.given().contentType("application/json")
.body("{\"key\": \"value\"}")
.when().post("/endpoint");
}
@Then("I receive valid HTTP response code 201")
public void i_receive_valid_http_response_code_201() {
assertEquals(201, response.getStatusCode());
}
}
4. Configurar o Runner com Cucumber
Crie uma classe para executar os testes do Cucumber.
src/test/java/cucumberOptions/TestRunner.java
package com.example;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
import org.junit.runner.RunWith;
@RunWith(Cucumber.class)
@CucumberOptions(
features = "src/test/resources/features",
glue = "com.example.steps",
plugin = {"pretty", "html:target/cucumber-reports.html"},
monochrome = true
)
public class TestRunner {
Executando os testes automatizados de API Rest
Para executar os testes automatizados de API Rest, você pode usar o comando Maven.
mvn test
Neste momento, você tem um exemplo de código e estrutura do projeto de automação de testes integrado de API Rest, fazendo requisição POST, recebendo resposta e validando o status code. Depois disso, ajuste o que foi gerado, conforme a sua necessidade.
Em seguida, é necessário melhorar o código e organizar o projeto, adicionando a requisição GET, recebendo respostas e validando dados.
Para isso, utilize as APIs da ServeRest, para:
- Cadastrar novo usuário (POST Usuário)
- Consultar usuário cadastrado (GET Usuário)
- Consultar usuário não cadastrado (GET Usuário)
A seguir, será demonstrado os ajustes, conforme cenários a serem validados.
Refatorando o projeto para ficar mais simples e organizado a implementação
Para fazer a refatoração, faça as modificações abaixo:
1 – Ajustando o projeto com Maven
Ajuste o arquivo pom.xml para conter as implementações.
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>StackSpot-api-integration-tests</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- RestAssured -->
<dependency>
<groupId>io.rest-assured</groupId>
<artifactId>rest-assured</artifactId>
<version>4.3.3</version>
<scope>test</scope>
</dependency>
<!-- Cucumber -->
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-java</artifactId>
<version>6.10.4</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-junit</artifactId>
<version>6.10.4</version>
<scope>test</scope>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!-- Java Faker -->
<dependency>
<groupId>com.GitHub.javafaker</groupId>
<artifactId>javafaker</artifactId>
<version>1.0.2</version>
</dependency>
</dependencies>
</project>
2 – Ajustando o cenário de teste com Cucumber
Ajuste o arquivo resources/features/usuario.feature para conter as implementações.
src/test/resources/features/usuario.feature
Feature: Usuário API
@todos @usuario-cadastrar
Scenario: Deve cadastrar novo usuário
Given Eu tenho os dados para cadastrar um novo usuario
When Eu faço um pedido POST para a URL "https://serverest.dev/usuarios"
Then O status do código de resposta deve ser 201
@todos @usuario-nao-cadastrado
Scenario: Deve consultar usuário cadastrado
Given Eu não tenho um usuario cadastrado mas desejo cadastrar
When Eu faço um pedido GET para a URL "https://serverest.dev/usuarios"
Then O status do código de resposta deve ser de 200
@todos @usuario-nao-existente
Scenario: Deve consultar usuário não cadastrado
Given Eu não tenho um usuario cadastrado "XPTO"
When Eu faço um pedido GET para a URL "https://serverest.dev/usuarios"
Then O status do código de resposta deverá ser de 400
3 – Ajustando os Steps de teste com RestAssured
Ajuste o arquivo stepDefinitions/UsuarioSteps.java para conter implementação dos testes da feature, de cadastrar novo usuário, consultar usuário cadastrado e consultar usuário não cadastrado.
src/test/java/stepDefinitions/UsuarioSteps.java
package stepDefinitions;
import io.cucumber.java.en.Given;
import io.cucumber.java.en.Then;
import io.cucumber.java.en.When;
import io.restassured.response.Response;
import services.UsuarioService;
public class UsuarioSteps {
private Response response;
private String body;
private String idUsuario;
private final UsuarioService usuarioService = new UsuarioService();
@Given("Eu tenho os dados para cadastrar um novo usuario")
public void eu_tenho_os_dados_para_cadastrar_um_novo_usuario() {
body = usuarioService.gerarDadosUsuario();
}
@When("Eu faço um pedido POST para a URL {string}")
public void eu_faco_um_pedido_post_para_a_url(String url) {
response = usuarioService.criarNovoUsuario(url, body);
}
@Then("O status do código de resposta deve ser {int}")
public void o_status_do_codigo_de_resposta_deve_ser(int statusCode) {
idUsuario = usuarioService.validarDadosUsuarioCadastrado(response,statusCode);
}
@Given("Eu não tenho um usuario cadastrado mas desejo cadastrar")
public void eu_nao_tenho_um_usuario_cadastrado_mas_desejo_cadastrar() {
idUsuario = usuarioService.verificarUsuarioExistente(null);
}
@When("Eu faço um pedido GET para a URL {string}")
public void eu_faco_um_pedido_get_para_a_url(String url) {
response = usuarioService.consultarUsuario(url, idUsuario);
}
@Then("O status do código de resposta deve ser de {int}")
public void o_status_do_codigo_de_resposta_deve_ser_de(int statusCode) {
usuarioService.validarDadosUsuarioConsultado(response,idUsuario,statusCode);
}
@Given("Eu não tenho um usuario cadastrado {string}")
public void eu_nao_tenho_um_usuario_cadastrado(String novoIdUsuario) {
idUsuario = novoIdUsuario;
}
@When("Eu faço uma tentativa de pedido GET para a URL {string}")
public void eu_faco_uma_tentativa_de_pedido_get_para_a_url(String url) {
response = usuarioService.consultarUsuario(url, idUsuario);
}
@Then("O status do código de resposta deverá ser de {int}")
public void o_status_do_codigo_de_resposta_devera_ser_de(int statusCode) {
usuarioService.validarDadosUsuarioNaoCadastrado(response,statusCode);
}
}
4 – Criando a estrutura DTO para manipular os dados da requisição
Crie o arquivo dto/UsuarioDto para criar get/set e acesso aos atributos do objeto/classe.
src/test/java/dto/UsuarioDto.java
package dto;
public class UsuarioDto {
private String nome;
private String email;
private String senha;
private String administrador;
// Getter e Setter para nome
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
// Getter e Setter para email
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
// Getter e Setter para senha
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
this.senha = senha;
}
// Getter e Setter para administrador
public String getAdministrador() {
return administrador;
}
public void setAdministrador(String administrador) {
this.administrador = administrador;
}
}
5 – Criando a estrutura Service para montar a requisição
Crie o arquivo service/UsuarioService.java para montar as requisições a serem feitas.
src/test/java/service/UsuarioService.java
package services;
import com.github.javafaker.Faker;
import dto.UsuarioDto;
import io.restassured.path.json.JsonPath;
import io.restassured.response.Response;
import static io.restassured.RestAssured.given;
import static org.junit.Assert.assertEquals;
public class UsuarioService {
private Response response;
private String requestBody;
private String idUsuario;
private UsuarioDto usuarioDto;
private Faker faker;
private String novoIdUsuario;
public String gerarDadosUsuario(){
faker = new Faker();
usuarioDto = new UsuarioDto();
usuarioDto.setNome(faker.name().name());
usuarioDto.setEmail(faker.internet().emailAddress());
usuarioDto.setSenha("123456");
usuarioDto.setAdministrador("true");
requestBody = "{\n" +
" \"nome\": \""+usuarioDto.getNome()+"\",\n" +
" \"email\": \""+usuarioDto.getEmail()+"\",\n" +
" \"password\": \""+ usuarioDto.getSenha()+"\",\n" +
" \"administrador\": \""+ usuarioDto.getAdministrador()+"\"\n" +
"}";
return requestBody;
}
public Response criarNovoUsuario(String url, String requestBody){
response = given()
.header("Content-type", "application/json")
.and()
.log().all()
.body(requestBody)
.when()
.post(url)
.then()
.log().all()
.extract().response();
return response;
}
public String validarDadosUsuarioCadastrado(Response response, int statusCode){
JsonPath jsonPathEvaluator = response.jsonPath();
assertEquals(statusCode, response.getStatusCode());
assertEquals("Cadastro realizado com sucesso",jsonPathEvaluator.get("message"));
idUsuario = jsonPathEvaluator.get("_id");
return idUsuario;
}
public String verificarUsuarioExistente(String idUsuario){
String novoBody;
Response novoResponse;
if (idUsuario == null){
novoBody = gerarDadosUsuario();
novoResponse = criarNovoUsuario("https://serverest.dev/usuarios",novoBody);
novoIdUsuario = validarDadosUsuarioCadastrado( novoResponse, 201);
}
else{
novoIdUsuario = idUsuario;
}
return novoIdUsuario;
}
public Response consultarUsuario(String url, String novoIdUsuario){
response = given()
.header("Content-type", "application/json")
.and()
.log().all()
.when()
.get(url + "/" + novoIdUsuario)
.then()
.log().all()
.extract().response();
return response;
}
public void validarDadosUsuarioConsultado(Response response, String novoId, int statusCode){
JsonPath jsonPathEvaluator = response.jsonPath();
if (novoIdUsuario.equals(novoId)) {
assertEquals(statusCode, response.getStatusCode());
assertEquals(novoIdUsuario, jsonPathEvaluator.get("_id"));
}
else {
assertEquals(usuarioDto.getNome(), jsonPathEvaluator.get("nome"));
assertEquals(usuarioDto.getEmail(), jsonPathEvaluator.get("email"));
assertEquals(usuarioDto.getSenha(), jsonPathEvaluator.get("password"));
assertEquals(usuarioDto.getAdministrador(), jsonPathEvaluator.get("administrador"));
assertEquals(statusCode, response.getStatusCode());
assertEquals(idUsuario, jsonPathEvaluator.get("_id"));
}
}
public void validarDadosUsuarioNaoCadastrado(Response response, int statusCode){
JsonPath jsonPathEvaluator = response.jsonPath();
assertEquals("Usuário não encontrado", jsonPathEvaluator.get("message"));
assertEquals(statusCode, response.getStatusCode());
}
}
Executando os testes após refatoração
Para executar os testes, você pode usar o comando Maven.
mvn test
Dessa forma, o projeto ajustado foi executado com sucesso. Com a ajuda da StackSpot AI foi possível melhorar a escrita dos cenários, promover reuso de código e simplificar a execução dos testes automatizados de API Rest.
Conclusão
Em conclusão, neste artigo, você conferiu as vantagens de adotar uma ferramenta contextualizada de inteligência artificial como a StackSpot AI em processos de testes automatizados de API Rest. Sem dúvidas, todo o ciclo de desenvolvimento de software tem ganhado velocidade e eficiência ao adotar a ferramenta de AI certa, nesse cenário, os processos de Qualidade de Software também tem se beneficiado muito dos novos recursos.
Dessa forma, ao utilizar a StackSpot AI, foi possível adotar sugestões assertivas, pois se baseiam em seus próprios padrões e fontes de conhecimento. Contudo, isso traz eficiência, confiabilidade e inovação sem precedentes aos seus testes automatizados de API Rest e outros processos de QA.
Ficou com alguma dúvida ou tem sugestões? Então deixe um comentário.
Referências
- Documentação da API ServeRest
- Documentação da StackSpot AI
- Documentação da StackSpot EDP
- Login gratuito na StackSpot AI
- Repositório GitHub deste tutorial
- Site da StackSpot
