Kako testirate Django aplikacije?

Question

Accepted Answer

Django vključuje **vgrajeni testni okvir** (ki razširja Pythonov `unittest`) z orodji, prilagojenimi spletnim aplikacijam — testni odjemalec za simuliranje zahtevkov, sistem fikstur/podatkovne baze, ki ustvari izolirano testno podatkovno bazo, in pomočnike za testiranje modelov, pogledov in obrazcev.

## Osnovni primer testnega primera

```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` obdaja vsak test v **transakcijo podatkovne baze, ki se pozneje razveljavi**, zato so testi izolirani in se medsebojno ne onesnažijo — in uporablja **ločeno testno podatkovno bazo** (ki se samodejno ustvari/izbriše), nikoli vaših resničnih podatkov.

## Testiranje pogledov s testnim odjemalcem

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

**Testni odjemalec** simulira HTTP zahtevke na vaše poglede (GET/POST, z prijavo, sejami itd.) brez zagnanega strežnika — kar vam omogoča testiranje celotnega toka zahtevka/odgovora, kodov stanja in prikazanega vsebine.

## Testiranje DRF API-jev

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

## Koristna orodja in prakse

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

## Kaj testirati

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

## Zakaj je to pomembno

Testiranje je bistveno za gradnjo zanesljivih, vzdrževalnih Django aplikacij, in Django-jev vgrajeni testni okvir — posebej prirejen za spletne aplikacije — ga naredi dostopnega in učinkovitega, zato je razumevanje tega pomembno tako za kakovost kode kot za strokovni standard.

Okvir zagotavlja spletno-specifična orodja, ki naredijo testiranje Django aplikacij praktično: **testni odjemalec** simulira HTTP zahtevke na poglede (obdelava GET/POST, avtentifikacije, sej), zato lahko testirate celoten tok zahtevka/odgovora — kode stanja, prikazano vsebino, preusmeritve, dovoljenja — brez zagnanega strežnika, kar je ključno, ker je v pogledih večina vedenja aplikacije.

**Avtomatska testna podatkovna baza** (ustvarjena sveža in uničena po zaključku, pri čemer je vsak test obdan z razveljavljeno transakcijo) zagotavlja, da so testi izolirani in nikoli ne dotaknejo resničnih podatkov, kar jih naredi varne in ponovljive.

Razumevanje, kako testirati ključne sloje — **modele** (lastne metode, validacija), **poglede** (kode stanja, podatke, avtentifikacijo/dovoljenja, obdelavo obrazcev prek testnega odjemalca), **obrazce/serializerje** (logiko validacije za veljavne in neveljavne vnose) in **poslovno logiko** — pokriva praktičen obseg testiranja Django aplikacije, in poznavanje orodij, kot so `APITestCase` za DRF API-je, `setUpTestData`/tovarne za učinkovito testne podatke in mocking zunanjih storitev za hitre determinističke teste, odraža zrelo testno prakso.

Dobro testirane Django aplikacije prestrežejo regresije, omogočajo samozavestno refaktoriranje in dokumentirajo pričakovano vedenje, medtem ko je spletno-zavedni dizajn ogrodja (še posebej testni odjemalec in testna podatkovna baza) naredi temeljito testiranje veliko lažje kot zvijanje svojega.

Ker je testiranje temeljno za profesionalen razvoj programske opreme in Django zagotavlja odličko vgrajeno podporo, prilagojeno njegovim funkcijam, je znanje, kako napisati učinkovite teste prek slojev model/pogled/obrazec, pomembno, pogosto relevantno znanje, ki loči razvijalce, ki gradijo robustne, vzdrževalne aplikacije, od tistih, ki pošljejo krhke, netestirane kode.