Introdução aos Testes de API com Rest Assured para Iniciantes

No mundo do desenvolvimento de software, APIs (Interfaces de Programação de Aplicações) se tornaram a espinha dorsal das aplicações modernas. À medida que essas APIs crescem em complexidade e importância, a necessidade de metodologias de testes robustas e eficientes nunca foi tão crítica. Apresentamos o Rest Assured, uma biblioteca baseada em Java que revolucionou a forma como abordamos os testes de API.

O Rest Assured ganhou imensa popularidade entre desenvolvedores e profissionais de QA devido à sua simplicidade e poder na automação de testes de API REST. Sua sintaxe expressiva e a integração perfeita com Java o tornam uma escolha ideal para equipes que buscam implementar estratégias abrangentes de testes de API.

Neste guia completo, vamos nos aprofundar nos testes de API com o Rest Assured, abordando desde a configuração básica até técnicas avançadas, e até mesmo explorar como ele se compara a outras ferramentas no cenário de testes de API.

O que é Rest Assured em Testes de API?

Rest Assured é uma biblioteca baseada em Java projetada especificamente para testar APIs RESTful. Ela fornece uma linguagem específica do domínio (DSL) para realizar requisições HTTP e validar respostas. As principais características incluem:

• API fluente para a fácil escrita de testes
• Suporte para parsing de XML e JSON
• Integração com ferramentas do ecossistema Java (TestNG, JUnit, etc.)
• Capacidades de validação extensivas

O que é REST API em Testes?

REST (Transferência de Estado Representacional) API é um estilo arquitetural para projetar aplicações em rede. No contexto dos testes, os testes de API REST envolvem:

1. Verificar o correto manuseio de métodos HTTP (GET, POST, PUT, DELETE, etc.)
2. Validar códigos de status da resposta
3. Verificar a estrutura e o conteúdo do payload da resposta
4. Testar o comportamento da API em diferentes cenários (entradas válidas/ inválidas, autenticação, etc.)
5. Verificar mudanças de estado após operações da API

Qual é a Diferença Entre Postman e Rest Assured?

Embora ambas as ferramentas sejam usadas para testes de API, elas servem a propósitos diferentes:

O Rest Assured é tipicamente preferido quando você precisa integrar testes de API em seu framework de automação de testes baseado em Java ou quando requer cenários de teste mais complexos.

Qual é a Diferença Entre TestNG e Rest Assured?

TestNG e Rest Assured servem a propósitos diferentes, mas muitas vezes são usados juntos:

Você pode usar o TestNG para estruturar e executar seus testes do Rest Assured, combinando os pontos fortes de ambas as ferramentas. Por exemplo:

import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class CombinedTest {

    @BeforeClass
    public void setup() {
        baseURI = "https://api.example.com";
        basePath = "/v1";
    }

    @Test(groups = "smoke")
    public void testGetUser() {
        given()
            .pathParam("id", 1)
        .when()
            .get("/users/{id}")
        .then()
            .statusCode(200)
            .body("name", notNullValue());
    }

    @Test(groups = "regression")
    public void testCreateUser() {
        String newUser = "{\"name\":\"John Doe\",\"email\":\"john@example.com\"}";
        
        given()
            .contentType("application/json")
            .body(newUser)
        .when()
            .post("/users")
        .then()
            .statusCode(201)
            .body("id", notNullValue());
    }
}

Este exemplo usa anotações do TestNG para organizar os testes e o Rest Assured para a lógica real dos testes de API.

Começando com Testes de API do Rest Assured

Antes de mergulharmos nas intricacies do Rest Assured, vamos configurar nosso ambiente de desenvolvimento para garantir que estamos prontos para começar a testar.

Configurando Seu Ambiente

Instale o Java: O Rest Assured requer Java 8 ou superior. Baixe e instale o JDK mais recente do site da Oracle ou use o OpenJDK.

