Integrationstests: API-Tests mit Supertest meistern

Im Bereich der Softwareentwicklung ist es entscheidend sicherzustellen, dass einzelne Komponenten isoliert korrekt funktionieren (Unit-Tests). Es ist jedoch ebenso wichtig zu überprüfen, ob diese Komponenten nahtlos zusammenarbeiten. Hier kommen Integrationstests ins Spiel. Integrationstests konzentrieren sich auf die Validierung der Interaktion zwischen verschiedenen Modulen oder Diensten innerhalb einer Anwendung. Dieser Artikel befasst sich eingehend mit Integrationstests, insbesondere mit API-Tests mit Supertest, einer leistungsstarken und benutzerfreundlichen Bibliothek zum Testen von HTTP-Assertions in Node.js.

Was sind Integrationstests?

Integrationstests sind eine Art von Softwaretests, bei denen einzelne Softwaremodule kombiniert und als Gruppe getestet werden. Ihr Ziel ist es, Fehler in den Interaktionen zwischen integrierten Einheiten aufzudecken. Im Gegensatz zu Unit-Tests, die sich auf einzelne Komponenten konzentrieren, überprüfen Integrationstests den Daten- und Kontrollfluss zwischen den Modulen. Gängige Ansätze für Integrationstests umfassen:

• Top-Down-Integration: Beginnend mit den Modulen der höchsten Ebene und Integration nach unten.
• Bottom-Up-Integration: Beginnend mit den Modulen der niedrigsten Ebene und Integration nach oben.
• Big-Bang-Integration: Gleichzeitige Integration aller Module. Dieser Ansatz wird im Allgemeinen weniger empfohlen, da es schwierig ist, Probleme zu isolieren.
• Sandwich-Integration: Eine Kombination aus Top-Down- und Bottom-Up-Integration.

Im Kontext von APIs beinhaltet das Integrationstesting die Überprüfung, ob verschiedene APIs korrekt zusammenarbeiten, ob die zwischen ihnen übergebenen Daten konsistent sind und ob das Gesamtsystem wie erwartet funktioniert. Stellen Sie sich zum Beispiel eine E-Commerce-Anwendung mit separaten APIs für Produktmanagement, Benutzerauthentifizierung und Zahlungsabwicklung vor. Integrationstests würden sicherstellen, dass diese APIs korrekt kommunizieren, sodass Benutzer Produkte durchsuchen, sich sicher anmelden und Einkäufe abschließen können.

Warum sind API-Integrationstests wichtig?

API-Integrationstests sind aus mehreren Gründen von entscheidender Bedeutung:

• Sicherstellung der Systemzuverlässigkeit: Es hilft, Integrationsprobleme frühzeitig im Entwicklungszyklus zu erkennen und unerwartete Ausfälle in der Produktion zu verhindern.
• Validierung der Datenintegrität: Es überprüft, ob Daten korrekt zwischen verschiedenen APIs übertragen und transformiert werden.
• Verbesserung der Anwendungsleistung: Es kann Leistungsengpässe im Zusammenhang mit API-Interaktionen aufdecken.
• Erhöhung der Sicherheit: Es kann Sicherheitsschwachstellen identifizieren, die durch unsachgemäße API-Integration entstehen. Zum Beispiel die Sicherstellung einer ordnungsgemäßen Authentifizierung und Autorisierung, wenn APIs kommunizieren.
• Reduzierung der Entwicklungskosten: Die frühzeitige Behebung von Integrationsproblemen ist deutlich kostengünstiger als deren spätere Behebung im Entwicklungslebenszyklus.

Stellen Sie sich eine globale Reisebuchungsplattform vor. API-Integrationstests sind von größter Bedeutung, um eine reibungslose Kommunikation zwischen APIs für Flugreservierungen, Hotelbuchungen und Zahlungsgateways aus verschiedenen Ländern zu gewährleisten. Eine fehlerhafte Integration dieser APIs könnte zu falschen Buchungen, Zahlungsausfällen und einer schlechten Benutzererfahrung führen, was sich negativ auf den Ruf und den Umsatz der Plattform auswirken würde.

Einführung in Supertest: Ein leistungsstarkes Werkzeug für API-Tests

Supertest ist eine High-Level-Abstraktion zum Testen von HTTP-Anfragen. Es bietet eine komfortable und flüssige API zum Senden von Anfragen an Ihre Anwendung und zum Überprüfen der Antworten. Supertest baut auf Node.js auf und ist speziell für das Testen von Node.js-HTTP-Servern konzipiert. Es funktioniert außergewöhnlich gut mit beliebten Test-Frameworks wie Jest und Mocha.

