TL;DR

  • REST Assured = librería Java para testing de REST API con sintaxis fluida
  • Patrón: given() (setup) → when() (acción) → then() (verificar)
  • Assertions: códigos de estado, headers, body JSON/XML con JsonPath/XmlPath
  • Se integra con JUnit 5, TestNG, Maven, Gradle
  • Mejor para equipos Java que quieren tests de API basados en código

Ideal para: Proyectos Java, equipos usando JUnit/TestNG, pipelines CI/CD Omite si: Stack no-Java o necesitas testing basado en GUI (usa Postman) Tiempo de lectura: 14 minutos

Tu proyecto Java necesita tests de API. El testing manual en Postman no escala. Quieres tests en el mismo lenguaje que tu aplicación, corriendo en CI/CD junto a los unit tests.

REST Assured trae el testing de API a Java. Escribe tests con sintaxis fluida, valida respuestas con matchers poderosos, integra con frameworks de test existentes.

¿Qué es REST Assured?

REST Assured es una librería Java que simplifica el testing de REST APIs. Provee un domain-specific language (DSL) para hacer requests HTTP y validar respuestas.

Por qué REST Assured:

  • Java-native — integración con JUnit, TestNG, Maven, Gradle
  • Sintaxis fluida — patrón legible given/when/then
  • Validación poderosa — JsonPath, XmlPath, Hamcrest matchers
  • Autenticación — OAuth, basic auth, API keys incluidos
  • Logging — depuración fácil de requests/responses

Setup

Maven

<dependencies>
    <dependency>
        <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>5.4.0</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>5.10.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

Gradle

testImplementation 'io.rest-assured:rest-assured:5.4.0'
testImplementation 'org.junit.jupiter:junit-jupiter:5.10.0'

Imports estáticos

import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

Tu primer test

Request GET básico

import org.junit.jupiter.api.Test;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class ApiTest {

    @Test
    void shouldReturnUsers() {
        given()
            .baseUri("https://api.example.com")
        .when()
            .get("/users")
        .then()
            .statusCode(200)
            .body("size()", greaterThan(0));
    }
}

POST con body JSON

@Test
void shouldCreateUser() {
    String requestBody = """
        {
            "name": "John Doe",
            "email": "john@example.com"
        }
        """;

    given()
        .baseUri("https://api.example.com")
        .contentType("application/json")
        .body(requestBody)
    .when()
        .post("/users")
    .then()
        .statusCode(201)
        .body("id", notNullValue())
        .body("name", equalTo("John Doe"));
}

Construcción de requests

Headers y Query Params

given()
    .baseUri("https://api.example.com")
    .header("Authorization", "Bearer " + token)
    .header("Accept", "application/json")
    .queryParam("page", 1)
    .queryParam("limit", 10)
.when()
    .get("/users")
.then()
    .statusCode(200);

Path Parameters

given()
    .baseUri("https://api.example.com")
    .pathParam("userId", 123)
.when()
    .get("/users/{userId}")
.then()
    .statusCode(200)
    .body("id", equalTo(123));

Validación de respuestas

Estado y headers

.then()
    .statusCode(200)
    .statusLine(containsString("OK"))
    .header("Content-Type", "application/json")
    .header("Cache-Control", containsString("max-age"));

JSON Body con JsonPath

// Respuesta: {"user": {"id": 1, "name": "John", "roles": ["admin", "user"]}}

.then()
    .body("user.id", equalTo(1))
    .body("user.name", equalTo("John"))
    .body("user.roles", hasSize(2))
    .body("user.roles", hasItem("admin"));

Extraer datos de respuesta

Response response = given()
    .baseUri("https://api.example.com")
.when()
    .get("/users/1")
.then()
    .extract().response();

String name = response.jsonPath().getString("name");
int id = response.jsonPath().getInt("id");
List<String> roles = response.jsonPath().getList("roles");

Autenticación

Basic Auth

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

Bearer Token

given()
    .auth().oauth2(accessToken)
.when()
    .get("/api/resource")
.then()
    .statusCode(200);

// O con header
given()
    .header("Authorization", "Bearer " + accessToken)
.when()
    .get("/api/resource");

Organización de tests

Configuración base

import org.junit.jupiter.api.BeforeAll;
import io.restassured.RestAssured;

public class BaseApiTest {

    @BeforeAll
    static void setup() {
        RestAssured.baseURI = "https://api.example.com";
        RestAssured.basePath = "/v1";
        RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
    }
}

REST Assured con Asistencia de IA

Las herramientas de IA pueden ayudar a escribir y mantener tests de REST Assured.

Lo que la IA hace bien:

  • Generar métodos de test desde documentación de API
  • Crear cadenas de assertions para JSON complejo
  • Convertir colecciones de Postman a REST Assured
  • Sugerir escenarios de edge cases

Lo que necesita humanos:

  • Diseñar estrategia de testing
  • Entender reglas de validación de negocio
  • Depurar problemas de autenticación
  • Decisiones de performance testing

FAQ

¿Qué es REST Assured?

REST Assured es una librería Java para testear REST APIs. Provee un domain-specific language (DSL) fluido con el patrón given/when/then que hace los tests legibles. Se integra con JUnit 5, TestNG, Maven y Gradle — encajando naturalmente en flujos de trabajo de proyectos Java.

¿REST Assured vs Postman — cuál usar?

REST Assured es basado en código (Java), corre en CI/CD y vive en control de versiones. Postman es basado en GUI, genial para exploración y testing manual. Usa REST Assured cuando tu equipo escribe Java y necesita tests automatizados en pipeline. Usa Postman para exploración rápida de API o equipos sin desarrolladores Java.

¿Puede REST Assured testear SOAP APIs?

REST Assured está diseñado específicamente para REST/HTTP APIs. Aunque puedes enviar payloads XML, carece de funciones específicas de SOAP como parsing de WSDL y manejo de sobres. Para testing SOAP, usa herramientas dedicadas como SoapUI o Apache CXF.

¿REST Assured soporta autenticación?

Sí, soporte completo. Basic auth con .auth().basic(), OAuth 2.0 con .auth().oauth2(), digest auth y headers personalizados para API keys o bearer tokens. La autenticación puede configurarse por-request o globalmente via RestAssured.authentication.

Recursos Oficiales

Ver También