आप Django applications को कैसे test करते हैं?

Question

Accepted Answer

Django में एक **built-in testing framework** शामिल है (Python के `unittest` को extend करते हुए) जिसमें web applications के लिए विशेष रूप से तैयार किए गए tools हैं — requests को simulate करने के लिए एक test client, एक fixtures/database system जो एक isolated test database बनाता है, और models, views, और forms को test करने के लिए helpers।

## एक basic test case

```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` प्रत्येक test को एक **database transaction में wrap करता है जो बाद में rolled back हो जाता है**, इसलिए tests isolated रहते हैं और एक-दूसरे को प्रदूषित नहीं करते — और यह एक **अलग test database** का उपयोग करता है (स्वचालित रूप से बनाया/नष्ट किया गया), कभी आपके real data का नहीं।

## test client के साथ views को 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)
```

**test client** बिना एक running server के आपके views को HTTP requests (GET/POST, login, sessions, आदि के साथ) simulate करता है — आपको पूरे request/response flow, status codes, और rendered content को test करने देता है।

## DRF APIs को test करना

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

## उपयोगी tools और practices

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

## क्या test करें

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

## यह क्यों महत्वपूर्ण है

Testing reliable, maintainable Django applications बनाने के लिए आवश्यक है, और Django का built-in testing framework — विशेष रूप से web applications के लिए तैयार किया गया — इसे सुलभ और प्रभावी बनाता है, इसलिए इसे समझना code quality और एक professional standard दोनों के लिए महत्वपूर्ण है।

Framework web-specific tools प्रदान करता है जो Django apps को test करना व्यावहारिक बनाते हैं: **test client** views को HTTP requests simulate करता है (GET/POST, authentication, sessions को handle करते हुए) ताकि आप पूरे request/response flow को test कर सकें — status codes, rendered content, redirects, permissions — बिना एक running server के, जो महत्वपूर्ण है क्योंकि views वह जगह हैं जहां एक app का अधिकांश behavior रहता है।

**automatic test database** (fresh बनाया गया और बाद में नष्ट किया गया, प्रत्येक test एक rolled-back transaction में wrap किया गया) यह सुनिश्चित करता है कि tests isolated रहें और कभी real data को न छुएं, उन्हें सुरक्षित और repeatable बनाते हुए।

मुख्य layers को कैसे test करें यह समझना — **models** (custom methods, validation), **views** (status codes, data, auth/permissions, test client के माध्यम से form handling), **forms/serializers** (valid और invalid दोनों input के लिए validation logic), और **business logic** — एक Django application को test करने के व्यावहारिक दायरे को कवर करता है, और DRF APIs के लिए `APITestCase`, कुशल test data के लिए `setUpTestData`/factories, और fast deterministic tests के लिए external services को mock करने जैसे tools को जानना परिपक्व testing practice को दर्शाता है।

Well-tested Django applications regressions को पकड़ती हैं, confident refactoring को सक्षम करती हैं, और expected behavior को document करती हैं, जबकि framework का web-aware design (विशेष रूप से test client और test database) thorough testing को अपना खुद का बनाने की तुलना में बहुत आसान बनाता है।

क्योंकि testing professional software development के लिए मौलिक है और Django अपनी features के लिए तैयार किए गए excellent built-in support प्रदान करता है, model/view/form layers में प्रभावी tests लिखना जानना महत्वपूर्ण, अक्सर प्रासंगिक ज्ञान है जो उन developers को अलग करता है जो robust, maintainable applications बनाते हैं उनसे जो नाजुक, untested code ship करते हैं।