Schlüsselfunktionen von Supertest:

• Einfach zu bedienen: Supertest bietet eine einfache und intuitive API zum Senden von HTTP-Anfragen und zum Durchführen von Assertions.
• Asynchrones Testen: Es behandelt asynchrone Operationen nahtlos und ist somit ideal zum Testen von APIs, die auf asynchroner Logik basieren.
• Flüssige Schnittstelle: Es bietet eine flüssige Schnittstelle, mit der Sie Methoden für prägnante und lesbare Tests verketten können.
• Umfassende Assertions-Unterstützung: Es unterstützt eine breite Palette von Assertions zur Überprüfung von Antwort-Statuscodes, Headern und Bodies.
• Integration mit Test-Frameworks: Es lässt sich nahtlos in gängige Test-Frameworks wie Jest und Mocha integrieren, sodass Sie Ihre bestehende Testinfrastruktur nutzen können.

Einrichten Ihrer Testumgebung

Bevor wir beginnen, richten wir eine grundlegende Testumgebung ein. Wir gehen davon aus, dass Sie Node.js und npm (oder yarn) installiert haben. Wir werden Jest als unser Test-Framework und Supertest für API-Tests verwenden.

1. Erstellen Sie ein Node.js-Projekt:

            mkdir api-testing-example
cd api-testing-example
npm init -y
            

              
                Copy
              
            
          

2. Installieren Sie die Abhängigkeiten:

            npm install --save-dev jest supertest
npm install express  # Or your preferred framework for creating the API
            

              
                Copy
              
            
          

3. Konfigurieren Sie Jest: Fügen Sie Folgendes zu Ihrer package.json-Datei hinzu:

            {
  "scripts": {
    "test": "jest"
  }
}
            

              
                Copy
              
            
          

4. Erstellen Sie einen einfachen API-Endpunkt: Erstellen Sie eine Datei namens app.js (oder ähnlich) mit dem folgenden Code:

            const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Für Tests exportieren

            

              
                Copy
              
            
          

Schreiben Ihres ersten Supertest-Tests

Nachdem wir unsere Umgebung eingerichtet haben, schreiben wir einen einfachen Supertest-Test, um unseren API-Endpunkt zu überprüfen. Erstellen Sie eine Datei namens app.test.js (oder ähnlich) im Stammverzeichnis Ihres Projekts:

            const request = require('supertest');
const app = require('./app');

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

            

              
                Copy
              
            
          

Erklärung:

• Wir importieren supertest und unsere Express-App.
• Wir verwenden describe, um unsere Tests zu gruppieren.
• Wir verwenden it, um einen spezifischen Testfall zu definieren.
• Wir verwenden request(app), um einen Supertest-Agenten zu erstellen, der Anfragen an unsere App sendet.
• Wir verwenden .get('/hello'), um eine GET-Anfrage an den /hello-Endpunkt zu senden.
• Wir verwenden await, um auf die Antwort zu warten. Die Methoden von Supertest geben Promises zurück, was uns die Verwendung von async/await für saubereren Code ermöglicht.
• Wir verwenden expect(response.statusCode).toBe(200), um zu überprüfen, ob der Antwort-Statuscode 200 OK ist.
• Wir verwenden expect(response.text).toBe('Hello, World!'), um zu überprüfen, ob der Antworttext "Hello, World!" ist.

Um den Test auszuführen, führen Sie den folgenden Befehl in Ihrem Terminal aus:

            npm test
            

              
                Copy
              
            
          

Wenn alles korrekt eingerichtet ist, sollten Sie sehen, dass der Test erfolgreich ist.

Fortgeschrittene Supertest-Techniken

Supertest bietet eine breite Palette von Funktionen für fortgeschrittene API-Tests. Lassen Sie uns einige davon erkunden.

1. Senden von Request-Bodies

Um Daten im Request-Body zu senden, können Sie die Methode .send() verwenden. Erstellen wir zum Beispiel einen Endpunkt, der JSON-Daten akzeptiert:

            app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simuliert das Erstellen eines Benutzers in einer Datenbank
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});
            

              
                Copy
              
            
          

