Einführung

Cypress ist weithin für seine End-to-End-Testfunktionen bekannt, aber es ist auch ein leistungsstarkes Tool zum Testen von APIs. API-Tests sind ein wesentlicher Bestandteil der Gewährleistung der Zuverlässigkeit, Leistung und Sicherheit moderner Webanwendungen, da viele Anwendungen heutzutage stark von Backend-Diensten und APIs abhängig sind. Dieser Beitrag führt Sie durch die Grundlagen des API-Testens mit Cypress, einschließlich der Einrichtung von API-Tests, der Erstellung von Anfragen, der Validierung von Antworten und der Automatisierung des Prozesses.

Warum Cypress für API-Tests verwenden?

1. Integrierte Funktionen: Cypress verfügt über integrierte Funktionen zum Erstellen von HTTP-Anfragen, Behauptungen und zum Verwalten asynchroner Tests.
2. Einfache Integration: Sie können API-Tests neben Ihren UI-Tests problemlos in Ihre bestehende Cypress-Testsuite integrieren.
3. Tolle Entwicklererfahrung: Cypress bietet eine benutzerfreundliche Oberfläche, schnelles Feedback und Echtzeit-Debugging.
4. Automatisierung: Sie können API-Tests in Ihrer CI/CD-Pipeline automatisieren und so sicherstellen, dass APIs bei jeder Bereitstellung konsistent getestet werden.

Erste Schritte mit API-Tests in Cypress

Wenn Sie Cypress bereits für End-to-End-Tests installiert haben, können Sie mit dem API-Testen beginnen. Wenn nicht, befolgen Sie die folgenden Installationsschritte.

Schritt 1: Cypress installieren

npm install cypress --save-dev

Nach der Installation können Sie Cypress mit dem folgenden Befehl ausführen:

npx cypress open

Schritt 2: Einrichten Ihres ersten API-Tests
Cypress bietet eine cy.request()-Methode, mit der Sie HTTP-Anfragen senden können. Hier ist ein einfaches Beispiel für das Testen einer API, die eine Liste von Benutzern zurückgibt:

describe('API Testing with Cypress', () => {
  it('should retrieve a list of users', () => {
    cy.request('GET', 'https://jsonplaceholder.typicode.com/users')
      .then((response) => {
        // Validate the status code
        expect(response.status).to.eq(200);

        // Validate the response body
        expect(response.body).to.have.length(10);
        expect(response.body[0]).to.have.property('name');
      });
  });
});

In diesem Beispiel testen wir eine GET-Anfrage, um eine Liste von Benutzern abzurufen. Cypress validiert den Antwortstatuscode und prüft, ob der Antworttext 10 Benutzer enthält.

Gängige HTTP-Methoden beim API-Testen

So können Sie gängige HTTP-Anfragen wie GET, POST, PUT und DELETE in Cypress ausführen.

GET-Anfrage
GET-Anfragen werden verwendet, um Daten vom Server abzurufen. Zum Beispiel:

cy.request('GET', 'https://jsonplaceholder.typicode.com/posts/1')
  .then((response) => {
    expect(response.status).to.eq(200);
    expect(response.body).to.have.property('id', 1);
  });

POST-Anfrage
POST-Anfragen werden verwendet, um neue Ressourcen auf dem Server zu erstellen. So testen Sie eine POST-Anfrage:

cy.request('POST', 'https://jsonplaceholder.typicode.com/posts', {
  title: 'New Post',
  body: 'This is the content of the new post.',
  userId: 1
})
  .then((response) => {
    expect(response.status).to.eq(201);
    expect(response.body).to.have.property('title', 'New Post');
  });

PUT-Anfrage
PUT-Anfragen werden verwendet, um vorhandene Ressourcen zu aktualisieren. Beispiel:

cy.request('PUT', 'https://jsonplaceholder.typicode.com/posts/1', {
  id: 1,
  title: 'Updated Post Title',
  body: 'Updated content',
  userId: 1
})
  .then((response) => {
    expect(response.status).to.eq(200);
    expect(response.body).to.have.property('title', 'Updated Post Title');
  });

DELETE-Anfrage
DELETE-Anfragen werden zum Entfernen von Ressourcen verwendet. Beispiel:

cy.request('DELETE', 'https://jsonplaceholder.typicode.com/posts/1')
  .then((response) => {
    expect(response.status).to.eq(200);
  });

Erweiterte API-Testtechniken

Sobald Sie grundlegende API-Anfragen beherrschen, können Sie mit fortgeschritteneren API-Testtechniken fortfahren, wie z. B. der Handhabung der Authentifizierung, dem Testen von API-Fehlern und der Verkettung von API-Aufrufen.

Handhabung der Authentifizierung
Einige APIs erfordern eine Authentifizierung über Token oder API-Schlüssel. Cypress kann die Authentifizierung durchführen, indem es benutzerdefinierte Header festlegt. Zum Beispiel:

