Como você testa aplicações Django?

Question

Accepted Answer

Django inclui um **framework de testes integrado** (estendendo `unittest` do Python) com ferramentas adaptadas para aplicações web — um cliente de teste para simular requisições, um sistema de fixtures/banco de dados que cria um banco de dados de teste isolado, e helpers para testar models, views e formulários.

## Um caso de teste básico

```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` envolve cada teste em uma **transação de banco de dados que é revertida** depois, então os testes são isolados e não poluem uns aos outros — e usa um **banco de dados de teste separado** (criado/destruído automaticamente), nunca seus dados reais.

## Testando views com o cliente de teste

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

O **cliente de teste** simula requisições HTTP para suas views (GET/POST, com login, sessões, etc.) sem um servidor em execução — permitindo que você teste o fluxo completo de requisição/resposta, códigos de status e conteúdo renderizado.

## Testando APIs 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")
```

## Ferramentas e práticas úteis

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

## O que testar

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

## Por que isso importa

Testing é essencial para construir aplicações Django confiáveis e manteníveis, e o framework de testes integrado do Django — adaptado especificamente para aplicações web — torna isso acessível e eficaz, então entendê-lo é importante tanto para qualidade de código quanto como padrão profissional.

O framework fornece ferramentas específicas para web que tornam testar apps Django prático: o **cliente de teste** simula requisições HTTP para views (tratando GET/POST, autenticação, sessões) para que você possa testar o fluxo completo de requisição/resposta — códigos de status, conteúdo renderizado, redirecionamentos, permissões — sem um servidor em execução, o que é crucial já que views é onde muito do comportamento de um app vive.

O **banco de dados de teste automático** (criado novo e destruído depois, com cada teste envolvido em uma transação revertida) garante que testes sejam isolados e nunca toquem dados reais, tornando-os seguros e repetíveis.

Entender como testar as camadas-chave — **models** (métodos customizados, validação), **views** (códigos de status, dados, auth/permissões, manipulação de formulários via cliente de teste), **formulários/serializers** (lógica de validação para input válido e inválido), e **lógica de negócio** — cobre o escopo prático de testar uma aplicação Django, e conhecer ferramentas como `APITestCase` para APIs DRF, `setUpTestData`/factories para dados de teste eficientes, e mocking de serviços externos para testes rápidos e determinísticos reflete prática madura de testes.

Aplicações Django bem testadas capturam regressões, habilitam refatoração confiante e documentam comportamento esperado, enquanto o design ciente de web do framework (especialmente o cliente de teste e banco de dados de teste) torna testes profundos muito mais fáceis do que rolar o seu próprio.

Porque testing é fundamental para desenvolvimento de software profissional e Django fornece suporte integrado excelente adaptado para suas features, saber como escrever testes eficazes nas camadas model/view/form é conhecimento importante e frequentemente relevante que distingue desenvolvedores que constroem aplicações robustas e manteníveis daqueles que entregam código frágil e não testado.