API-Tests: Checkliste und Autotests

API-Test-Checkliste: Von Statuscodes bis hin zu KI-gesteuerter Automatisierung

API-Tests erfordern einen systematischen Ansatz – Validierung von Statuscodes, Antwortstrukturen, Grenzfällen und Authentifizierung. Postman ist ideal für manuelle Tests, während Jest + axios nahtlos in CI/CD-Pipelines integriert werden kann. KI beschleunigt die Erzeugung von Testfällen aus OpenAPI-Spezifikationen, analysiert Antworten und erkennt Muster bei extremen Datenwerten.

Wichtige Kategorien beim API-Testing

API-Tests umfassen mehrere kritische Bereiche. Das Überspringen einzelner Punkte birgt das Risiko, Fehler in der Produktion unentdeckt zu lassen.

Statuscodes

Stellen Sie sicher, dass der Code dem erwarteten Szenario entspricht:

| Szenario | Erwarteter Code |

|----------|----------------|

| Erfolgreiche Erstellung | 201 |

| Ressource nicht gefunden | 404 |

| Unzureichende Berechtigungen | 403 |

| Nicht authentifiziert | 401 |

| Ungültige Daten | 400/422 |

| Serverfehler | 500 |

Häufiger Fehler: Rückgabe von 200 mit Fehler im Body – dies verstößt gegen REST-Prinzipien.

Antwortstruktur

• Erforderliche Felder sind vorhanden.
• Datentypen stimmen mit Erwartungen überein (z. B. Zahl statt String).
• Verschachtelte Objekte sind nicht null.
• Arrays werden nicht mit Objekten verwechselt.

Grenzfälle

Testen Sie Randbedingungen:

• Leerer Anfragetext.
• Fehlendes Pflichtfeld.
• Leerzeichen in einem Feld.
• Zahlen: 0, negative Werte, MAX_INT.
• Zeichenketten: 1 Zeichen, maximale Länge, Sonderzeichen, SQL/XSS-Payloads.

Authentifizierung & Header

• Kein Token: 401.
• Abgelaufener Token: 401.
• Ungültiger Token: 403.
• Schreibgeschützter Benutzer bei Schreiboperation: 403.

Header: Content-Type, CORS, Rate-Limiting.

Testen mit Postman

Nutzen Sie den Tests-Tab für JavaScript-Skripte nach Empfang einer Antwort.

Grundlegende Assertions

// Status und Antwortzeit
pm.test("Status 200", () => {
    pm.response.to.have.status(200);
});

pm.test("Antwort <500ms", () => {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

// Content-Type
pm.test("JSON", () => {
    pm.response.to.have.header("Content-Type", "application/json; charset=utf-8");
});

Struktur und Typen

const response = pm.response.json();

pm.test("id ist vorhanden", () => {
    pm.expect(response).to.have.property("id");
});

pm.test("id ist eine Zahl", () => {
    pm.expect(response.id).to.be.a("number");
});

pm.test("email ist nicht leer", () => {
    pm.expect(response.email).to.be.a("string").and.not.empty;
});

Negative Fälle: Kein Token

pm.test("401 ohne Token", () => {
    pm.response.to.have.status(401);
});

const response = pm.response.json();
pm.expect(response).to.have.property("message");

Speichern Sie den Token aus /login in einer Umgebungsvariablen: pm.environment.set("auth_token", response.token);. Verwenden Sie ihn als {{auth_token}} in den Headern.

Automatisierte Tests mit Jest + axios

Für CI/CD schreiben Sie Tests direkt im Code. Beispiel für /users/:id:

const axios = require("axios");

const BASE_URL = "https://api.example.com";
const TOKEN = process.env.API_TOKEN;

const client = axios.create({
    baseURL: BASE_URL,
    headers: { Authorization: `Bearer ${TOKEN}` }
});

describe("GET /users/:id", () => {

    test("Benutzer per ID abrufen", async () => {
        const response = await client.get("/users/1");

        expect(response.status).toBe(200);
        expect(response.data).toMatchObject({
            id: expect.any(Number),
            email: expect.any(String),
            name: expect.any(String),
        });
    });

    test("404 für nicht existierenden Benutzer", async () => {
        await expect(client.get("/users/999999"))
            .rejects.toMatchObject({
                response: { status: 404 }
            });
    });

    test("401 ohne Token", async () => {
        await expect(axios.get(`${BASE_URL}/users/1`))
            .rejects.toMatchObject({
                response: { status: 401 }
            });
    });

});

Ausführen mit: npx jest user.test.js.

Universelle Checkliste

Positive Szenarien:

• Gültige Daten → korrekter Status.
• Antwortstruktur entspricht Dokumentation.
• Erforderliche Felder vorhanden.
• Korrekte Datentypen.
• Antwortzeit innerhalb vorgegebener Grenzen.

Negative Fälle:

• Keine Auth → 401.
• Falscher Token → 403.
• Fehlendes Feld → 400/422.
• Falscher Datentyp → 400/422.
• Nicht existierende Ressource → 404.
• Leerer Body → Validierungsfehler.

Grenzfälle:

• Min-/Max-Werte.
• Null oder negative Zahlen.
• Leere Zeichenketten.
• Sonderzeichen/Unicode.
• Lange Zeichenketten.

Sicherheit:

• SQL-Injection.
• XSS.
• IDOR (ID-Raten).

KI-gestützte Automatisierung

KI generiert Testfälle aus OpenAPI-Spezifikationen – sowohl positive als auch negative und Grenzfälle – im Jest-Format.

Prompt: "Generiere Tests für POST /users basierend auf Schema [schema]. Nutze realistische Daten."

Automatische Analyse von Antworten mittels LLMs:

async function validateWithAI(prompt, response) {
    // Aufruf von Claude/GPT zur Bewertung der Relevanz
    // ...
    return data.content[0].text.trim() === "YES";
}

Erzeugung von Grenzdaten: KI schlägt RTL-Text, Emojis, unsichtbare Unicode-Zeichen vor.

KI ersetzt kein Verständnis der Geschäftslogik (z. B. Rabatt ≤ 100 für Nicht-Premium-Nutzer).

Was zählt wirklich?

• Validieren Sie Statuscodes strikt je Szenario – verwenden Sie niemals 200 für Fehler.
• Testen Sie Antwortstruktur und Typen mit JSONPath-ähnlichen Assertionen.
• Automatisieren Sie negative und Grenzfälle in CI/CD mit Jest/axios.
• Nutzen Sie KI für repetitive Aufgaben: Testgenerierung, Analyse, Grenzdaten.
• Verwenden Sie die Checkliste als obligatorisches Template für jeden Endpunkt.

— Editorial Team