Lektionen
Start
Jetzt lernen
CodeGym /Kurse /Docker SELF /Testen und Debuggen von Anwendungen

Testen und Debuggen von Anwendungen

Docker SELF
Level 24 , Lektion 2
Verfügbar

8.1 Frontend-Testing

In diesem Abschnitt schauen wir uns an, wie wir unser Multi-Container-Anwendung testen und debuggen können. Testing hilft uns, Fehler zu finden und zu beheben, und sicherzustellen, dass alle Systemkomponenten korrekt funktionieren.

Für das Testen des Frontends auf ReactJS verwenden wir die Bibliotheken Jest und React Testing Library.

Installation von Jest und React Testing Library

Schritt 1. Abhängigkeiten installieren:

Terminal 

cd frontend
npm install --save-dev jest @testing-library/react @testing-library/jest-dom

Schritt 2. Jest konfigurieren:

Erstelle die Datei jest.config.js im Verzeichnis frontend:

Javascript 

module.exports = {
  setupFilesAfterEnv: ['<rootDir>/src/setupTests.js'],
  testEnvironment: 'jsdom',
};

Schritt 3. Datei setupTests.js erstellen:

Erstelle die Datei setupTests.js im Verzeichnis frontend/src:

Javascript 

import '@testing-library/jest-dom/extend-expect';

Schritt 4. Tests für Komponenten schreiben

Erstelle eine Testdatei für die Komponente TaskList im Verzeichnis frontend/src:

Javascript 

import React from 'react';
import { render, screen } from '@testing-library/react';
import TaskList from './TaskList';

test('renders Task List heading', () => {
  render(<TaskList />);
  const headingElement = screen.getByText(/Task List/i);
  expect(headingElement).toBeInTheDocument();
});
Java university

Schritt 5. Tests ausführen

Um die Tests auszuführen, verwende den Befehl:

Terminal 

npm test

8.2 Testen des Backends

Zum Testen des Backends mit Flask verwenden wir die Bibliothek unittest.

Installation der Abhängigkeiten:

Terminal 

cd ../backend
pip install Flask-Testing

Schreiben von Tests für Endpoints

Erstelle ein Verzeichnis tests und eine Datei test_routes.py im Verzeichnis backend:

Python 

import unittest
from app import app, db
from app.models import User, Task

class BasicTests(unittest.TestCase):

    def setUp(self):
        app.config['TESTING'] = True
        app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
        self.app = app.test_client()
        db.create_all()

    def tearDown(self):
        db.session.remove()
        db.drop_all()

    def test_user_registration(self):
        response = self.app.post('/register', json={
            'username': 'testuser',
            'password': 'testpassword'
        })
        self.assertEqual(response.status_code, 201)

    def test_task_creation(self):
        self.app.post('/register', json={
            'username': 'testuser',
            'password': 'testpassword'
        })
        access_token = self.app.post('/login', json={
            'username': 'testuser',
            'password': 'testpassword'
        }).json['access_token']

        response = self.app.post('/tasks', json={
            'title': 'Testaufgabe',
            'description': 'Testbeschreibung',
            'owner_id': 1,
            'status': 'nicht erledigt'
        }, headers={'Authorization': f'Bearer {access_token}'})
        self.assertEqual(response.status_code, 201)

if __name__ == "__main__":
    unittest.main()

Tests ausführen

Zum Ausführen der Tests benutze den Befehl:

Terminal 

python -m unittest discover

8.3 Integrationstests

Integrationstests überprüfen die Interaktion zwischen den Komponenten des Systems.

Einrichten einer Testumgebung

Für Integrationstests verwenden wir Docker Compose, um alle Services in einer Testumgebung hochzufahren.

Schritt 1. Erstellen einer Docker Compose Datei für Tests:

Erstelle die Datei docker-compose.test.yml im Root-Verzeichnis des Projekts:

Yaml 

version: '3'

services:
  frontend:
    build: ./frontend
    ports:
      - "3001:3000"
    networks:
      - task-network

  backend:
    build: ./backend
    ports:
      - "5001:5000"
    depends_on:
      - database
    networks:
      - task-network
    environment:
      - DATABASE_URL=postgresql://taskuser:taskpassword@database:5432/taskdb

  database:
    image: postgres:13
    environment:
      - POSTGRES_DB=taskdb
      - POSTGRES_USER=taskuser
      - POSTGRES_PASSWORD=taskpassword
    networks:
      - task-network
    volumes:
      - db-data:/var/lib/postgresql/data

networks:
  task-network:
    driver: bridge

volumes:
  db-data:

Schritt 2. Starten der Testumgebung:

Nutze den folgenden Befehl, um alle Services in der Testumgebung zu starten:

Terminal 

docker compose -f docker-compose.test.yml up --build

Schreiben von Integrationstests

Integrationstests können mit verschiedenen Tools geschrieben werden. Ein Ansatz besteht darin, Selenium für automatisierte UI-Tests zu verwenden.

Schritt 1. Installation von Selenium:

Terminal 

pip install selenium

Schritt 2. Schreiben eines Integrationstests:

Erstelle die Datei test_integration.py im Verzeichnis tests:

Python 

from selenium import webdriver
from selenium.webdriver.common.keys import Keys

def test_frontend():
    driver = webdriver.Chrome()
    driver.get("http://localhost:3001")
    assert "Task Liste" in driver.title
    driver.close()

if __name__ == "__main__":
    test_frontend()

Schritt 3. Starten eines Integrationstests:

Verwende den folgenden Befehl, um den Integrationstest auszuführen:

Terminal 

python tests/test_integration.py

8.4 Debuggen

Für Debugging kannst du Container-Logs und Monitoring-Tools nutzen.

Container-Logs ansehen

Um die Logs anzusehen, benutze den Befehl:

Terminal 

docker compose logs

Verwendung von Monitoring-Tools

Nutze die zuvor eingerichteten Prometheus und Grafana, um Metriken und den Zustand von Services zu überwachen.

  1. Gehe zur Weboberfläche von Grafana: Öffne deinen Browser und gehe zu http://localhost:3033.
  2. Schau dir die Dashboards an: Nutze die erstellten Dashboards, um die Performance und den Zustand der Services zu verfolgen.
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION