Testen in JavaScript: Unit, Integration, E2E von A bis Z

Testen in JavaScript: Unit, Integration, E2E — von A bis Z

Die Entwicklung moderner Webanwendungen in JavaScript (insbesondere mit Node.js) ist ohne qualitativ hochwertiges Testen nicht möglich. Tests fangen nicht nur Fehler ab, bevor sie in die Produktion gelangen, sondern dienen auch als lebendige Dokumentation und ermöglichen es, Code ohne Angst vor Beschädigungen zu refaktorieren. In diesem Artikel werden wir die drei Hauptebenen der Testpyramide behandeln: Unit (Modultests), Integration (Integrationstests) und E2E (End-to-End-Tests). Sie erfahren, wie sie sich unterscheiden, welche Werkzeuge verwendet werden und sehen fertige Beispiele mit Node.js.

1. Unit-Tests: Isolierte Module testen

Unit-Tests sind das Fundament der Pyramide. Sie überprüfen die Arbeit einzelner Funktionen, Klassen oder Komponenten in vollständiger Isolation von externen Abhängigkeiten (DB, API, Dateisystem). Das Hauptziel ist sicherzustellen, dass die Logik des Moduls bei beliebigen Eingabedaten korrekt funktioniert.

Für Node.js ist das beliebteste Framework Jest (von Facebook). Es erfordert keine komplexe Konfiguration, verfügt über integrierte Assertions, Mocks und Codeabdeckung.

Beispiel: Testen einer Array-Sortierfunktion

// utils.jsfunction sortNumbers(arr) {  if (!Array.isArray(arr)) {    throw new Error('Input must be an array');  }  return [...arr].sort((a, b) => a - b);}

module.exports = { sortNumbers };

// utils.test.jsconst { sortNumbers } = require('./utils');

describe('sortNumbers', () => {  test('should sort an array of numbers in ascending order', () => {    expect(sortNumbers([3, 1, 2])).toEqual([1, 2, 3]);  });

  test('should handle an empty array', () => {    expect(sortNumbers([])).toEqual([]);  });

  test('should throw error for non-array input', () => {    expect(() => sortNumbers('string')).toThrow('Input must be an array');  });});

Best Practices für Unit-Tests:

• Ein Test — eine Überprüfung (ein Assert).
• Verwenden Sie describe zur Gruppierung von Tests nach Funktionen.
• Mocken Sie externe Abhängigkeiten (mit jest.mock()).
• Schreiben Sie Tests vor dem Code (TDD — Test-Driven Development).

2. Integrationstests: Überprüfung der Komponenteninteraktion

Integrationstests überprüfen, wie verschiedene Module des Systems zusammenarbeiten. Zum Beispiel, wie Ihr Controller mit der Datenbank oder einer externen API interagiert. Im Gegensatz zu Unit-Tests mocken wir hier nicht alles, sondern verwenden reale (oder Test-)Umgebungen.

Zum Testen von HTTP-Servern mit Express eignet sich die Bibliothek Supertest in Kombination mit Jest hervorragend.

Beispiel: Testen eines REST-Endpunkts

// app.jsconst express = require('express');const app = express();

app.get('/api/hello', (req, res) => {  res.json({ message: 'Hello, World!' });});

app.post('/api/data', (req, res) => {  const { name } = req.body;  if (!name) {    return res.status(400).json({ error: 'Name is required' });  }  res.status(201).json({ received: name });});

module.exports = app;

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

describe('Integration tests for API', () => {  test('GET /api/hello should return a greeting', async () => {    const response = await request(app)      .get('/api/hello')      .expect(200);

    expect(response.body).toEqual({ message: 'Hello, World!' });  });

  test('POST /api/data with valid body should return 201', async () => {    const response = await request(app)      .post('/api/data')      .send({ name: 'Alice' })      .expect(201);

    expect(response.body).toEqual({ received: 'Alice' });  });

  test('POST /api/data without name should return 400', async () => {
```