Jak testujete Django aplikace?

Question

Accepted Answer

Django zahrnuje **vestavěný testovací framework** (rozšiřující Python's `unittest`) s nástroji upravenými pro webové aplikace — testovacího klienta pro simulaci požadavků, systém fixtures/databáze, který vytváří izolovanou testovací databázi, a pomocné funkce pro testování modelů, views a formulářů.

## Základní testovací případ

```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` obaluje každý test v **databázové transakci, která se následně vrátí**, takže testy jsou izolované a navzájem se neovlivňují — a používá **samostatnou testovací databázi** (automaticky vytvořenou/zničenou), nikdy vaše skutečná data.

## Testování views s testovacím klientem

```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)
```

**Testovací klient** simuluje HTTP požadavky na vaše views (GET/POST, s přihlášením, relacemi atd.) bez běžícího serveru — umožňuje vám testovat celý tok požadavek/odpověď, stavové kódy a vykreslený obsah.

## Testování DRF API

```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")
```

## Užitečné nástroje a praktiky

```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)
```

## Co testovat

```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
```

## Proč na tom záleží

Testování je nezbytné pro vytváření spolehlivých a udržovatelných Django aplikací, a Django's vestavěný testovací framework — speciálně upravený pro webové aplikace — to činí přístupným a efektivním, takže jeho pochopení je důležité jak pro kvalitu kódu, tak jako profesionální standard.

Framework poskytuje webové nástroje, které činí testování Django aplikací praktickým: **testovací klient** simuluje HTTP požadavky na views (zpracovává GET/POST, ověřování, relace), aby jste mohli testovat celý tok požadavek/odpověď — stavové kódy, vykreslený obsah, přesměrování, oprávnění — bez běžícího serveru, což je klíčové, protože views jsou místem, kde se odehrává velká část chování aplikace.

**Automatická testovací databáze** (vytvořená čistě a zničená později, přičemž každý test je obalený rollback transakci) zajišťuje, že testy jsou izolované a nikdy se nedotýkají skutečných dat, což je činí bezpečnými a opakovatelnými.

Pochopení testování klíčových vrstev — **modelů** (vlastní metody, validace), **views** (stavové kódy, data, ověřování/oprávnění, zpracování formulářů přes testovacího klienta), **formulářů/serializérů** (logika validace pro platné a neplatné vstupy) a **obchodní logiky** — pokrývá praktický rozsah testování Django aplikace, a znalost nástrojů jako `APITestCase` pro DRF API, `setUpTestData`/factories pro efektivní testovací data a mockování externích služeb pro rychlé deterministické testy odráží vyzrálou testovací praxi.

Dobře otestované Django aplikace odchytávají regrese, umožňují sebevědomé refaktorování a dokumentují očekávané chování, přičemž design frameworku zaměřený na web (zvláště testovací klient a testovací databáze) činí důkladné testování mnohem snadnějším než vytváření vlastního řešení.

Protože testování je základem profesionálního vývoje software a Django poskytuje vynikající vestavěnou podporu přizpůsobenou svým funkcím, znalost psaní efektivních testů napříč vrstvami model/view/form je důležitá, často relevantní znalost, která rozlišuje vývojáře, kteří vytvářejí robustní, udržovatelné aplikace, od těch, kteří nasazují křehký, netestovaný kód.