django-tdd

# Django 测试驱动开发 (TDD) 使用 pytest、factory_boy 和 Django REST Framework 进行 Django 应用程序的测试驱动开发。 ## 何时启用 - 编写新的 Django 应用程序时 - 实现 Django REST Framework API 时 - 测试 Django 模型（Models）、视图（Views）、序列化器（Serializers）时 - 配置 Django 项目的测试基础设施时 ## Django 的 TDD 工作流 ### 红-绿-重构（Red-Green-Refactor）循环 ```python # 步骤 1: RED - 编写一个失败的测试 def test_user_creation(): user = User.objects.create_user(email='test@example.com', password='testpass123') assert user.email == 'test@example.com' assert user.check_password('testpass123') assert not user.is_staff # 步骤 2: GREEN - 使测试通过 # 创建 User 模型或 Factory # 步骤 3: REFACTOR - 在保持测试通过的同时进行改进 ``` ## 设置 ### pytest 配置 ```ini # pytest.ini [pytest] DJANGO_SETTINGS_MODULE = config.settings.test testpaths = tests python_files = test_*.py python_classes = Test* python_functions = test_* addopts = --reuse-db --nomigrations --cov=apps --cov-report=html --cov-report=term-missing --strict-markers markers = slow: marks tests as slow integration: marks tests as integration tests ``` ### 测试设置 ```python # config/settings/test.py from .base import * DEBUG = True DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': ':memory:', } } # 禁用迁移以加快速度 class DisableMigrations: def __contains__(self, item): return True def __getitem__(self, item): return None MIGRATION_MODULES = DisableMigrations() # 更快的密码哈希 PASSWORD_HASHERS = [ 'django.contrib.auth.hashers.MD5PasswordHasher', ] # 邮件后端 EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' # Celery 始终为 eager 模式 CELERY_TASK_ALWAYS_EAGER = True CELERY_TASK_EAGER_PROPAGATES = True ``` ### conftest.py ```python # tests/conftest.py import pytest from django.utils import timezone from django.contrib.auth import get_user_model User = get_user_model() @pytest.fixture(autouse=True) def timezone_settings(settings): """确保时区一致。""" settings.TIME_ZONE = 'UTC' @pytest.fixture def user(db): """创建测试用户。""" return User.objects.create_user( email='test@example.com', password='testpass123', username='testuser' ) @pytest.fixture def admin_user(db): """创建管理员用户。""" return User.objects.create_superuser( email='admin@example.com', password='adminpass123', username='admin' ) @pytest.fixture def authenticated_client(client, user): """返回已认证的客户端。""" client.force_login(user) return client @pytest.fixture def api_client(): """返回 DRF API 客户端。""" from rest_framework.test import APIClient return APIClient() @pytest.fixture def authenticated_api_client(api_client, user): """返回已认证的 API 客户端。""" api_client.force_authenticate(user=user) return api_client ``` ## Factory Boy ### Factory 设置 ```python # tests/factories.py import factory from factory import fuzzy from datetime import datetime, timedelta from django.contrib.auth import get_user_model from apps.products.models import Product, Category User = get_user_model() class UserFactory(factory.django.DjangoModelFactory): """User 模型的 Factory。""" class Meta: model = User email = factory.Sequence(lambda n: f"user{n}@example.com") username = factory.Sequence(lambda n: f"user{n}") password = factory.PostGenerationMethodCall('set_password', 'testpass123') first_name = factory.Faker('first_name') last_name = factory.Faker('last_name') is_active = True class CategoryFactory(factory.django.DjangoModelFactory): """Category 模型的 Factory。""" class Meta: model = Category name = factory.Faker('word') slug = factory.LazyAttribute(lambda obj: obj.name.lower()) description = factory.Faker('text') class ProductFactory(factory.django.DjangoModelFactory): """Product 模型的 Factory。""" class Meta: model = Product name = factory.Faker('sentence', nb_words=3) slug = factory.LazyAttribute(lambda obj: obj.name.lower().replace(' ', '-')) description = factory.Faker('text') price = fuzzy.FuzzyDecimal(10.00, 1000.00, 2) stock = fuzzy.FuzzyInteger(0, 100) is_active = True category = factory.SubFactory(CategoryFactory) created_by = factory.SubFactory(UserFactory) @factory.post_generation def tags(self, create, extracted, **kwargs): """为产品添加标签。""" if not create: return if extracted: for tag in extracted: self.tags.add(tag) ``` ### 使用 Factory ```python # tests/test_models.py import pytest from tests.factories import ProductFactory, UserFactory def test_product_creation(): """测试使用 Factory 创建产品。""" product = ProductFactory(price=100.00, stock=50) assert product.price == 100.00 assert product.stock == 50 assert product.is_active is True def test_product_with_tags(): """测试带有标签的产品。""" tags = [TagFactory(name='electronics'), TagFactory(name='new')] product = ProductFactory(tags=tags) assert product.tags.count() == 2 def test_multiple_products(): """测试创建多个产品。""" products = ProductFactory.create_batch(10) assert len(products) == 10 ``` ## 模型测试 ### 模型测试 ```python # tests/test_models.py import pytest from django.core.exceptions import ValidationError from tests.factories import UserFactory, ProductFactory class TestUserModel: """测试 User 模型。""" def test_create_user(self, db): """测试普通用户创建。""" user = UserFactory(email='test@example.com') assert user.email == 'test@example.com' assert user.check_password('testpass123') assert not user.is_staff assert not user.is_superuser def test_create_superuser(self, db): """测试超级用户创建。""" user = UserFactory( email='admin@example.com', is_staff=True, is_superuser=True ) assert user.is_staff assert user.is_superuser def test_user_str(self, db): """测试用户的字符串表示。""" user = UserFactory(email='test@example.com') assert str(user) == 'test@example.com' class TestProductModel: """测试 Product 模型。""" def test_product_creation(self, db): """测试产品创建。""" product = ProductFactory() assert product.id is not None assert product.is_active is True assert product.created_at is not None def test_product_slug_generation(self, db): """测试自动 Slug 生成。""" product = ProductFactory(name='Test Product') assert product.slug == 'test-product' def test_product_price_validation(self, db): """测试价格不能为负值。""" product = ProductFactory(price=-10) with pytest.raises(ValidationError): product.full_clean() def test_product_manager_active(self, db): """测试 Active Manager 方法。""" ProductFactory.create_batch(5, is_active=True) ProductFactory.create_batch(3, is_active=False) active_count = Product.objects.active().count() assert active_count == 5 def test_product_stock_management(self, db): """测试库存管理。""" product = ProductFactory(stock=10) product.reduce_stock(5) product.refresh_from_db() assert product.stock == 5 with pytest.raises(ValueError): product.reduce_stock(10) # 库存不足 ``` ## 视图测试 ### Django 视图测试 ```python # tests/test_views.py import pytest from django.urls import reverse from tests.factories import ProductFactory, UserFactory class TestProductViews: """测试产品视图。""" def test_product_list(self, client, db): """测试产品列表视图。""" ProductFactory.create_batch(10) response = client.get(reverse('products:list')) assert response.status_code == 200 assert len(response.context['products']) == 10 def test_product_detail(self, client, db): """测试产品详情视图。""" product = ProductFactory() response = client.get(reverse('products:detail', kwargs={'slug': product.slug})) assert response.status_code == 200 assert response.context['product'] == product def test_product_create_requires_login(self, client, db): """测试创建产品需要登录。""" response = client.get(reverse('products:create')) assert response.status_code == 302 assert response.url.startswith('/accounts/login/') def test_product_create_authenticated(self, authenticated_client, db): """测试作为已认证用户的产品创建。""" response = authenticated_client.get(reverse('products:create')) assert response.status_code == 200 def test_product_create_post(self, authenticated_client, db, category): """测试通过 POST 创建产品。""" data = { 'name': 'Test Product', 'description': 'A test product', 'price': '99.99', 'stock': 10, 'category': category.id, } response = authenticated_client.post(reverse('products:create'), data) assert response.status_code == 302 assert Product.objects.filter(name='Test Product').exists() ``` ## DRF API 测试 ### 序列化器测试 ```python # tests/test_serializers.py import pytest from rest_framework.exceptions import ValidationError from apps.products.serializers import ProductSerializer from tests.factories import ProductFactory class TestProductSerializer: """测试 ProductSerializer。""" def test_serialize_product(self, db): """测试产品序列化。""" product = ProductFactory() serializer = ProductSerializer(product) data = serializer.data assert data['id'] == product.id assert data['name'] == product.name assert data['price'] == str(product.price) def test_deserialize_product(self, db): """测试产品数据反序列化。""" data = { 'name': 'Test Product', 'description': 'Test description', 'price': '99.99', 'stock': 10, 'category': 1, } serializer = ProductSerializer(data=data) assert serializer.is_valid() product = serializer.save() assert product.name == 'Test Product' assert float(product.price) == 99.99 def test_price_validation(self, db): """测试价格校验。""" data = { 'name': 'Test Product', 'price': '-10.00', 'stock': 10, } serializer = ProductSerializer(data=data) assert not serializer.is_valid() assert 'price' in serializer.errors def test_stock_validation(self, db): """测试库存不能为负。""" data = { 'name': 'Test Product', 'price': '99.99', 'stock': -5, } serializer = ProductSerializer(data=data) assert not serializer.is_valid() assert 'stock' in serializer.errors ``` ### API ViewSet 测试 ```python # tests/test_api.py import pytest from rest_framework.test import APIClient from rest_framework import status from django.urls import reverse from tests.factories import ProductFactory, UserFactory class TestProductAPI: """测试 Product API 端点。""" @pytest.fixture def api_client(self): """返回 API 客户端。""" return APIClient() def test_list_products(self, api_client, db): """测试产品列表。""" ProductFactory.create_batch(10) url = reverse('api:product-list') response = api_client.get(url) assert response.status_code == status.HTTP_200_OK assert response.data['count'] == 10 def test_retrieve_product(self, api_client, db): """测试获取产品。"""