So können Sie diesen Endpunkt mit Supertest testen:

            describe('POST /users', () => {
  it('creates a new user', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});
            

              
                Copy
              
            
          

Erklärung:

• Wir verwenden .post('/users'), um eine POST-Anfrage an den /users-Endpunkt zu senden.
• Wir verwenden .send(userData), um das userData-Objekt im Request-Body zu senden. Supertest setzt den Content-Type-Header automatisch auf application/json.
• Wir verwenden .expect(201), um zu überprüfen, ob der Antwort-Statuscode 201 Created ist.
• Wir verwenden expect(response.body).toHaveProperty('id'), um zu überprüfen, ob der Antwort-Body eine id-Eigenschaft enthält.
• Wir verwenden expect(response.body.name).toBe(userData.name) und expect(response.body.email).toBe(userData.email), um zu überprüfen, ob die name- und email-Eigenschaften im Antwort-Body mit den Daten übereinstimmen, die wir in der Anfrage gesendet haben.

2. Setzen von Headern

Um benutzerdefinierte Header in Ihren Anfragen zu setzen, können Sie die Methode .set() verwenden. Dies ist nützlich zum Setzen von Authentifizierungstoken, Inhaltstypen oder anderen benutzerdefinierten Headern.

            describe('GET /protected', () => {
  it('requires authentication', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('returns 200 OK with a valid token', async () => {
    // Simuliert das Abrufen eines gültigen Tokens
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});
            

              
                Copy
              
            
          

Erklärung:

• Wir verwenden .set('Authorization', `Bearer ${token}`), um den Authorization-Header auf Bearer ${token} zu setzen.

3. Umgang mit Cookies

Supertest kann auch mit Cookies umgehen. Sie können Cookies mit der Methode .set('Cookie', ...) setzen oder die Eigenschaft .cookies verwenden, um auf Cookies zuzugreifen und diese zu ändern.

4. Testen von Datei-Uploads

Supertest kann verwendet werden, um API-Endpunkte zu testen, die Datei-Uploads verarbeiten. Sie können die Methode .attach() verwenden, um Dateien an die Anfrage anzuhängen.

5. Verwendung von Assertions-Bibliotheken (Chai)

Obwohl die eingebaute Assertions-Bibliothek von Jest für viele Fälle ausreicht, können Sie auch leistungsfähigere Assertions-Bibliotheken wie Chai mit Supertest verwenden. Chai bietet eine ausdrucksstärkere und flexiblere Assertions-Syntax. Um Chai zu verwenden, müssen Sie es installieren:

            npm install --save-dev chai
            

              
                Copy
              
            
          

Dann können Sie Chai in Ihre Testdatei importieren und seine Assertions verwenden:

            const request = require('supertest');
const app = require('./app');
const chai = require('chai');
const expect = chai.expect;

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});
            

              
                Copy
              
            
          

Hinweis: Möglicherweise müssen Sie Jest so konfigurieren, dass es korrekt mit Chai funktioniert. Dies beinhaltet oft das Hinzufügen einer Setup-Datei, die Chai importiert und es für die Zusammenarbeit mit dem globalen expect von Jest konfiguriert.

6. Wiederverwenden von Agents

Für Tests, die die Einrichtung einer speziellen Umgebung erfordern (z. B. Authentifizierung), ist es oft vorteilhaft, einen Supertest-Agenten wiederzuverwenden. Dies vermeidet redundanten Setup-Code in jedem Testfall.

            describe('Authenticated API Tests', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Einen persistenten Agenten erstellen
    // Authentifizierung simulieren
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('can access a protected resource', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('can perform other actions that require authentication', async () => {
    // Führen Sie hier andere authentifizierte Aktionen aus
  });
});
            

              
                Copy
              
            
          

In diesem Beispiel erstellen wir einen Supertest-Agenten im beforeAll-Hook und authentifizieren den Agenten. Nachfolgende Tests innerhalb des describe-Blocks können diesen authentifizierten Agenten dann wiederverwenden, ohne sich für jeden Test erneut authentifizieren zu müssen.

Best Practices für API-Integrationstests mit Supertest

Um effektive API-Integrationstests zu gewährleisten, beachten Sie die folgenden Best Practices:

• Testen Sie End-to-End-Workflows: Konzentrieren Sie sich auf das Testen vollständiger Benutzer-Workflows anstatt isolierter API-Endpunkte. Dies hilft, Integrationsprobleme zu identifizieren, die beim isolierten Testen einzelner APIs möglicherweise nicht offensichtlich sind.
• Verwenden Sie realistische Daten: Verwenden Sie realistische Daten in Ihren Tests, um reale Szenarien zu simulieren. Dies umfasst die Verwendung gültiger Datenformate, Grenzwert-Tests und potenziell ungültiger Daten, um die Fehlerbehandlung zu testen.
• Isolieren Sie Ihre Tests: Stellen Sie sicher, dass Ihre Tests voneinander unabhängig sind und nicht auf einem gemeinsamen Zustand basieren. Dies macht Ihre Tests zuverlässiger und einfacher zu debuggen. Erwägen Sie die Verwendung einer dedizierten Testdatenbank oder das Mocking externer Abhängigkeiten.
• Mocken Sie externe Abhängigkeiten: Verwenden Sie Mocking, um Ihre API von externen Abhängigkeiten wie Datenbanken, Drittanbieter-APIs oder anderen Diensten zu isolieren. Dies macht Ihre Tests schneller und zuverlässiger und ermöglicht es Ihnen auch, verschiedene Szenarien zu testen, ohne auf die Verfügbarkeit externer Dienste angewiesen zu sein. Bibliotheken wie nock sind nützlich zum Mocking von HTTP-Anfragen.
• Schreiben Sie umfassende Tests: Streben Sie eine umfassende Testabdeckung an, einschließlich positiver Tests (Überprüfung erfolgreicher Antworten), negativer Tests (Überprüfung der Fehlerbehandlung) und Grenzwert-Tests (Überprüfung von Randfällen).
• Automatisieren Sie Ihre Tests: Integrieren Sie Ihre API-Integrationstests in Ihre Continuous Integration (CI)-Pipeline, um sicherzustellen, dass sie bei jeder Änderung am Code automatisch ausgeführt werden. Dies hilft, Integrationsprobleme frühzeitig zu erkennen und zu verhindern, dass sie in die Produktion gelangen.
• Dokumentieren Sie Ihre Tests: Dokumentieren Sie Ihre API-Integrationstests klar und prägnant. Dies erleichtert es anderen Entwicklern, den Zweck der Tests zu verstehen und sie im Laufe der Zeit zu warten.
• Verwenden Sie Umgebungsvariablen: Speichern Sie sensible Informationen wie API-Schlüssel, Datenbankpasswörter und andere Konfigurationswerte in Umgebungsvariablen, anstatt sie in Ihren Tests fest zu codieren. Dies macht Ihre Tests sicherer und einfacher für verschiedene Umgebungen zu konfigurieren.
• Berücksichtigen Sie API-Verträge: Nutzen Sie API-Vertragstests (Contract Testing), um zu validieren, dass Ihre API einem definierten Vertrag (z. B. OpenAPI/Swagger) entspricht. Dies hilft, die Kompatibilität zwischen verschiedenen Diensten sicherzustellen und Breaking Changes zu verhindern. Werkzeuge wie Pact können für Vertragstests verwendet werden.

Häufige Fehler, die es zu vermeiden gilt

• Tests nicht isolieren: Tests sollten unabhängig sein. Vermeiden Sie es, sich auf das Ergebnis anderer Tests zu verlassen.
• Implementierungsdetails testen: Konzentrieren Sie sich auf das Verhalten und den Vertrag der API, nicht auf ihre interne Implementierung.
• Fehlerbehandlung ignorieren: Testen Sie gründlich, wie Ihre API mit ungültigen Eingaben, Randfällen und unerwarteten Fehlern umgeht.
• Authentifizierungs- und Autorisierungstests überspringen: Stellen Sie sicher, dass die Sicherheitsmechanismen Ihrer API ordnungsgemäß getestet werden, um unbefugten Zugriff zu verhindern.

Fazit

API-Integrationstests sind ein wesentlicher Bestandteil des Softwareentwicklungsprozesses. Mit Supertest können Sie einfach umfassende und zuverlässige API-Integrationstests schreiben, die dazu beitragen, die Qualität und Stabilität Ihrer Anwendung sicherzustellen. Denken Sie daran, sich auf das Testen von End-to-End-Workflows zu konzentrieren, realistische Daten zu verwenden, Ihre Tests zu isolieren und Ihren Testprozess zu automatisieren. Durch die Befolgung dieser Best Practices können Sie das Risiko von Integrationsproblemen erheblich reduzieren und ein robusteres und zuverlässigeres Produkt liefern.

Da APIs weiterhin moderne Anwendungen und Microservices-Architekturen antreiben, wird die Bedeutung robuster API-Tests, insbesondere von Integrationstests, nur noch zunehmen. Supertest bietet Entwicklern weltweit ein leistungsstarkes und zugängliches Werkzeugset, um die Zuverlässigkeit und Qualität ihrer API-Interaktionen zu gewährleisten.