Escolha um IDE: Embora você possa usar qualquer editor de texto, um Ambiente de Desenvolvimento Integrado (IDE) pode aumentar significativamente sua produtividade. As opções populares incluem:

• IntelliJ IDEA
• Eclipse
• Visual Studio Code com extensões Java

Configure um projeto Maven: O Maven ajudará a gerenciar nossas dependências. Crie um novo projeto Maven em seu IDE ou use a linha de comando:

mvn archetype:generate -DgroupId=com.example -DartifactId=rest-assured-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Adicione a dependência do Rest Assured: Abra seu arquivo pom.xml e adicione a seguinte dependência:

<dependências>
    <dependência>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>4.4.0</version>
        <scope>test</scope>
    </dependência>
    <dependência>
        <groupId>org.testng</groupId>
        <artifactId>testng</artifactId>
        <version>7.4.0</version>
        <scope>test</scope>
    </dependência>
    <dependência>
        <groupId>org.hamcrest</groupId>
        <artifactId>hamcrest</artifactId>
        <version>2.2</version>
        <scope>test</scope>
    </dependência>
</dependências>

Isso inclui Rest Assured, TestNG para organização de testes e Hamcrest para matchers adicionais.

Atualize o Maven: Execute mvn clean install para baixar as dependências.

Com estas etapas concluídas, você está pronto para começar a escrever testes do Rest Assured!

Conceitos Básicos de Testes de API do Rest Assured

O Rest Assured segue uma sintaxe Given-When-Then, inspirada no desenvolvimento orientado a comportamento (BDD). Esta estrutura torna os testes legíveis e intuitivos, mesmo para aqueles que não estão familiarizados com a base de código.

A Estrutura Given-When-Then

• Given: Configure as pré-condições do teste (por exemplo, parâmetros, cabeçalhos, autenticação)
• When: Realize a ação da API (GET, POST, PUT, DELETE, etc.)
• Then: Afirme a resposta (código de status, conteúdo do corpo, cabeçalhos)

Vamos detalhar um exemplo simples:

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
import org.testng.annotations.Test;

public class SimpleTest {
    @Test
    public void testGetRequest() {
        given()
            .baseUri("https://api.example.com")
        .when()
            .get("/users")
        .then()
            .statusCode(200)
            .body("data.size()", greaterThan(0))
            .body("data[0].id", notNullValue())
            .body("data[0].email", containsString("@"));
    }
}

Este teste faz o seguinte:

1. Define a URI base para a API
2. Envia uma requisição GET para o endpoint "/users"
3. Afirma que:

• O código de status é 200
• A resposta contém um array de dados não vazio
• O primeiro usuário no array tem um ID não nulo
• O e-mail do primeiro usuário contém um símbolo "@"

Compreendendo a Sintaxe do Rest Assured

O Rest Assured usa uma interface fluente, permitindo que você encadeie chamadas de método. Aqui está uma análise de alguns métodos comuns:

• given(): Inicia a especificação do teste
• baseUri(), basePath(): Define a URL base e o caminho para a requisição
• param(), queryParam(): Adiciona parâmetros de consulta
• header(), headers(): Define cabeçalhos da requisição
• body(): Define o corpo da requisição
• when(): Marca o início da seção de requisição
• get(), post(), put(), delete(): Métodos HTTP
• then(): Inicia a seção de validação
• statusCode(): Afirma o código de status da resposta
• body(): Valida o corpo da resposta

Técnicas Avançadas de Testes de API do Rest Assured

À medida que você se sentir mais confortável com o Rest Assured, você vai querer explorar seus recursos mais avançados para criar suítes de testes robustas e abrangentes.

Gerenciando Autenticação em Testes de API do Rest Assured

Muitas APIs requerem autenticação. O Rest Assured suporta vários métodos de autenticação:

Autenticação Básica

given()
    .auth().basic("username", "password")
.when()
    .get("/secure-endpoint")
