Django 测试指南

from django.db import models
from django.core.validators import MinValueValidator, MaxValueValidator

class Product(models.Model):
name = models.CharField(max_length=100)
price = models.DecimalField(
    max_digits=10,
    decimal_places=2,
    validators=[MinValueValidator(0)]
)
description = models.TextField(blank=True)
created_at = models.DateTimeField(auto_now_add=True)
is_available = models.BooleanField(default=True)

def __str__(self):
    return self.name

def apply_discount(self, percentage):
    """应用折扣"""
    if 0 <= percentage <= 100:
        discount = self.price * percentage / 100
        return self.price - discount
    raise ValueError("折扣百分比必须在0-100之间")

from django.test import TestCase
from django.core.exceptions import ValidationError
from .models import Product

class ProductModelTest(TestCase):
def test_create_product(self):
    """测试创建产品"""
    product = Product.objects.create(
        name='笔记本电脑',
        price=5999.99,
        description='高性能笔记本电脑'
    )
    self.assertEqual(Product.objects.count(), 1)
    self.assertEqual(product.name, '笔记本电脑')

def test_product_price_validation(self):
    """测试价格验证"""
    product = Product(name='测试产品', price=-100)
    with self.assertRaises(ValidationError):
        product.full_clean()  # 触发验证

def test_product_str_method(self):
    """测试字符串表示"""
    product = Product.objects.create(name='手机', price=2999.99)
    self.assertEqual(str(product), '手机')

def test_apply_discount(self):
    """测试折扣方法"""
    product = Product.objects.create(name='平板', price=1000.00)
    discounted_price = product.apply_discount(20)
    self.assertEqual(discounted_price, 800.00)

def test_apply_invalid_discount(self):
    """测试无效折扣"""
    product = Product.objects.create(name='平板', price=1000.00)
    with self.assertRaises(ValueError):
        product.apply_discount(150)

from django import forms
from .models import Product

class ProductForm(forms.ModelForm):
class Meta:
    model = Product
    fields = ['name', 'price', 'description', 'is_available']
    widgets = {
        'description': forms.Textarea(attrs={'rows': 4}),
    }

def clean_price(self):
    """自定义价格验证"""
    price = self.cleaned_data['price']
    if price <= 0:
        raise forms.ValidationError('价格必须大于0')
    return price

def clean(self):
    """表单级验证"""
    cleaned_data = super().clean()
    name = cleaned_data.get('name')
    description = cleaned_data.get('description')

    # 确保描述不包含名称（示例规则）
    if name and description and name in description:
        raise forms.ValidationError('描述中不能包含产品名称')

    return cleaned_data

from django.test import TestCase
from .forms import ProductForm

class ProductFormTest(TestCase):
def test_valid_form(self):
    """测试有效表单数据"""
    form_data = {
        'name': '有效产品',
        'price': 99.99,
        'description': '这是一个有效的产品描述',
        'is_available': True
    }
    form = ProductForm(data=form_data)
    self.assertTrue(form.is_valid())

def test_invalid_price(self):
    """测试无效价格"""
    form_data = {
        'name': '无效产品',
        'price': -10.00,  # 无效价格
        'description': '描述'
    }
    form = ProductForm(data=form_data)
    self.assertFalse(form.is_valid())
    self.assertIn('price', form.errors)

def test_name_in_description_validation(self):
    """测试名称在描述中的验证"""
    form_data = {
        'name': '手机',
        'price': 100.00,
        'description': '这是一个手机产品的描述'  # 包含名称
    }
    form = ProductForm(data=form_data)
    self.assertFalse(form.is_valid())
    self.assertIn('__all__', form.errors)  # 表单级错误

def test_form_save(self):
    """测试表单保存"""
    form_data = {
        'name': '新手机',
        'price': 2999.99,
        'description': '新款智能手机',
        'is_available': True
    }
    form = ProductForm(data=form_data)
    self.assertTrue(form.is_valid())

    product = form.save()
    self.assertEqual(product.name, '新手机')
    self.assertEqual(product.price, 2999.99)
    self.assertTrue(Product.objects.filter(name='新手机').exists())

import factory
from django.contrib.auth.models import User
from .models import Product, Category

