Wie testet man Django-Anwendungen?

Question

Accepted Answer

Django enthält ein **integriertes Test-Framework** (das Pythons `unittest` erweitert) mit speziellen Tools für Webanwendungen — einen Test-Client zum Simulieren von Anfragen, ein Fixtures-/Datenbanksystem, das eine isolierte Test-Datenbank erstellt, und Helfer zum Testen von Models, Views und Forms.

## Ein einfacher Test-Fall

```python
from django.test import TestCase

class ArticleModelTest(TestCase):
    def setUp(self):
        # runs before each test; data created here is rolled back after
        self.article = Article.objects.create(title="Test", body="...")

def test_str(self):
        self.assertEqual(str(self.article), "Test")

def test_default_published(self):
        self.assertFalse(self.article.published)
```

`TestCase` umhüllt jeden Test in eine **Datenbanktransaktion, die danach zurückgerollt wird**, sodass Tests isoliert sind und sich nicht gegenseitig beeinflussen — und es verwendet eine **separate Test-Datenbank** (wird automatisch erstellt/gelöscht), niemals Ihre echten Daten.

## Views mit dem Test-Client testen

```python
class ArticleViewTest(TestCase):
    def test_list_view(self):
        Article.objects.create(title="Hello")
        response = self.client.get("/articles/")        # simulate a GET request
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, "Hello")           # the title appears in the HTML

def test_create_requires_login(self):
        response = self.client.post("/articles/create/", {"title": "X"})
        self.assertEqual(response.status_code, 302)      # redirected to login

def test_authenticated_create(self):
        self.client.login(username="ann", password="pw")  # log in for the test
        response = self.client.post("/articles/create/", {"title": "New", "body": "..."})
        self.assertEqual(Article.objects.count(), 1)
```

Der **Test-Client** simuliert HTTP-Anfragen an Ihre Views (GET/POST, mit Login, Sessions usw.) ohne einen laufenden Server — und ermöglicht es Ihnen, den gesamten Request/Response-Flow, Status-Codes und dargestellte Inhalte zu testen.

## Testing von DRF APIs

```python
from rest_framework.test import APITestCase

class ArticleAPITest(APITestCase):
    def test_create_article(self):
        response = self.client.post("/api/articles/", {"title": "X", "body": "..."}, format="json")
        self.assertEqual(response.status_code, 201)
        self.assertEqual(response.data["title"], "X")
```

## Nützliche Tools und bewährte Praktiken

```text
✓ setUpTestData — create shared read-only data ONCE per class (faster than setUp)
✓ Factories (factory_boy) — generate test data cleanly instead of manual creation
✓ pytest-django — many teams prefer pytest's cleaner syntax over unittest
✓ Coverage.py — measure test coverage
✓ Mock external services (APIs, email) so tests are fast and deterministic
✓ Run: python manage.py test  (or pytest)
```

## Was zu testen ist

```text
Models → custom methods, validation, properties
Views  → status codes, correct data, permissions/auth, form handling
Forms/Serializers → validation logic (valid + invalid cases)
Business logic → the core domain rules
```

## Warum es wichtig ist

Testing ist unerlässlich für die Erstellung zuverlässiger, wartbarer Django-Anwendungen, und Djangos integriertes Test-Framework — speziell für Webanwendungen zugeschnitten — macht es zugänglich und effektiv, daher ist das Verständnis dafür sowohl für Code-Qualität als auch als professioneller Standard wichtig.

Das Framework bietet web-spezifische Tools, die das Testen von Django-Apps praktisch machen: Der **Test-Client** simuliert HTTP-Anfragen an Views (mit GET/POST, Authentifizierung, Sessions), sodass Sie den gesamten Request/Response-Flow — Status-Codes, dargestellte Inhalte, Weiterleitungen, Berechtigungen — testen können, ohne einen Server zu benötigen. Das ist entscheidend, da Views der Ort sind, wo sich ein Großteil des Verhaltens einer App befindet.

Die **automatische Test-Datenbank** (wird frisch erstellt und danach zerstört, wobei jeder Test in einer zurückgerollten Transaktion läuft) stellt sicher, dass Tests isoliert sind und niemals echte Daten berühren, was sie sicher und wiederholbar macht.

Das Verständnis dafür, wie man die Schlüsselschichten testet — **Models** (benutzerdefinierte Methoden, Validierung), **Views** (Status-Codes, Daten, Auth/Berechtigungen, Form-Handling über den Test-Client), **Forms/Serializer** (Validierungslogik für gültige und ungültige Eingaben) und **Business-Logik** — deckt den praktischen Umfang des Testens einer Django-Anwendung ab. Das Wissen über Tools wie `APITestCase` für DRF APIs, `setUpTestData`/Factories für effiziente Test-Daten und das Mocking von externen Services für schnelle deterministische Tests zeigt reife Test-Praktiken.

Gut getestete Django-Anwendungen fangen Regressions auf, ermöglichen selbstbewusstes Refactoring und dokumentieren erwartetes Verhalten. Das web-bewusste Design des Frameworks (besonders der Test-Client und die Test-Datenbank) macht umfassendes Testing viel einfacher als eine eigene Implementierung.

Weil Testing grundlegend für professionelle Softwareentwicklung ist und Django hervorragende, auf seine Funktionen zugeschnittene Built-in-Unterstützung bietet, ist das Wissen, wie man effektive Tests über die Model/View/Form-Schichten hinweg schreibt, wichtig und häufig relevantes Wissen, das Entwickler, die robuste, wartbare Anwendungen erstellen, von denen unterscheidet, die fragile, ungetestete Code ausliefern.