.then()
    .statusCode(200);

OAuth 2.0

given()
    .auth().oauth2("your_access_token")
.when()
    .get("/oauth2-protected-endpoint")
.then()
    .statusCode(200);

Autenticação Personalizada

Para APIs com esquemas de autenticação personalizados, você pode adicionar cabeçalhos manualmente:

given()
    .header("X-API-Key", "your-api-key")
.when()
    .get("/custom-auth-endpoint")
.then()
    .statusCode(200);

Parametrizando Testes em Testes de API do Rest Assured

Testes parametrizados permitem que você execute o mesmo teste com diferentes entradas, aumentando sua cobertura de testes:

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class ParameterizedTest {

    @DataProvider(name = "userIds")
    public Object[][] createUserIds() {
        return new Object[][] {{1}, {2}, {3}, {4}, {5}};
    }

    @Test(dataProvider = "userIds")
    public void testMultipleUsers(int userId) {
        given()
            .pathParam("id", userId)
        .when()
            .get("https://api.example.com/users/{id}")
        .then()
            .statusCode(200)
            .body("id", equalTo(userId))
            .body("name", notNullValue());
    }
}

Este teste será executado cinco vezes, uma vez para cada ID de usuário fornecido pelo provedor de dados.

Validando Respostas JSON em Testes de API do Rest Assured

O Rest Assured fornece poderosas capacidades de parsing de JSON usando JSONPath:

given()
.when()
    .get("https://api.example.com/users/1")
.then()
    .statusCode(200)
    .body("name", equalTo("John Doe"))
    .body("email", endsWith("@example.com"))
    .body("roles", hasItems("user", "admin"))
    .body("address.city", equalTo("Nova Iorque"))
    .body("phoneNumbers.size()", greaterThanOrEqualTo(1));

Este teste valida vários aspectos da resposta JSON, incluindo objetos e arrays aninhados.

Gerenciando Respostas XML

Embora o JSON seja mais comum, algumas APIs ainda usam XML. O Rest Assured também pode lidar com respostas XML:

given()
.when()
    .get("https://api.example.com/data.xml")
.then()
    .statusCode(200)
    .body("root.data.name", equalTo("Test Name"))
    .body("root.data.value", equalTo("100"));

Upload e Download de Arquivos

O Rest Assured pode lidar com operações de arquivos:

Upload de Arquivos

File fileToUpload = new File("path/to/file.txt");

given()
    .multiPart("file", fileToUpload)
.when()
    .post("/upload")
.then()
    .statusCode(200)
    .body("message", equalTo("Arquivo carregado com sucesso"));

Download de Arquivos

byte[] downloadedFile = given()
.when()
    .get("/download/file.pdf")
.then()
    .statusCode(200)
    .extract().asByteArray();

// Agora você pode gravar o array de bytes em um arquivo ou processá-lo ainda mais

Usando Apidog com Testes de API do Rest Assured

Enquanto o Rest Assured é poderoso por conta própria, você pode aprimorar seu fluxo de trabalho de testes de API incorporando Apidog, uma plataforma de documentação e testes de API. Aqui está como você pode usar Apidog ao lado do Rest Assured:

Desenhar APIs: Use APIdog para desenhar e documentar suas APIs antes da implementação. Isso ajuda a criar uma especificação clara para desenvolvedores e testadores.

Gerar Testes: APIdog pode gerar casos de teste com base em suas especificações de API. Embora esses não sejam testes diretamente do Rest Assured, eles podem servir como um modelo para o que testar.

Implementar Testes: Traduza os casos de teste gerados pelo APIdog em testes do Rest Assured. Isso garante que seus testes cubram todos os comportamentos especificados.

Colaborar: Compartilhe especificações de API e resultados de testes com sua equipe através dos recursos colaborativos do APIdog. Isso mantém todos alinhados quanto ao comportamento esperado da API.

