Bagaimana Anda menguji aplikasi Django?

Question

Accepted Answer

Django menyediakan **kerangka kerja pengujian bawaan** (memperluas `unittest` Python) dengan alat yang disesuaikan untuk aplikasi web — klien pengujian untuk mensimulasikan permintaan, sistem fixtures/database yang membuat database pengujian terisolasi, dan pembantu untuk menguji model, views, dan form.

## Kasus uji dasar

```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` membungkus setiap pengujian dalam **transaksi database yang dibalikkan** setelahnya, sehingga pengujian terisolasi dan tidak saling mempengaruhi — dan menggunakan **database pengujian terpisah** (dibuat/dihancurkan secara otomatis), tidak pernah data nyata Anda.

## Menguji views dengan klien pengujian

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

**Klien pengujian** mensimulasikan permintaan HTTP ke views Anda (GET/POST, dengan login, session, dll) tanpa server yang berjalan — memungkinkan Anda menguji alur request/response lengkap, kode status, dan konten yang dirender.

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

## Alat dan praktik yang berguna

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

## Apa yang harus diuji

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

## Mengapa ini penting

Pengujian sangat penting untuk membangun aplikasi Django yang andal dan mudah dirawat, dan kerangka kerja pengujian bawaan Django — dirancang khusus untuk aplikasi web — membuatnya dapat diakses dan efektif, sehingga memahaminya penting baik untuk kualitas kode maupun sebagai standar profesional.

Kerangka kerja menyediakan alat khusus web yang membuat pengujian aplikasi Django praktis: **klien pengujian** mensimulasikan permintaan HTTP ke views (menangani GET/POST, autentikasi, session) sehingga Anda dapat menguji alur request/response lengkap — kode status, konten yang dirender, pengalihan, izin — tanpa server yang berjalan, yang penting karena views adalah tempat banyak perilaku aplikasi berada.

**Database pengujian otomatis** (dibuat baru dan dihancurkan setelahnya, dengan setiap pengujian dibungkus dalam transaksi yang dibalikkan) memastikan pengujian terisolasi dan tidak pernah menyentuh data nyata, membuatnya aman dan dapat diulang.

Memahami cara menguji lapisan-lapisan kunci — **model** (metode kustom, validasi), **views** (kode status, data, autentikasi/izin, penanganan form melalui klien pengujian), **form/serializer** (logika validasi untuk input yang valid dan tidak valid), dan **logika bisnis** — mencakup cakupan praktis pengujian aplikasi Django, dan mengetahui alat seperti `APITestCase` untuk API DRF, `setUpTestData`/factory untuk data pengujian yang efisien, dan mocking layanan eksternal untuk pengujian cepat dan deterministik mencerminkan praktik pengujian yang matang.

Aplikasi Django yang teruji dengan baik menangkap regresi, memungkinkan refactoring yang percaya diri, dan mendokumentasikan perilaku yang diharapkan, sementara desain web-aware framework (terutama klien pengujian dan database pengujian) membuat pengujian menyeluruh jauh lebih mudah daripada membuat milik Anda sendiri.

Karena pengujian adalah fondasi pengembangan perangkat lunak profesional dan Django menyediakan dukungan bawaan yang sangat baik yang disesuaikan dengan fitur-fiturnya, mengetahui cara menulis pengujian efektif di seluruh lapisan model/view/form adalah pengetahuan yang penting dan sering relevan yang membedakan pengembang yang membangun aplikasi yang kuat dan mudah dirawat dari mereka yang mengirim kode yang rapuh dan tidak teruji.