Qualidade e eficiência: como fazer testes automatizados de API Rest com uma ferramenta de IA

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

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

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

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 {

<?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>

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

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

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

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

    }
}