API Testing: Unit, Integration und Contract Tests

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Zuverlässige APIs benötigen eine durchdachte Teststrategie, die Unit Tests, Integrationstests und Contract Tests kombiniert, um Fehler früh zu erkennen und Schnittstellenverträge zu schützen.

Kompakte Beschreibung

API Testing umfasst alle Testaktivitäten, die die Korrektheit, Sicherheit, Performance und Stabilität einer API sicherstellen. Unit Tests prüfen isolierte Funktionen, Controller oder Handler ohne externe Abhängigkeiten. Integrationstests überprüfen die Zusammenarbeit mehrerer Komponenten, wie API, Datenbank und externe Services. Contract Tests stellen sicher, dass Provider und Consumer einer API denselben Vertrag einhalten, beispielsweise durch OpenAPI oder Pact. Eine gute Teststrategie deckt die API auf verschiedenen Ebenen ab, ist automatisiert und läuft in der Continuous Integration Pipeline. Ziel ist es, Fehler früh zu finden, Regressionen zu vermeiden und den Vertrag zwischen API und Clients zuverlässig zu dokumentieren und zu schützen.

Wichtige Komponenten

Unit Tests für APIs

Unit Tests prüfen kleine, isolierte Einheiten der API, wie Handler, Controller, Validierungslogik oder Mapper. Externe Abhängigkeiten wie Datenbanken oder HTTP-Clients werden durch Mocks oder Stubs ersetzt. Unit Tests sind schnell und geben schnelles Feedback bei Änderungen.

Integrationstests

Integrationstests prüfen die Zusammenarbeit der API mit echten oder containerisierten Abhängigkeiten. Dazu gehören Datenbankzugriffe, Message Queues, externe APIs und Authentifizierungsdienste. Testcontainer ermöglichen es, Datenbanken oder andere Services in Testumgebungen zu starten.

End-to-End Tests

End-to-End Tests simulieren die API aus Kundensicht. Sie senden echte HTTP-Anfragen und prüfen die vollständige Response. Tools wie Postman, REST Assured oder Supertest werden häufig verwendet. E2E Tests sind langsamer, decken aber den gesamten Stack ab.

Contract Tests

Contract Tests prüfen, ob API und Client den vereinbarten Vertrag einhalten. Der Vertrag kann durch OpenAPI, JSON Schema oder Frameworks wie Pact definiert werden. Consumer Driven Contracts ermöglichen es, dass die Consumer ihre Erwartungen an den Provider kommunizieren.

Consumer Driven Contracts

Bei Consumer Driven Contracts schreiben die Clients ihre Erwartungen als Vertrag auf. Der Provider muss diesen Vertrag erfüllen. Pact ist ein beliebtes Framework für diesen Ansatz. Er verhindert, dass Änderungen der API unbemerkt Clients zerstören.

Testpyramide

Die Testpyramide besagt, dass Du viele schnelle Unit Tests, weniger Integrationstests und nur wenige langsame E2E Tests haben solltest. Contract Tests ergänzen die Pyramide zwischen Integration und Unit Tests. Sie helfen, Schnittstellenverträge effizient zu prüfen.

Testdaten und Fixtures

Testdaten sollten reproduzierbar und isoliert sein. Fixtures, Factories oder Setup-Methoden erzeugen die benötigten Daten vor jedem Test. Datenbanktests sollten Transaktionen oder frische Datenbanken nutzen, um Zustände zwischen Tests zu isolieren.

Mocking und Stubbing

Mocking ersetzt externe Abhängigkeiten durch kontrollierte Objekte. Stubbing liefert vordefinierte Antworten. Beide Techniken sind wichtig für Unit Tests, aber nicht für Integrationstests, wo echte Abhängigkeiten genutzt werden.

Fuzzing und Negative Tests

Negative Tests prüfen, wie die API mit ungültigen Eingaben, fehlenden Feldern oder unerwarteten Datentypen umgeht. Fuzzing erzeugt automatisch viele zufällige oder semi-zufällige Eingaben, um Schwachstellen zu finden.

Performance Tests

Performance Tests prüfen Antwortzeiten, Durchsatz und Verhalten unter Last. Tools wie k6, JMeter oder Gatling werden eingesetzt. Sie ergänzen funktionale Tests und sind wichtig für APIs mit hohen Anforderungen an Verfügbarkeit und Skalierung.

CI/CD Integration

API-Tests sollten in der Continuous Integration Pipeline automatisch ausgeführt werden. Unit Tests laufen bei jedem Build, Integrationstests vor dem Merge, Contract Tests bei API-Änderungen und E2E Tests vor dem Deployment. Fehler stoppen den Build frühzeitig.

Praxisbeispiel

Ein Node.js Team testet eine Bestell-API auf allen Ebenen.

Unit Test für die Validierung einer Bestellung:

describe('Order validation', () => {
  test('rejects negative quantity', () => {
    const result = validateOrder({ customerId: 1, items: [{ productId: 5, quantity: -1 }] });
    expect(result.valid).toBe(false);
    expect(result.errors).toContain('quantity must be positive');
  });
});

Integrationstest mit Testcontainer:

describe('POST /orders', () => {
  test('creates an order and persists it', async () => {
    const response = await request(app)
      .post('/orders')
      .send({ customerId: 1, items: [{ productId: 5, quantity: 2 }] })
      .expect(201);

    expect(response.body.id).toBeDefined();
    expect(response.body.status).toBe('created');

    const order = await db.query('SELECT * FROM orders WHERE id = ?', [response.body.id]);
    expect(order).toHaveLength(1);
  });
});

Contract Test mit Pact:

const pact = new Pact({
  consumer: 'web-shop',
  provider: 'order-service',
});

await pact.addInteraction({
  state: 'order can be created',
  uponReceiving: 'a request to create an order',
  withRequest: {
    method: 'POST',
    path: '/orders',
    body: { customerId: 1, items: [{ productId: 5, quantity: 2 }] }
  },
  willRespondWith: {
    status: 201,
    body: { id: 1, status: 'created' }
  }
});

Durch die Kombination der drei Ebenen wird die API früh und umfassend getestet.

IRC-Security.de

Cybersecurity Artikel und Tutorials

FAQ: API Testing

Quellen

1. https://martinfowler.com/articles/consumerDrivenContracts.html
2. https://docs.pact.io/
3. https://www.testcontainers.org/

Buchempfehlungen zum Testen und API Design

Wenn Du Dich weiter mit API Testing, Testautomatisierung und Softwarequalität beschäftigen möchtest, empfehlen wir Dir die folgenden Bücher:

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert