REST Assured — REST-APIs professionell testen in Java

REST-Assured ist die inoffizielle Standardbibliothek zum Testen von REST-APIs in Java. Mit ihrer ausdrucksstarken, BDD-inspirierten Fluent-API lassen sich HTTP-Requests und deren Responses intuitiv formulieren und validieren. Über 7.000 GitHub-Sterne und die nahtlose Integration mit JUnit 5 machen REST Assured zur ersten Wahl für API-Tests. Seit Version 6.0.0 (Dezember 2025) setzt REST Assured auf Java 17+ als Baseline und bietet Support für Spring Framework 7, Jackson 3 und Groovy 5.

Erste Schritte

<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>rest-assured</artifactId>
    <version>6.0.0</version>
    <scope>test</scope>
</dependency>
Code-Sprache: HTML, XML (xml)

REST Assured 6.x setzt Java 17 voraus. Für Projekte, die noch auf Java 11/8 laufen, steht die 5.x-Linie (aktuell 5.5.7) zur Verfügung.

Das Grundmuster von REST Assured folgt dem BDD-Prinzip given-when-then:

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

class ApiTest {

    @Test
    void einfacherGetRequest() {
        given()
            .baseUri("https://api.example.com")
        .when()
            .get("/users/42")
        .then()
            .statusCode(200)
            .body("name", equalTo("Max Mustermann"))
            .body("email", containsString("@"));
    }
}
Code-Sprache: JavaScript (javascript)

Der Clou: given() beschreibt die Request-Parameter, when() führt den Request aus und then() validiert die Response — alles in fließendem, lesbarem Java.

Statische Imports und Basiskonfiguration

Für wiederkehrende Basis-URLs empfiehlt sich eine zentrale Konfiguration:

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

class BaseApiTest {

    @BeforeAll
    static void setup() {
        RestAssured.baseURI = "http://localhost:8080/api";
        RestAssured.port = 8080;
        RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
    }
}
Code-Sprache: JavaScript (javascript)

Mit enableLoggingOfRequestAndResponseIfValidationFails() werden Request und Response nur bei fehlgeschlagenen Tests geloggt — extrem hilfreich für die Fehlersuche.

JSON-Validierung mit JsonPath

REST Assured integriert JsonPath, eine Abfragesprache für JSON, die an XPath erinnert:

@Test
void komplexeJsonValidierung() {
    given()
        .queryParam("minPreis", 20)
    .when()
        .get("/buecher")
    .then()
        .statusCode(200)
        .body("size()", greaterThan(0))
        .body("findAll { it.preis > 30 }.name", hasItem("Clean Code"))
        .body("max { it.preis }.name", notNullValue());
}
Code-Sprache: JavaScript (javascript)

Neben findAll und max unterstützt JsonPath auch find, min, sum und collect.

POST-Requests und Serialisierung

REST Assured serialisiert Java-Objekte mithilfe eines konfigurierten ObjectMapper (standardmäßig Jackson) automatisch in JSON:

import io.restassured.http.ContentType;

record BuchRequest(String titel, String autor, double preis) {}

@Test
void buchErstellen() {
    BuchRequest neuesBuch = new BuchRequest("Domain-Driven Design", "Eric Evans", 44.99);

    given()
        .contentType(ContentType.JSON)
        .body(neuesBuch)
    .when()
        .post("/buecher")
    .then()
        .statusCode(201)
        .header("Location", notNullValue())
        .body("id", notNullValue())
        .body("titel", equalTo("Domain-Driven Design"));
}
Code-Sprache: JavaScript (javascript)

Authentifizierung

REST Assured unterstützt alle gängigen Auth-Mechanismen:

<em>// Basic Auth</em>
given().auth().basic("username", "password").when().get("/secure");

<em>// OAuth 2.0</em>
given().auth().oauth2("access-token-xyz").when().get("/api/protected");

<em>// API-Key</em>
given().header("X-API-Key", "secret-key").when().get("/external-api");
Code-Sprache: JavaScript (javascript)

Response-Daten extrahieren

Manchmal benötigt man Daten aus einer Response für den nächsten Request:

@Test
void responseDatenWiederverwenden() {
    String userId = given()
        .body(new BuchRequest("Effective Java", "Joshua Bloch", 39.90))
    .when()
        .post("/buecher")
    .then()
        .statusCode(201)
        .extract()
        .path("id");

    <em>// Verwende die ID im nächsten Request</em>
    given()
    .when()
        .get("/buecher/" + userId)
    .then()
        .statusCode(200);
}
Code-Sprache: JavaScript (javascript)

Schema-Validierung

Mit json-schema-validator lassen sich Responses gegen ein JSON Schema prüfen. Dazu wird das Modul als zusätzliche Abhängigkeit benötigt:

<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>json-schema-validator</artifactId>
    <version>6.0.0</version>
    <scope>test</scope>
</dependency>
Code-Sprache: HTML, XML (xml)

import static io.restassured.module.jsv.JsonSchemaValidator.*;

@Test
void responseSchemaValidieren() {
    given()
    .when()
        .get("/users")
    .then()
        .assertThat()
        .body(matchesJsonSchemaInClasspath("user-schema.json"));
}
Code-Sprache: JavaScript (javascript)

Fazit

REST Assured macht API-Tests zu einer dankbaren Aufgabe: Die Fluent-API ist sofort verständlich, JsonPath und Hamcrest-Matchers ermöglichen präzise Validierungen und Authentifizierungsmechanismen sind direkt integriert. In Kombination mit Testcontainers für echte HTTP-Calls entstehen robuste, aussagekräftige Integrationstests, die im CI/CD-Pipeline verlässlich die API-Qualität sichern.