Kaip testuoti Django programas?

Question

Accepted Answer

Django apima **įtaisytą testavimo sistemą** (plečiančią Python `unittest`), suskirtą specifiškai žiniatinklio programoms — bandymo klientą HTTP užklausoms imituoti, pritvirtintų duomenų/duomenų bazės sistemą izoliuotai bandymų duomenų bazei kurti, ir pagelbininkus modeliams, puslapiams (views) ir formoms testuoti.

## Pagrindinis bandymo atvejis

```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` supakuoja kiekvieną bandymą **duomenų bazės transakcijoje, kuri vėliau atšaukiama**, todėl bandymai yra izoliuoti ir neatsklepia vieni kitus — ir jis naudoja **atskirą bandymų duomenų bazę** (automatiškai sukurtą/sunaikintą), niekada tavo tikrųjų duomenų.

## Puslapių (views) testavimas su bandymo klientu

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

**Bandymo klientas** imituoja HTTP užklausas tavo puslapiams (GET/POST, su prisijungimu, seansais ir t.t.) be veikiančio serverio — leidžiant tau testuoti pilną užklausos/atsakymo eigą, būsenos kodus ir atvaizduotą turinį.

## DRF API testavimas

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

## Naudingi įrankiai ir praktikos

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

## Ką testuoti

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

## Kodėl tai svarbu

Testavimas yra būtinas kuriant patikimas, lengvai priežiūrimas Django programas, o Django įtaisyta testavimo sistema — pritaikyta specifiškai žiniatinklio programoms — daro tai prieinama ir veiksminga, todėl jos supratimas yra svarbus tiek kodo kokybei, tiek kaip profesionalus standartas.

Sistema suteikia žiniatinklo-specifnius įrankius, kurie daro Django programų testavimą praktiška: **bandymo klientas** imituoja HTTP užklausas puslapiams (tvarko GET/POST, autentifikaciją, seansus), todėl gali testuoti pilną užklausos/atsakymo eigą — būsenos kodus, atvaizduotą turinį, nukreipimus, leidimus — be veikiančio serverio, kas yra labai svarbu, nes puslapiai — tai vieta, kurioje gyvena daug programos elgesio.

**Automatinė bandymų duomenų bazė** (sukurta iš naujo ir sunaikinta po to, kiekvienas bandymas apsuptytas atšaukta transakcija) užtikrina, kad bandymai yra izoliuoti ir niekada neliečia tikrųjų duomenų, todėl jie yra saugūs ir kartojami.

Supratimas, kaip testuoti pagrindinius sluoksnius — **modelius** (pasirinktiniai metodai, validavimas), **puslapius** (būsenos kodai, duomenys, autentifikacija/leidimai, formos tvarkymas per bandymo klientą), **formas/serializatorius** (validavimo logika tiek galimiems, tiek negalumiems įvestimams), ir **verslo logiką** — apima praktikinį Django programos testavimo taikymo sritį, ir žinant įrankius kaip `APITestCase` DRF API, `setUpTestData`/gamyklas efektyviai kurti bandymų duomenis, ir nuo išorinių servisų nusisukti greitų deterministinių bandymų, atspindi brandžią testavimo praktiką.

Gerai testuotos Django programos sugaudo regresijas, leidžia pasitiklingai refaktorinti, ir dokumentuoja laukiamą elgesį, o sistemos žiniatinklo-suvokiantis dizainas (ypač bandymo klientas ir bandymų duomenų bazė) daro nuodugnų testavimą daug lengvesniu nei kurti savo.

Nes testavimas yra pagrindinis profesionalaus programinės įrangos kūrimo elementas ir Django suteikia puikų įtaisytą palaikymą, pritaikytą jo savybėms, žinojimas, kaip rašyti veiksmingus bandymus skersai modelio/puslapio/formos sluoksnių yra svarbi, dažnai aktuali žinias, kuri atskiria kūrėjus, kurie laido tvirius, lengvai priežiūrimas programas, nuo tų, kurie paleidžia trapias, netestuotas programas.