તમે Django એપ્લિકેશનને કેવી રીતે ટેસ્ટ કરો છો?

Question

Accepted Answer

Django એક **બિલ્ટ-ઇન ટેસ્ટિંગ ફ્રેમવર્ક** (Python ના `unittest` ને વિસ્તૃત કર્યું) ને અન્તર્ભૂત કરે છે જે વેબ એપ્લિકેશનમાં ખાસ ટૂલ્સ સાથે આવે છે — વિનંતીઓનું સિમ્યુલેટ કરવા માટે એક ટેસ્ટ ક્લાયન્ટ, એક ફિક્સચર/ડેટાબેસ સિસ્ટમ જે એક અલગ ટેસ્ટ ડેટાબેસ બનાવે છે, અને મોડલ્સ, વ્યુઝ અને ફોર્મ્સને ટેસ્ટ કરવા માટે સહાયક.

## એક મૂળભૂત ટેસ્ટ કેસ

```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` દરેક ટેસ્ટને એક **ડેટાબેસ ટ્રાન્ઝેક્શનમાં પછીથી રોલ બેક** કરવામાં આવે તે રીતે લપેટે છે, તેથી ટેસ્ટ્સ અલગ રહે છે અને એક બીજાને દૂષિત કરતા નથી — અને તે એક **અલગ ટેસ્ટ ડેટાબેસ** (આપોઆપ બનાવવામાં આવે અને નાશ કરવામાં આવે) વાપરે છે, ક્યારેય તમારો વાસ્તવિક ડેટા નહીં.

## ટેસ્ટ ક્લાયન્ટ સાથે વ્યુઝને ટેસ્ટ કરવું

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

**ટેસ્ટ ક્લાયન્ટ** તમારા વ્યુઝને HTTP વિનંતીઓ (GET/POST, લોગિન, સેશન્સ વગેરે) સાથે સિમ્યુલેટ કરે છે — તે ચાલી રહેલ સર્વર વિના તમને સંપૂર્ણ વિનંતી/પ્રતિક્રિયા પ્રવાહ, સ્ટેટસ કોડ્સ અને પ્રસ્તુત સમગ્રી ટેસ્ટ કરવા દે છે.

## DRF APIs ને ટેસ્ટ કરવું

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

## ઉપયોગી ટૂલ્સ અને પ્રણાલીઓ

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

## શું ટેસ્ટ કરવું

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

## શા માટે આ મહત્તવપૂર્ણ છે

ટેસ્ટિંગ વિશ્વસનીય, જાળવણીયોગ્ય Django એપ્લિકેશનો બનાવવા માટે આવશ્યક છે, અને Django નું બિલ્ટ-ઇન ટેસ્ટિંગ ફ્રેમવર્ક — વેબ એપ્લિકેશનો માટે ખાસ રીતે ડિઝાઇન કરેલ — તેને સુલભ અને અસરકારક બનાવે છે, તેથી તેને સમજવું કોડ ગુણવત્તા અને પ્રોફેશનલ ધોરણ બંને માટે મહત્તવપૂર્ણ છે.

ફ્રેમવર્ક વેબ-ચોક્કસ ટૂલ્સ પ્રદાન કરે છે જે Django એપ્લિકેશનો ટેસ્ટ કરવાનું વ્યવહારુ બનાવે છે: **ટેસ્ટ ક્લાયન્ટ** વ્યુઝને HTTP વિનંતીઓ સાથે સિમ્યુલેટ કરે છે (GET/POST, પ્રમાણીકરણ, સેશન્સ હેન્ડલ કરે છે) તેથી તમે સંપૂર્ણ વિનંતી/પ્રતિક્રિયા પ્રવાહ — સ્ટેટસ કોડ્સ, પ્રસ્તુત સમગ્રી, રીડાયરેક્ટ્સ, અનુમતિઓ — ટેસ્ટ કરી શકો છો ચાલી રહેલ સર્વર વિના, જે મહત્તવપૂર્ણ છે કારણ કે વ્યુઝ છે જ્યાં એપ્લિકેશનનું ઘણું વર્તન રહે છે.

**આપોઆપ ટેસ્ટ ડેટાબેસ** (તાજું બનાવવામાં આવે અને પછીથી નાશ કરવામાં આવે, દરેક ટેસ્ટ રોલ-બેક ટ્રાન્ઝેક્શનમાં હોય) ટેસ્ટ્સને અલગ નિશ્ચિત કરે છે અને ક્યારેય વાસ્તવિક ડેટા ને સ્પર્શ કરતા નથી, તેમને સુરક્ષિત અને પુનરાવર્તિત કરી શકાય તે બનાવે છે.

મુખ્ય સ્તરોને કેવી રીતે ટેસ્ટ કરવું તે સમજવું — **મોડલ્સ** (કસ્ટમ પદ્ધતિઓ, માન્યતા), **વ્યુઝ** (સ્ટેટસ કોડ્સ, ડેટા, સત્તાધિકાર/અનુમતિઓ, ફોર્મ હેન્ડલિંગ ટેસ્ટ ક્લાયન્ટ દ્વારા), **ફોર્મ્સ/સીરીયલાઇઝર્સ** (માન્ય અને અમાન્ય ઇનપુટ બંને માટે માન્યતા તર્કશાસ્ત્ર), અને **બિઝનેસ તર્કશાસ્ત્ર** — Django એપ્લિકેશનને ટેસ્ટ કરવાનાં વ્યવહારુ અવકાશને આવરી લે છે, અને `APITestCase` જેવા ટૂલ્સ DRF APIs માટે, `setUpTestData`/ફેક્ટરીઓ કુશલ ટેસ્ટ ડેટા માટે, અને બાહ્ય સેવાઓને મોક કરવું ઝડપી નિર્ણયક્ષમ ટેસ્ટ્સ માટે તેને જાણવું પરિપક્વ ટેસ્ટિંગ પ્રણાલીને પ્રતિબિંબિત કરે છે.

ાણે Django એપ્લિકેશનો રીગ્રેશનો પકડે છે, આત્મવિશ્વાસી રીફેક્ટરીંગ સક્ષમ કરે છે, અને અપેક્ષિત વર્તનને દસ્તાવેજ કરે છે, જ્યારે ફ્રેમવર્કનું વેબ-સચેત ડિઝાઇન (ખાસ કરીને ટેસ્ટ ક્લાયન્ટ અને ટેસ્ટ ડેટાબેસ) સંપૂર્ણ ટેસ્ટિંગ તમારું પોતાનું રોલીંગ કરતા વધુ સરળ બનાવે છે.

ટેસ્ટિંગ પ્રોફેશનલ સોફ્ટવેર ડેવલપમેન્ટ માટે મૂળભૂત છે અને Django એક્સીલન્ટ બિલ્ટ-ઇન સપોર્ટ તેના વૈશિષ્ટ્યોને માટે તૈયાર છે, તેથી મોડલ/વ્યુ/ફોર્મ સ્તરો પર અસરકારક ટેસ્ટ્સ કેવી રીતે લખવું તે જાણવું મહત્તવપૂર્ણ છે, વારંવાર સંબંધિત જ્ઞાન જે તે વિકાસકર્તાઓને અલગ કરે છે જેઓ મજબૂત, જાળવણીયોગ્ય એપ્લિકેશનો બનાવે છે તેમાંથી જેઓ નાજુક, અનુપરીક્ષિત કોડ શિપ કરે છે.