Django TDD Skill

Test-driven development workflow for Django applications. Covers pytest fixtures, Django TestCase, factory_boy, and testing patterns.

When to Activate

Activate when:

• Writing new Django features using TDD workflow
• Adding tests to existing Django applications
• Debugging test failures in Django projects
• Setting up testing infrastructure for Django apps

TDD Workflow

1. Write a failing test (RED)
2. Run the test - it should fail
3. Write minimal implementation (GREEN)
4. Run tests - they should pass
5. Refactor (IMPROVE)
6. Verify coverage

Test Setup

Using pytest with Django

# conftest.py
import pytest
import django
from django.conf import settings

@pytest.fixture(scope="session")
def django_db_setup():
    settings.DATABASES["default"] = {
        "ENGINE": "django.db.backends.sqlite3",
        "NAME": ":memory:",
    }

@pytest.fixture
def api_client():
    from rest_framework.test import APIClient
    return APIClient()

Django TestCase

from django.test import TestCase, Client
from django.urls import reverse
from django.contrib.auth import get_user_model
from .models import Article, Author

User = get_user_model()

class ArticleViewTest(TestCase):
    def setUp(self):
        self.client = Client()
        self.user = User.objects.create_user(
            email='test@example.com',
            password='testpass123'
        )
        self.author = Author.objects.create(name='Author', email='a@test.com')
        self.article = Article.objects.create(
            title='Test',
            content='Content',
            author=self.author,
            status='published'
        )

Testing Views

List View Tests

def test_article_list_view(self):
    response = self.client.get(reverse('article-list'))
    self.assertEqual(response.status_code, 200)
    self.assertContains(response, 'Test')
    self.assertTemplateUsed(response, 'articles/list.html')
    self.assertEqual(len(response.context['articles']), 1)

Detail View Tests

def test_article_detail_view(self):
    response = self.client.get(
        reverse('article-detail', kwargs={'pk': self.article.pk})
    )
    self.assertEqual(response.status_code, 200)
    self.assertContains(response, self.article.title)

def test_article_detail_not_found(self):
    response = self.client.get(
        reverse('article-detail', kwargs={'pk': 9999})
    )
    self.assertEqual(response.status_code, 404)

Authentication Tests

def test_create_article_requires_login(self):
    response = self.client.get(reverse('article-create'))
    self.assertRedirects(response, '/accounts/login/?next=/articles/create/')

def test_create_article_authenticated(self):
    self.client.login(email='test@example.com', password='testpass123')
    response = self.client.post(reverse('article-create'), {
        'title': 'New Article',
        'content': 'New content',
        'status': 'draft',
    })
    self.assertEqual(response.status_code, 302)
    self.assertTrue(Article.objects.filter(title='New Article').exists())

JSON API Tests

def test_json_response(self):
    response = self.client.get(
        reverse('api-articles'),
        content_type='application/json'
    )
    self.assertEqual(response.status_code, 200)
    data = response.json()
    self.assertIn('articles', data)

Testing Models

def test_article_creation(self):
    article = Article.objects.create(
        title='Test Article',
        content='Test content',
        author=self.author,
        status='draft'
    )
    self.assertEqual(article.title, 'Test Article')
    self.assertEqual(article.status, 'draft')
    self.assertEqual(str(article), 'Test Article')

def test_article_ordering(self):
    Article.objects.create(title='Second', author=self.author)
    Article.objects.create(title='First', author=self.author)
    articles = list(Article.objects.all())
    self.assertEqual(articles[0].title, 'First')

Factory Boy Fixtures

Defining Factories

# factories.py
import factory
from factory.django import DjangoModelFactory
from .models import Author, Article

class AuthorFactory(DjangoModelFactory):
    class Meta:
        model = Author

    name = factory.Sequence(lambda n: f"Author {n}")
    email = factory.LazyAttribute(lambda obj: f"{obj.name.replace(' ', '')}@example.com")

class ArticleFactory(DjangoModelFactory):
    class Meta:
        model = Article

    title = factory.Sequence(lambda n: f"Article {n}")
    content = "Test content"
    author = factory.SubFactory(AuthorFactory)
    status = 'draft'

Using Factories in Tests

from .factories import AuthorFactory, ArticleFactory

def test_article_with_factory(self):
    author = AuthorFactory(name="Jane Doe")
    article = ArticleFactory(title="Test", author=author)
    assert article.author.name == "Jane Doe"
    assert article.title == "Test"

Pytest Fixtures

Basic Fixture

import pytest

@pytest.fixture
def sample_data():
    return {"name": "test", "value": 42}

def test_sample_data(sample_data):
    assert sample_data["name"] == "test"
    assert sample_data["value"] == 42

Fixture with Teardown

import tempfile
import os

@pytest.fixture
def temp_file():
    fd, path = tempfile.mkstemp()
    os.write(fd, b"test content")
    os.close(fd)
    yield path
    os.unlink(path)

def test_temp_file(temp_file):
    assert os.path.exists(temp_file)
    with open(temp_file) as f:
        assert f.read() == "test content"

Parametrized Fixtures

@pytest.fixture(params=["mysql", "postgresql", "sqlite"])
def database_type(request):
    return request.param

def test_database_type(database_type):
    assert database_type in ["mysql", "postgresql", "sqlite"]

Common Patterns

Testing Forms

def test_form_valid(self):
    form_data = {
        'title': 'New Article',
        'content': 'Content',
        'author': self.author.pk,
        'status': 'draft',
    }
    form = ArticleForm(data=form_data)
    self.assertTrue(form.is_valid())

def test_form_invalid(self):
    form_data = {'title': '', 'content': 'Content'}
    form = ArticleForm(data=form_data)
    self.assertFalse(form.is_valid())
    self.assertIn('title', form.errors)

Testing Middleware

def test_middleware_process_request(self):
    response = self.client.get('/articles/')
    self.assertEqual(response.status_code, 200)
    # Check middleware added expected headers or behavior

Testing Signals

def test_signal_on_save(self):
    article = ArticleFactory()
    # Verify signal handlers executed (e.g., notifications sent)

Coverage Verification

# Run with coverage
pytest --cov=myapp --cov-report=html

# Minimum 80% coverage required

Related Skills

• django-patterns
• python-patterns
• tdd-workflow