Hvordan tester du Django-applikationer?

Question

IT Interview Practice · Accepted Answer

Django indeholder en **built-in test framework** (der udvider Pythons `unittest`) med værktøjer tilpasset webapplikationer — en test client til at simulere requests, et fixtures/database-system, der opretter en isoleret test database, og hjælpere til test af models, views og forms.

## Et grundlæggende 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` omslutter hver test i en **database transaction, der rulles tilbage** efterfølgende, så tests er isolerede og ikke forurener hinanden — og den bruger en **separat test database** (oprettet/ødelagt automatisk), aldrig dine rigtige data.

## Test af views med test clienten

```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 clienten** simulerer HTTP requests til dine views (GET/POST, med login, sessions osv.) uden en kørende server — hvilket lader dig teste hele request/response-flowet, status codes og rendereret indhold.

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

## Nyttige værktøjer og best 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)
```

## Hvad skal testes

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

## Hvorfor det betyder noget

Testing er essentielt for at bygge pålidelige, vedligeholdelige Django-applikationer, og Djangos built-in test framework — tilpasset specifikt til webapplikationer — gør det tilgængeligt og effektivt, så at forstå det er vigtigt både for kodekvalitet og som professionel standard.

Frameworket leverer webspecifikke værktøjer, der gør test af Django-apps praktisk: **test clienten** simulerer HTTP requests til views (håndterer GET/POST, autentifikation, sessions) så du kan teste hele request/response-flowet — status codes, rendereret indhold, redirects, tilladelser — uden en kørende server, hvilket er afgørende da views er hvor meget af en apps opførsel bor.

**Den automatiske test database** (oprettet frisk og ødelagt efter, med hver test omsluttet i en tilbagerullet transaction) sikrer at tests er isolerede og aldrig rører rigtige data, hvilket gør dem sikre og gentagelige.

At forstå hvordan man tester de vigtigste lag — **models** (custom metoder, validering), **views** (status codes, data, auth/tilladelser, form håndtering via test clienten), **forms/serializers** (validerings logik for både valid og invalid input) og **business logic** — dækker det praktiske omfang af test af en Django-applikation, og at kende værktøjer som `APITestCase` til DRF APIs, `setUpTestData`/factories til effektiv test data og mocking af eksterne services til hurtige deterministiske tests afspejler moden test praksis.

Vel-testede Django-applikationer fanger regressioner, muliggør selvsikker refactoring, og dokumenterer forventet opførsel, mens frameworkets webklar design (især test clienten og test databasen) gør grundig testing meget nemmere end at rulle sin egen.

Fordi testing er fundamental for professionel softwareudvikling og Django leverer fremragende built-in support tilpasset dets features, at vide hvordan man skriver effektive tests på tværs af model/view/form lagene er vigtig, hyppigt relevant viden, der skelner udvikler, der bygger robuste, vedligeholdelige applikationer fra dem, der udsender skrøbelig, utestet kode.

Et grundlæggende test case

Test af views med test clienten

Test af DRF APIs

Nyttige værktøjer og best practices

Hvad skal testes

Hvorfor det betyder noget

Relaterede spørgsmål