Django Testing 進階：Mock、Factory Boy 與 Coverage | Django 教學

pip install factory-boy

# articles/tests/factories.py

import factory
from factory.django import DjangoModelFactory
from django.contrib.auth.models import User
from articles.models import Article, Category


class UserFactory(DjangoModelFactory):
    """使用者資料工廠。"""

    class Meta:
        model = User

    username = factory.Sequence(lambda n: f'user_{n}')  # 自動遞增：user_0, user_1...
    email = factory.LazyAttribute(lambda obj: f'{obj.username}@example.com')  # 依據 username 動態生成
    first_name = factory.Faker('first_name', locale='zh_TW')  # 使用 Faker 產生假資料
    last_name = factory.Faker('last_name', locale='zh_TW')
    password = factory.PostGenerationMethodCall('set_password', 'testpass123')


class CategoryFactory(DjangoModelFactory):
    """文章分類資料工廠。"""

    class Meta:
        model = Category

    name = factory.Sequence(lambda n: f'Category {n}')
    slug = factory.LazyAttribute(lambda obj: obj.name.lower().replace(' ', '-'))


class ArticleFactory(DjangoModelFactory):
    """文章資料工廠。"""

    class Meta:
        model = Article

    title = factory.Faker('sentence', nb_words=5)  # 隨機生成 5 個單詞的句子
    content = factory.Faker('paragraphs', nb=3, as_text=True)
    author = factory.SubFactory(UserFactory)  # 自動建立關聯的 User
    category = factory.SubFactory(CategoryFactory)  # 自動建立關聯的 Category
    is_published = True

# articles/tests/test_with_factory.py

from django.test import TestCase
from articles.tests.factories import UserFactory, ArticleFactory


class ArticleWithFactoryTest(TestCase):
    """使用 Factory Boy 建立測試資料。"""

    def test_create_single_article(self):
        """建立單篇文章（自動建立 author）。"""
        article = ArticleFactory(title='Factory 建立的文章')
        self.assertEqual(article.title, 'Factory 建立的文章')
        self.assertIsNotNone(article.author)  # author 自動建立

    def test_create_article_with_specific_author(self):
        """指定作者建立文章。"""
        user = UserFactory(username='custom_author')
        article = ArticleFactory(author=user)
        self.assertEqual(article.author.username, 'custom_author')

    def test_create_batch(self):
        """批量建立多篇文章。"""
        user = UserFactory()
        articles = ArticleFactory.create_batch(10, author=user)
        self.assertEqual(len(articles), 10)
        self.assertTrue(all(a.author == user for a in articles))

    def test_build_without_saving(self):
        """只建立物件實例，不存入資料庫。"""
        article = ArticleFactory.build()  # 不呼叫 save()
        self.assertIsNone(article.pk)  # 尚未儲存，pk 為 None

# articles/tests/test_services.py

from unittest.mock import patch, MagicMock
from django.test import TestCase
from articles.services import publish_article


class PublishArticleTest(TestCase):
    """測試文章發布服務（包含外部 API 呼叫）。"""

    @patch('articles.services.send_notification')
    def test_publish_sends_notification(self, mock_send):
        """測試發布文章後會發送通知。"""
        article = ArticleFactory()
        publish_article(article)

        # 驗證 send_notification 被呼叫了一次
        mock_send.assert_called_once()

    @patch('articles.services.external_api.post')
    def test_publish_calls_external_api(self, mock_api_post):
        """測試發布文章後會呼叫外部 API。"""
        # 設定 Mock 的回傳值
        mock_api_post.return_value = MagicMock(
            status_code=200,
            json=lambda: {'id': 'ext_123', 'status': 'published'},
        )

        article = ArticleFactory()
        result = publish_article(article)

        # 驗證 API 被正確呼叫
        mock_api_post.assert_called_once_with(
            'https://api.example.com/articles',
            json={'title': article.title, 'content': article.content},
        )
        self.assertEqual(result['external_id'], 'ext_123')

    @patch('articles.services.external_api.post')
    def test_publish_handles_api_failure(self, mock_api_post):
        """測試外部 API 失敗時的錯誤處理。"""
        mock_api_post.side_effect = ConnectionError('API 無法連線')

        article = ArticleFactory()

        with self.assertRaises(ConnectionError):
            publish_article(article)

def test_email_sending(self):
    """測試 Email 寄送功能。"""
    with patch('django.core.mail.send_mail') as mock_send_mail:
        mock_send_mail.return_value = 1  # 表示成功寄送 1 封

        from articles.services import notify_author
        result = notify_author(self.article)

        self.assertTrue(result)
        mock_send_mail.assert_called_once_with(
            subject='你的文章已發布',
            message='...',
            from_email='noreply@example.com',
            recipient_list=[self.article.author.email],
        )

# 驗證是否被呼叫
mock.assert_called()                  # 至少被呼叫一次
mock.assert_called_once()             # 恰好被呼叫一次
mock.assert_not_called()              # 從未被呼叫