cy.request({
  method: 'GET',
  url: 'https://api.example.com/protected',
  headers: {
    Authorization: `Bearer ${Cypress.env('auth_token')}`
  }
})
  .then((response) => {
    expect(response.status).to.eq(200);
  });

Hier wird der Authorization-Header verwendet, um zusammen mit der Anfrage ein Token zu senden.

API-Fehler testen
Es ist wichtig zu testen, wie sich Ihre API verhält, wenn etwas schief geht, beispielsweise bei ungültigen Eingaben oder fehlenden Ressourcen. Beispiel: Testen eines 404-Fehlers:

cy.request({
  method: 'GET',
  url: 'https://jsonplaceholder.typicode.com/posts/9999',
  failOnStatusCode: false
})
  .then((response) => {
    expect(response.status).to.eq(404);
  });

Durch die Einstellung failOnStatusCode: false wird Cypress den Test für Nicht-2xx-Antworten nicht automatisch nicht bestehen lassen, sodass Sie Fehlerantworten validieren können.

API-Aufrufe verketten
Manchmal müssen Sie mehrere API-Aufrufe miteinander verketten, beispielsweise um eine Ressource zu erstellen und sie dann in einem nachfolgenden Test zu verwenden:

cy.request('POST', 'https://jsonplaceholder.typicode.com/posts', {
  title: 'Post for chaining',
  body: 'Chained post content',
  userId: 1
}).then((postResponse) => {
  cy.request('GET', `https://jsonplaceholder.typicode.com/posts/${postResponse.body.id}`)
    .then((getResponse) => {
      expect(getResponse.body).to.have.property('title', 'Post for chaining');
    });
});

In diesem Beispiel erstellt die POST-Anfrage einen neuen Beitrag und die GET-Anfrage ruft diesen Beitrag basierend auf der vom ersten Aufruf zurückgegebenen ID ab.

Automatisierung von API-Tests in CI/CD-Pipelines

Um die Stabilität Ihrer APIs sicherzustellen, ist es wichtig, Ihre API-Tests als Teil Ihrer Continuous Integration/Continuous Deployment (CI/CD)-Pipeline auszuführen. Cypress lässt sich problemlos in CI/CD-Tools wie Jenkins, GitHub Actions oder Travis CI integrieren.

Hier ist ein Beispiel für einen GitHub Actions-Workflow, der Cypress-Tests bei jedem Push ausführt:

name: CI

on:
  push:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '14'

      - name: Install dependencies
        run: npm install

      - name: Run Cypress tests
        run: npx cypress run

Dieser Workflow stellt sicher, dass API-Tests jedes Mal automatisch ausgeführt werden, wenn Code in den Hauptzweig übertragen wird.

Best Practices für API-Tests mit Cypress

Um sicherzustellen, dass Ihre API-Tests zuverlässig, wartbar und effizient sind, befolgen Sie diese Best Practices:

1. Umgebungsvariablen verwenden: Speichern Sie vertrauliche Daten wie API-Schlüssel, Token oder Basis-URLs in Umgebungsvariablen.
2. Bei Bedarf Scheinantworten: Wenn Sie nicht jedes Mal auf die echte API zugreifen möchten, verspotten Sie die API-Antworten mit cy.intercept().
3. Behandeln Sie Ratenbeschränkungen: Wenn Ihre API über Ratenbeschränkungen verfügt, stellen Sie sicher, dass Ihre Tests diese angemessen handhaben, indem Sie Wiederholungen oder Verzögerungen zwischen Anfragen hinzufügen.
4. Tests unabhängig halten: Stellen Sie sicher, dass jeder API-Test unabhängig von den anderen ist, sodass sie in beliebiger Reihenfolge ohne Abhängigkeitsprobleme ausgeführt werden können.
5. Fokus auf Randfälle: Testen Sie sowohl den Happy Path als auch Randfälle (z. B. ungültige Eingaben, große Datensätze, Ratenbegrenzung), um alle potenziellen Szenarien abzudecken.

Abschluss

API-Tests sind ein wesentlicher Bestandteil, um sicherzustellen, dass Ihre Anwendung reibungslos funktioniert, auch wenn sie auf externe Dienste oder Backend-APIs angewiesen ist. Cypress bietet eine einfache, aber leistungsstarke Möglichkeit, APIs zusätzlich zu Ihren UI-Tests zu testen, was es zu einer ausgezeichneten Wahl für Entwickler macht, die mit modernen JavaScript-Anwendungen arbeiten. Durch die Nutzung von Funktionen wie cy.request(), Assertions und CI/CD-Integration können Sie eine robuste und zuverlässige API-Testsuite erstellen, die Probleme frühzeitig erkennt und die Qualität Ihrer APIs sicherstellt.

Beginnen Sie noch heute mit dem Testen Ihrer APIs mit Cypress und verbessern Sie Ihren Entwicklungsworkflow mit automatisierten, zuverlässigen Tests!