class UserFactory(factory.django.DjangoModelFactory):
class Meta:
    model = User

username = factory.Sequence(lambda n: f'user{n}')
email = factory.LazyAttribute(lambda obj: f'{obj.username}@example.com')
password = factory.PostGenerationMethodCall('set_password', 'password123')

class CategoryFactory(factory.django.DjangoModelFactory):
class Meta:
    model = Category

name = factory.Sequence(lambda n: f'Category {n}')

class ProductFactory(factory.django.DjangoModelFactory):
class Meta:
    model = Product

name = factory.Sequence(lambda n: f'Product {n}')
price = factory.Faker('pydecimal', left_digits=3, right_digits=2, positive=True)
category = factory.SubFactory(CategoryFactory)

@factory.post_generation
def tags(self, create, extracted, **kwargs):
    if not create:
        return

    if extracted:
        for tag in extracted:
            self.tags.add(tag)

from .factories import ProductFactory, UserFactory

class ProductFactoryTest(TestCase):
def test_product_factory(self):
    """测试产品工厂"""
    product = ProductFactory()
    self.assertIsNotNone(product.name)
    self.assertIsNotNone(product.price)
    self.assertIsNotNone(product.category)

def test_product_with_custom_data(self):
    """测试使用自定义数据的工厂"""
    product = ProductFactory(name='自定义产品', price=888.88)
    self.assertEqual(product.name, '自定义产品')
    self.assertEqual(product.price, 888.88)

def test_batch_creation(self):
    """测试批量创建"""
    products = ProductFactory.create_batch(5)
    self.assertEqual(len(products), 5)
    self.assertEqual(Product.objects.count(), 5)

class ViewWithFactoryTest(TestCase):
def setUp(self):
    self.user = UserFactory()
    self.products = ProductFactory.create_batch(3)

def test_product_list_with_factories(self):
    """使用工厂测试产品列表"""
    self.client.force_login(self.user)
    response = self.client.get(reverse('product_list'))

    self.assertEqual(response.status_code, 200)
    self.assertEqual(len(response.context['products']), 3)

from unittest.mock import patch, Mock
from django.test import TestCase
from .services import PaymentService, EmailService
from .models import Order

class PaymentTest(TestCase):
@patch('myapp.services.PaymentService.process_payment')
def test_successful_payment(self, mock_process):
    """测试成功支付场景"""
    # 配置 Mock
    mock_process.return_value = {'status': 'success', 'transaction_id': '12345'}

    order = Order.objects.create(total_amount=100.00)
    result = PaymentService.process_order_payment(order)

    # 验证 Mock 被调用
    mock_process.assert_called_once_with(amount=100.00)

    # 验证结果
    self.assertTrue(result['success'])
    self.assertEqual(order.transaction_id, '12345')

@patch('myapp.services.EmailService.send_email')
def test_order_confirmation_email(self, mock_send_email):
    """测试订单确认邮件发送"""
    # 配置 Mock 不实际发送邮件
    mock_send_email.return_value = True

    order = Order.objects.create(total_amount=100.00)
    success = EmailService.send_order_confirmation(order)

    self.assertTrue(success)
    mock_send_email.assert_called_once()

from django.test import TestCase
from unittest.mock import patch
from django.db.models.signals import post_save
from .models import Product, Inventory
from .signals import update_inventory

class SignalTest(TestCase):
def test_inventory_signal(self):
    """测试产品创建时库存信号"""
    # 断开信号以便单独测试
    post_save.disconnect(update_inventory, sender=Product)

    product = Product.objects.create(name='测试产品', price=100)

    # 手动调用信号处理程序
    update_inventory(sender=Product, instance=product, created=True)

    # 验证库存记录创建
    self.assertTrue(Inventory.objects.filter(product=product).exists())

    # 重新连接信号
    post_save.connect(update_inventory, sender=Product)

@patch('myapp.tasks.send_welcome_email.delay')
def test_celery_task_mock(self, mock_task):
    """测试 Celery 任务调用"""
    from .views import register_user

    response = self.client.post('/register/', {
        'username': 'newuser',
        'email': 'user@example.com',
        'password': 'password123'
    })

    # 验证任务被调用
    mock_task.assert_called_once_with('user@example.com')