Come si testano le applicazioni Django?

Question

Accepted Answer

Django include un **framework di testing integrato** (che estende `unittest` di Python) con strumenti progettati per applicazioni web — un client di test per simulare richieste, un sistema di fixture/database che crea un database di test isolato, e helper per testare modelli, view e form.

## Un caso di test base

```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` avvolge ogni test in una **transazione di database che viene sottoposta a rollback** successivamente, così i test sono isolati e non si inquinano reciprocamente — e utilizza un **database di test separato** (creato/distrutto automaticamente), mai i tuoi dati reali.

## Testing delle view con il client di test

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

Il **client di test** simula richieste HTTP alle tue view (GET/POST, con login, sessioni, ecc.) senza un server in esecuzione — permettendoti di testare l'intero flusso richiesta/risposta, i codici di stato e il contenuto renderizzato.

## Testing di API DRF

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

## Strumenti e pratiche utili

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

## Cosa testare

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

## Perché è importante

Il testing è essenziale per costruire applicazioni Django affidabili e manutenibili, e il framework di testing integrato di Django — progettato specificamente per applicazioni web — lo rende accessibile ed efficace, quindi comprenderlo è importante sia per la qualità del codice che come standard professionale.

Il framework fornisce strumenti specifici per il web che rendono il testing delle app Django pratico: il **client di test** simula richieste HTTP alle view (gestendo GET/POST, autenticazione, sessioni) così puoi testare l'intero flusso richiesta/risposta — codici di stato, contenuto renderizzato, redirect, permessi — senza un server in esecuzione, il che è cruciale poiché le view sono dove risiede gran parte del comportamento di un'app.

Il **database di test automatico** (creato da zero e distrutto dopo, con ogni test avvolto in una transazione sottoposta a rollback) assicura che i test siano isolati e non tocchino mai dati reali, rendendoli sicuri e ripetibili.

Comprendere come testare i layer chiave — **modelli** (metodi personalizzati, validazione), **view** (codici di stato, dati, autenticazione/permessi, gestione dei form tramite il client di test), **form/serializer** (logica di validazione per input validi e non validi), e **logica di business** — copre l'ambito pratico del testing di un'applicazione Django, e conoscere strumenti come `APITestCase` per le API DRF, `setUpTestData`/factory per dati di test efficienti, e mocking di servizi esterni per test veloci e deterministici riflette una pratica di testing matura.

Le applicazioni Django ben testate catturano regressioni, abilitano refactoring confidenziale, e documentano il comportamento atteso, mentre il design consapevole del web del framework (specialmente il client di test e il database di test) rende il testing approfondito molto più facile che implementare il tuo.

Poiché il testing è fondamentale per lo sviluppo software professionale e Django fornisce un eccellente supporto integrato adatto alle sue caratteristiche, sapere come scrivere test efficaci attraverso i layer modello/view/form è una conoscenza importante e frequentemente rilevante che distingue gli sviluppatori che costruiscono applicazioni robuste e manutenibili da quelli che distribuiscono codice fragile e non testato.