# 驗證呼叫的參數
mock.assert_called_with(arg1, arg2)               # 最後一次呼叫的參數
mock.assert_called_once_with(arg1, kwarg='value')  # 唯一一次呼叫的參數
mock.assert_any_call(arg1)                         # 任何一次呼叫中有此參數

# 檢查呼叫次數
self.assertEqual(mock.call_count, 3)

# 取得所有呼叫記錄
print(mock.call_args_list)  # [call(arg1), call(arg2), ...]

# articles/tests/test_api.py

from django.contrib.auth.models import User
from rest_framework import status
from rest_framework.test import APITestCase, APIClient
from rest_framework.authtoken.models import Token
from articles.models import Article
from articles.tests.factories import UserFactory, ArticleFactory


class ArticleAPITest(APITestCase):
    """測試 Article REST API。"""

    def setUp(self):
        self.user = UserFactory()
        self.token = Token.objects.create(user=self.user)
        self.client = APIClient()
        # Token 認證
        self.client.credentials(
            HTTP_AUTHORIZATION=f'Token {self.token.key}'
        )

    def test_list_articles(self):
        """測試列表 API 回傳正確格式。"""
        ArticleFactory.create_batch(3, author=self.user)

        response = self.client.get('/api/articles/')

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data['results']), 3)

    def test_create_article(self):
        """測試建立文章 API。"""
        response = self.client.post('/api/articles/', {
            'title': 'API 建立的文章',
            'content': '透過 API 測試建立',
        })

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(Article.objects.count(), 1)
        self.assertEqual(Article.objects.first().author, self.user)

    def test_create_article_unauthenticated(self):
        """測試未認證時被拒絕。"""
        self.client.force_authenticate(user=None)  # 清除認證

        response = self.client.post('/api/articles/', {
            'title': '未認證的文章',
            'content': '...',
        })

        self.assertEqual(
            response.status_code, status.HTTP_401_UNAUTHORIZED
        )

    def test_update_article_by_owner(self):
        """測試作者可以更新自己的文章。"""
        article = ArticleFactory(author=self.user)

        response = self.client.patch(
            f'/api/articles/{article.pk}/',
            {'title': '更新後的標題'},
        )

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        article.refresh_from_db()
        self.assertEqual(article.title, '更新後的標題')

    def test_delete_article_by_non_owner(self):
        """測試非作者無法刪除文章。"""
        other_user = UserFactory()
        article = ArticleFactory(author=other_user)

        response = self.client.delete(f'/api/articles/{article.pk}/')

        self.assertEqual(
            response.status_code, status.HTTP_403_FORBIDDEN
        )

# 方式一：Token 認證
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token_key}')

# 方式二：force_authenticate（最簡潔，跳過認證流程）
self.client.force_authenticate(user=self.user)

# 方式三：Session 認證
self.client.login(username='user', password='pass')

# 清除認證
self.client.force_authenticate(user=None)
self.client.credentials()  # 清除所有 credentials

# articles/tests/test_performance.py

from django.test import TestCase
from articles.tests.factories import ArticleFactory


class ArticlePerformanceTest(TestCase):
    """測試文章相關功能的 SQL 查詢效能。"""

    def test_list_view_query_count(self):
        """確保列表頁的查詢次數不隨資料量線性增長。"""
        ArticleFactory.create_batch(20)

        # 預期：1 次查詢取文章列表 + 1 次查詢取作者（若使用 select_related）
        with self.assertNumQueries(2):
            response = self.client.get('/articles/')
            self.assertEqual(response.status_code, 200)

    def test_api_list_query_count(self):
        """確保 API 列表端點的查詢數量在合理範圍。"""
        self.client.force_login(self.user)
        ArticleFactory.create_batch(10, author=self.user)

        with self.assertNumQueries(3):  # 認證 + 查文章 + 計數（分頁）
            response = self.client.get('/api/articles/')
            self.assertEqual(response.status_code, 200)

from django.test.utils import CaptureQueriesContext
from django.db import connection


def test_detect_n_plus_1(self):
    """偵測 N+1 查詢問題。"""
    ArticleFactory.create_batch(10)

    with CaptureQueriesContext(connection) as ctx:
        response = self.client.get('/articles/')

    # 印出所有 SQL 查詢（除錯用）
    for query in ctx.captured_queries:
        print(query['sql'])

    # 確保查詢次數在合理範圍
    self.assertLessEqual(
        len(ctx.captured_queries), 5,
        f'查詢次數過多：{len(ctx.captured_queries)} 次'
    )

pip install coverage

# 使用 coverage 執行 Django 測試
coverage run --source='.' manage.py test

# 在終端機顯示覆蓋率摘要
coverage report

# 顯示未覆蓋的行號
coverage report --show-missing

# 生成 HTML 格式的詳細報告
coverage html
# 報告會輸出到 htmlcov/ 目錄，用瀏覽器開啟 htmlcov/index.html 查看

# .coveragerc

[run]
source = apps
omit =
    */migrations/*
    */tests/*
    */admin.py
    manage.py
    */wsgi.py
    */asgi.py

[report]
show_missing = True
fail_under = 80        # 覆蓋率低於 80% 時視為失敗

[html]
directory = htmlcov

# pyproject.toml