Manter Documentação: À medida que você atualiza seus testes do Rest Assured, garanta que a documentação do APIdog permaneça sincronizada. Isso ajuda a manter uma documentação de API precisa e atualizada.

Como Integrar API REST com Apidog

A integração de uma API REST com Apidog envolve algumas etapas básicas. Aqui está um processo passo a passo detalhado para integrar API REST com Apidog:

2. Clique em "Novo Projeto" e dê um nome ao seu projeto.

3. Crie uma Nova API.

4. Agora clique no botão "Adicionar Endpoint" e preencha os seguintes detalhes para o endpoint "Obter todos os livros": Neste caso,

URL: http://localhost:5000/books

Método: GET

Nome do endpoint: Obter todos os livros

5. Especifique quaisquer parâmetros de consulta ou cabeçalhos que seu endpoint possa exigir clicando nos botões "Adicionar parâmetro" ou "Adicionar cabeçalho".

6. Clique no botão "Enviar" para testar seu endpoint e garantir que está funcionando corretamente. Assim que seu endpoint estiver funcionando como esperado, clique no botão "Salvar APICase" para adicioná-lo ao seu projeto Apidog.

7. Agora você pode usar Apidog para testar seu endpoint e gerar documentação para sua API Flask.

8. Defina os passos de teste do seu caso de teste e selecione os endpoints que deseja incluir nos testes. Personalize os Casos de Teste conforme suas necessidades.

9. Depois de testar os casos, você pode publicá-los na web ou exportá-los para um arquivo PDF ou Markdown.

O Apidog oferece inúmeras opções de personalização para auxiliar os usuários a utilizar e testar suas APIs de acordo com seus requisitos específicos.

Melhores Práticas para Testes de API do Rest Assured

Para aproveitar ao máximo os testes de API do Rest Assured, considere estas melhores práticas:

Organize seus testes: Use TestNG ou JUnit para estruturar seus testes de forma lógica. Agrupe testes relacionados e use anotações apropriadas para configuração e finalização.

Reutilize código: Crie métodos utilitários para operações comuns para manter seus testes DRY (Don't Repeat Yourself). Por exemplo:

public class TestUtils {
    public static RequestSpecification getBaseRequestSpec() {
        return given()
            .baseUri("https://api.example.com")
            .contentType(ContentType.JSON)
            .accept(ContentType.JSON);
    }
}

Então use isso em seus testes:

@Test
public void testSomething() {
    TestUtils.getBaseRequestSpec()
        .when()
            .get("/endpoint")
        .then()
            .statusCode(200);
}

Use logging: Ative o registro para depurar problemas mais facilmente. O Rest Assured fornece várias opções de registro:

given()
    .log().all()  // Registra todos os detalhes da requisição
.when()
    .get("/endpoint")
.then()
    .log().ifValidationFails()  // Registra a resposta se a asserção falhar
    .statusCode(200);

Valide esquemas: Use validação de Esquema JSON para garantir que as estruturas de resposta estejam corretas:

given()
.when()
    .get("/users")
.then()
    .assertThat()
    .body(matchesJsonSchemaInClasspath("user-schema.json"));

Gerencie dados específicos do ambiente: Use arquivos de propriedades ou variáveis de ambiente para gerenciar diferentes ambientes:

public class Config {
    public static String getBaseUrl() {
        return System.getProperty("api.baseUrl", "https://api.example.com");
    }
}

Então use isso em seus testes:

@Test
public void testEndpoint() {
    given()
        .baseUri(Config.getBaseUrl())
    .when()
        .get("/users")
    .then()
        .statusCode(200);
}

Use extração de resposta: Para validações complexas, extraia a resposta e faça asserções:

Response response = given()
    .when()
        .get("/users")
    .then()
        .extract().response();

JsonPath jsonPath = response.jsonPath();
List<String> names = jsonPath.getList("name");
Assert.assertTrue(names.contains("John Doe"));

Implemente matchers personalizados: Para validações específicas, crie matchers personalizados do Hamcrest:

public class CustomMatchers {
    public static Matcher<String> isValidEmail() {
        return new TypeSafeMatcher<String>() {
            @Override
            protected boolean matchesSafely(String item) {
                return item.matches("^[A-Za-z0-9+_.-]+@(.+)$");
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("deve ser um e-mail válido");
            }
        };
    }
}

Use-o em seus testes:

given()
.when()
    .get("/users/1")
.then()
    .body("email", CustomMatchers.isValidEmail());

Use provedores de dados para testes abrangentes: Aproveite os provedores de dados do TestNG para testar vários cenários:

@DataProvider(name = "userRoles")
public Object[][] userRoles() {
    return new Object[][] {
        {"admin", 200},
        {"user", 403},
        {"guest", 401}
    };
}

@Test(dataProvider = "userRoles")
public void testAccessControl(String role, int expectedStatus) {
    given()
        .auth().oauth2(getTokenForRole(role))
    .when()
        .get("/admin-endpoint")
    .then()
        .statusCode(expectedStatus);
}

Implemente um mecanismo de nova tentativa: Para testes instáveis ou redes não confiáveis, implemente um mecanismo de nova tentativa:

@Test(retryAnalyzer = RetryAnalyzer.class)
public void testWithRetry() {
    // Seu código de teste aqui
}

public class RetryAnalyzer implements IRetryAnalyzer {
    private int retryCount = 0;
    private static final int MAX_RETRY_COUNT = 3;

    @Override
    public boolean retry(ITestResult result) {
        if (retryCount < MAX_RETRY_COUNT) {
            retryCount++;
            return true;
        }
        return false;
    }
}

Use especificações: Para expectativas consistentes de requisição/resposta, use especificações:

RequestSpecification requestSpec = new RequestSpecBuilder()
    .setBaseUri("https://api.example.com")
    .setContentType(ContentType.JSON)
    .build();

ResponseSpecification responseSpec = new ResponseSpecBuilder()
    .expectStatusCode(200)
    .expectContentType(ContentType.JSON)
    .build();

@Test
public void testWithSpecs() {
    given()
        .spec(requestSpec)
    .when()
        .get("/users")
    .then()
        .spec(responseSpec);
}

Conclusão

Os testes de API do Rest Assured oferecem uma maneira poderosa e flexível de automatizar seus testes de API. Ao combiná-lo com ferramentas como TestNG e APIdog, você pode criar uma estratégia abrangente de testes de API que se integra perfeitamente aos seus projetos baseados em Java.

As principais vantagens de usar o Rest Assured incluem:

1. Simplicidade: Sua API fluente torna a escrita de testes intuitiva e legível.
2. Poder: Oferece extensas capacidades para construção de requisições e validação de respostas.
3. Integração: Funciona bem com o ecossistema Java, incluindo ferramentas de build e pipelines CI/CD.
4. Flexibilidade: Desde requisições GET simples até autenticação complexa e manipulação de arquivos, o Rest Assured pode lidar com tudo.

À medida que as APIs continuam a desempenhar um papel crucial na arquitetura moderna de software, testes robustos de API se tornam cada vez mais importantes. O Rest Assured fornece as ferramentas necessárias para garantir que suas APIs sejam confiáveis, com bom desempenho e se comportem como esperado.

Lembre-se, testes eficazes de API não são apenas sobre encontrar bugs; é sobre garantir a qualidade e a confiabilidade de todo o seu sistema. Com o Rest Assured, você tem uma ferramenta versátil à sua disposição para testar minuciosamente suas APIs e detectar problemas antes que cheguem à produção.

À medida que você continua sua jornada com o Rest Assured, continue explorando seus recursos, mantenha-se atualizado com as versões mais recentes e não hesite em contribuir com a comunidade de código aberto. Boas provas!