[tool.coverage.run]
source = ["apps"]
omit = ["*/migrations/*", "*/tests/*", "*/admin.py"]

[tool.coverage.report]
show_missing = true
fail_under = 80

pip install pytest pytest-django pytest-cov

# pytest.ini

[pytest]
DJANGO_SETTINGS_MODULE = myproject.settings.test
python_files = tests.py test_*.py *_tests.py
python_classes = Test*
python_functions = test_*
addopts = --strict-markers -v
markers =
    slow: 標記為耗時測試
    integration: 標記為整合測試

# pyproject.toml

[tool.pytest.ini_options]
DJANGO_SETTINGS_MODULE = "myproject.settings.test"
python_files = ["tests.py", "test_*.py", "*_tests.py"]
addopts = "--strict-markers -v"
markers = [
    "slow: 標記為耗時測試",
    "integration: 標記為整合測試",
]

# conftest.py（放在專案根目錄或 App 目錄）

import pytest
from rest_framework.test import APIClient
from articles.tests.factories import UserFactory


@pytest.fixture
def user(db):
    """提供一個已建立的普通使用者。

    db fixture 確保測試可以存取資料庫。
    """
    return UserFactory()


@pytest.fixture
def admin_user(db):
    """提供一個超級使用者。"""
    return UserFactory(is_staff=True, is_superuser=True)


@pytest.fixture
def authenticated_client(client, user):
    """提供已登入的 Django Test Client。

    client 是 pytest-django 內建的 fixture。
    """
    client.force_login(user)
    return client


@pytest.fixture
def api_client():
    """提供 DRF APIClient。"""
    return APIClient()


@pytest.fixture
def authenticated_api_client(api_client, user):
    """提供已認證的 DRF APIClient。"""
    api_client.force_authenticate(user=user)
    return api_client

# articles/tests/test_articles_pytest.py

import pytest
from articles.tests.factories import ArticleFactory
from articles.models import Article


@pytest.mark.django_db
def test_article_creation(user):
    """測試文章建立（使用 conftest.py 的 user fixture）。"""
    article = ArticleFactory(title='pytest 建立的文章', author=user)
    assert article.title == 'pytest 建立的文章'
    assert article.author == user


@pytest.mark.django_db
def test_article_list_view(authenticated_client):
    """測試列表頁（使用已登入的 Client）。"""
    ArticleFactory.create_batch(5)
    response = authenticated_client.get('/articles/')
    assert response.status_code == 200


@pytest.mark.django_db
def test_article_api_create(authenticated_api_client):
    """測試 API 建立文章。"""
    response = authenticated_api_client.post('/api/articles/', {
        'title': 'API 文章',
        'content': '內容',
    })
    assert response.status_code == 201
    assert Article.objects.count() == 1


@pytest.mark.slow
@pytest.mark.django_db
def test_bulk_creation_performance(user):
    """測試批量建立效能（標記為 slow）。"""
    ArticleFactory.create_batch(100, author=user)
    assert Article.objects.count() == 100

# 執行所有測試
pytest

# 執行特定檔案
pytest articles/tests/test_articles_pytest.py

# 執行特定測試函式
pytest articles/tests/test_articles_pytest.py::test_article_creation

# 排除慢速測試
pytest -m "not slow"

# 只跑整合測試
pytest -m integration

# 搭配 Coverage
pytest --cov=apps --cov-report=html --cov-report=term-missing

# 平行執行（需安裝 pytest-xdist）
pip install pytest-xdist
pytest -n auto  # 自動偵測 CPU 核心數

# .github/workflows/test.yml

name: Django Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_DB: test_mydb
          POSTGRES_USER: postgres
          POSTGRES_PASSWORD: postgres
        ports: ['5432:5432']
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

      redis:
        image: redis:7
        ports: ['6379:6379']

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Run tests with coverage
        env:
          DJANGO_SETTINGS_MODULE: myproject.settings.test
          DATABASE_URL: postgresql://postgres:postgres@localhost/test_mydb
        run: |
          pytest --cov=apps --cov-report=xml --cov-fail-under=80 -x

      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v4
        with:
          file: coverage.xml

# 快速回饋：只跑 Unit Test（排除 slow 和 integration 標記）
pytest -m "not slow and not integration" --cov=apps --cov-fail-under=70

# 完整測試：包含 Integration Test
pytest --cov=apps --cov-fail-under=80

# Nightly Build：包含所有測試（含 slow）
pytest --cov=apps --cov-fail-under=80

# 好的命名：清楚描述測試的行為與預期
def test_create_article_requires_authentication(self):
def test_unpublished_article_not_in_list(self):
def test_author_can_delete_own_article(self):

# 不好的命名：過於模糊
def test_article(self):
def test_view(self):
def test_1(self):

def test_publish_article_sends_notification(self):
    # Arrange（準備）：建立測試資料與前置條件
    article = ArticleFactory(is_published=False)

    # Act（執行）：執行要測試的操作
    article.publish()

    # Assert（斷言）：驗證結果符合預期
    self.assertTrue(article.is_published)
    self.assertIsNotNone(article.published_at)