AI 寫得快,測試兜得住 左邊一個終端視窗在跑 pytest,三行測試進度點幾乎全綠,第一行裡有一個紅色的 F,結果是 1 failed、17 passed;一條紅色虛線從這個 F 連到右邊三層測試金字塔的底層,那裡單元測試的白點裡有一個紅點被圈了出來;金字塔底層最寬,頂層最窄。 $ pytest F 1 failed, 17 passed

用 AI 寫程式碼的時代,測試不是可選項,而是必選項。

你正在用 Copilot、Claude Code 或 Cursor 寫 Python?你一天能產出過去一週的程式碼量?

很好。但問題來了——這些程式碼你敢直接上線嗎?

AI 生成的程式碼”看起來對”,卻未必經過深思熟慮。邏輯漏洞藏在角落裡,邊界條件被優雅的程式碼風格掩蓋。過去你寫一個函式要半小時,至少在腦子裡過了幾遍;現在 AI 三秒生成,你掃一眼就接受了。

測試,是你對 AI 程式碼唯一可靠的審查手段。

好訊息是:AI 同樣擅長寫測試。過去團隊跳過測試,最大的理由是”沒時間寫”。現在這個理由不成立了——讓 AI 寫程式碼的同時生成測試,再用測試反過來驗證程式碼,形成閉環。寫測試的成本,從”人天”降到了”人分鐘”。

本文是一份面向 Python 開發者的全場景測試指南。不講空泛的理論,從”為什麼要測”講起,到”每層測什麼、怎麼測”,最後落地到專案結構和 CI/CD。每個環節都有可執行的程式碼示例。

全文分三個部分:

  • Part 1: WHY — AI 時代,為什麼測試比以往更重要
  • Part 2: HOW — 測試金字塔、各層級實戰、工具鏈
  • Part 3: WHAT — 專案結構、覆蓋率、CI/CD 工程化落地

不管你是獨立開發者還是團隊成員,不管你寫的是庫、服務還是產品——讀完這篇,你會知道每一行程式碼該怎麼被測試保護。


Part 1: WHY — AI 時代,為什麼測試比以往更重要

程式碼在加速,風險也在加速

2024 年之後,AI 輔助程式設計不再是嚐鮮,而是日常。GitHub Copilot、Claude Code、Cursor——這些工具讓程式碼產出速度提升了數倍。一個下午就能搭出過去需要一週的功能。

但速度本身不是目的,可靠的速度才是。

AI 生成的程式碼有一個微妙的特點:它看起來很專業。變數命名規範,結構清晰,甚至帶著註釋。這種”專業感”會讓你放鬆警惕——掃一眼就接受,覺得”應該沒問題”。

然而 AI 並不真正理解你的業務邏輯。它基於模式匹配生成程式碼,擅長的是”像正確答案”,而不是”就是正確答案”。常見的隱患包括:

  • 邊界條件遺漏:price = 0 時折扣函式返回 NaN,AI 不會主動替你想到
  • 隱式假設:AI 預設輸入總是合法的,不會主動加防禦性檢查
  • 邏輯漏洞:多條件分支中某個路徑永遠走不到,但程式碼看上去完整
  • 依賴誤用:呼叫了一個 API 的過時用法,語法正確但行為不符合預期

這些問題不會在 code review 中輕易暴露——因為程式碼”看起來對”。

讓我們把話說明白:

  • AI 寫的程式碼 + 測試透過 = 有一定可信度的程式碼
  • AI 寫的程式碼 + 沒有測試 = 不可信的程式碼
  • AI 寫的程式碼 + AI 寫的測試 + 人工審查測試邏輯 = 最佳實踐

人的角色變了:從寫程式碼到審程式碼

AI 時代,開發者的核心工作從”寫程式碼”轉向了”審程式碼”。你不再逐行敲鍵盤,而是評估 AI 的產出是否正確、是否安全、是否符合業務需求。

人工審查有用,但有極限。你能盯著一個函式看 5 分鐘,但你盯不住 50 個函式。特別是當 AI 一口氣生成了一整個模組的時候——你需要一個自動化的、可重複的審查機制。

這就是測試。

測試不是”寫完程式碼後的額外工作”,它是對 AI 程式碼的驗收標準。沒有測試透過,程式碼就不算完成。

寫測試的成本,被 AI 打下來了

過去團隊不寫測試,最常見的理由是:

“業務趕,沒時間寫測試。”

這個理由曾經成立。手寫測試確實耗時——構造 mock 資料、處理邊界 case、維護 fixture……一個函式的測試可能比函式本身還長。

但現在,AI 把寫測試的成本打到了地板上。

你可以這樣工作:

  1. 讓 AI 生成業務程式碼
  2. 緊接著讓 AI 為這段程式碼生成測試
  3. 執行測試,如果失敗,說明程式碼或測試有問題
  4. 修正後再跑,直到全部透過

這個迴圈的時間成本,從”人天”變成了”人分鐘”。AI 寫測試的速度和寫業務程式碼一樣快,而且它特別擅長生成引數化測試和邊界 case——這些恰恰是人類最容易偷懶跳過的部分。


Part 2: HOW — 怎麼測試

測試金字塔:先搞清楚測哪層

在動手寫測試之前,先回答一個問題:這段程式碼應該用什麼級別的測試來覆蓋?

經典的測試金字塔把測試分為三層1:

E2E 整合測試 單元測試 ← 少量,覆蓋核心路徑 ← 適量,驗證模組間協作 ← 大量,快速驗證邏輯

每層的定位不同,成本和收益也不同:

測試層級涉及範圍執行速度易寫易維護性典型工具擅長髮現容易漏檢
端到端測試產品全流程(UI/API)慢(分鐘級)低Playwright, Selenium, httpx真實使用者場景、跨系統整合邊界條件、異常路徑(case 太重,只覆蓋主流程)
整合測試模組間互動、資料庫、外部服務中(秒級)中pytest + testcontainers, requests介面不匹配、資料流轉錯誤、配置問題完整使用者路徑、UI 互動問題
單元測試單個函式/類快(毫秒級)高pytest, unittest, Hypothesis邏輯錯誤、邊界條件、異常處理模組間整合問題、真實環境差異

各層測什麼:

單元測試 — 驗證單個函式/類的邏輯正確性:

  1. 正常路徑:給合法輸入,返回預期結果
  2. 邊界條件:空值、零值、極大極小、空列表、空字串
  3. 異常處理:非法輸入是否丟擲正確的異常
  4. 分支覆蓋:if/else 的每條路徑都走到

整合測試 — 驗證模組間互動、與外部服務的對接:

  1. API 介面:請求/響應格式、狀態碼、錯誤處理
  2. 資料庫操作:CRUD 是否正確寫入和讀取、事務是否正常回滾
  3. 外部服務呼叫:第三方 API 不可用時的降級邏輯

端到端測試 — 只覆蓋核心路徑,不測邊界條件:

  • 核心使用者路徑:註冊 → 登入 → 核心操作 → 結果驗證
  • 跨系統整合:前端 → 後端 → 資料庫 → 第三方服務的全鏈路
  • 關鍵頁面互動:表單提交、頁面跳轉、錯誤提示展示

不同專案型別,側重點不同:

  • Python 庫(如一個工具包):重單元測試,確保每個公開 API 行為正確
  • Web 服務(如 FastAPI 後端):重整合測試,確保介面和資料庫協作正常
  • 產品應用(如帶 UI 的全棧應用):三層都要有,端到端測試覆蓋核心路徑

不管哪種專案,AI 場景下每層都不可省略。AI 生成的程式碼可能在任何層級出問題——函式邏輯可能錯,模組拼接可能錯,整體流程也可能錯。


邏輯驗證方法

驗證單個函式/類的輸入→輸出是否正確。這是金字塔的底座,數量最多、跑得最快。

假設我們有一個折扣計算函式:

Python
def calculate_discount(price: float, rate: float) -> float:
"""计算折后价格。rate 为折扣率,0.1 表示打九折。"""
if not 0 <= rate <= 1:
raise ValueError(f"折扣率必须在 0~1 之间,收到: {rate}")
return price * (1 - rate)

基本斷言 — 用 pytest

最直接的方式,一個測試驗證一個預期:

Python
def test_calculate_discount_normal():
assert calculate_discount(100, 0.1) == 90.0
def test_calculate_discount_zero_rate():
assert calculate_discount(100, 0) == 100.0
def test_calculate_discount_invalid_rate():
with pytest.raises(ValueError, match="折扣率必须在 0~1 之间"):
calculate_discount(100, 1.5)

引數化 — 用 @pytest.mark.parametrize

當你需要用多組資料測同一個邏輯時,別寫 N 個函式,用引數化:

Python
@pytest.mark.parametrize("price, rate, expected", [
(100, 0.1, 90.0), # 正常折扣
(0, 0.1, 0.0), # 零价格
(100, 0, 100.0), # 无折扣
(100, 1, 0.0), # 全额折扣
(99.99, 0.5, 49.995),# 小数精度
])
def test_calculate_discount_cases(price, rate, expected):
assert calculate_discount(price, rate) == pytest.approx(expected)

屬性測試 — 用 Hypothesis

人類容易漏想邊界 case,Hypothesis 幫你自動探索。你不指定具體輸入,而是描述輸入的”性質”,讓框架隨機生成幾百組資料來跑:

Python
from hypothesis import given
from hypothesis import strategies as st
@given(
price=st.floats(min_value=0, max_value=10000, allow_nan=False),
rate=st.floats(min_value=0, max_value=1, allow_nan=False),
)
def test_discount_always_in_range(price, rate):
result = calculate_discount(price, rate)
assert 0 <= result <= price

如果 Hypothesis 發現了某組讓斷言失敗的輸入,它會自動縮小到最小反例(shrinking),告訴你具體是哪個邊界值出了問題。

形式化驗證 — 用 Z3

Hypothesis 透過隨機輸入來尋找 bug,但它不能證明沒有 bug——跑 200 組沒出錯,不代表第 201 組也沒問題。如果你需要數學級別的保證,可以用 Z3。

Z3 是微軟開源的 SMT 求解器(pip install z3-solver)。思路是把程式碼邏輯翻譯成約束,讓 Z3 嘗試找反例——如果找不到,就說明性質對所有合法輸入都成立:

Python
from z3 import Real, Solver, And, Not, unsat
def test_discount_in_range_proven():
price = Real('price')
rate = Real('rate')
result = price * (1 - rate)
s = Solver()
# 前提:price >= 0, 0 <= rate <= 1
s.add(price >= 0, rate >= 0, rate <= 1)
# 尝试找反例:result < 0 或 result > price
s.add(Not(And(result >= 0, result <= price)))
assert s.check() == unsat # unsat = 无反例 = 性质恒成立

Hypothesis 說”我試了 200 組都沒問題”,Z3 說”我證明了不可能有問題”。代價是你需要把邏輯手動建模成約束——適合核心演算法和關鍵不變數,不適合大面積鋪開。


互動驗證方法

驗證模組間協作、使用者流程是否正確。從瀏覽器互動到 API 全鏈路到框架介面測試。

瀏覽器測試 — Playwright

Python
# 安装:pip install pytest-playwright && playwright install
from playwright.sync_api import expect
def test_user_login_flow(page):
# 1. 访问登录页
page.goto("http://localhost:3000/login")
# 2. 填写表单
page.fill("#email", "alice@example.com")
page.fill("#password", "correct-password")
# 3. 点击登录
page.click("button[type=submit]")
# 4. 验证跳转到首页,显示欢迎信息
expect(page).to_have_url("http://localhost:3000/dashboard")
expect(page.locator(".welcome-message")).to_contain_text("Hello, Alice")
def test_user_login_wrong_password(page):
page.goto("http://localhost:3000/login")
page.fill("#email", "alice@example.com")
page.fill("#password", "wrong-password")
page.click("button[type=submit]")
# 应该停留在登录页,显示错误提示
expect(page).to_have_url("http://localhost:3000/login")
expect(page.locator(".error-message")).to_be_visible()

Web 框架介面測試 — FastAPI TestClient

不需要啟動伺服器,直接測介面:

Python
import pytest
from httpx import AsyncClient, ASGITransport
from app.main import app
@pytest.fixture
async def client():
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://test") as c:
yield c
@pytest.mark.asyncio
async def test_create_user(client):
resp = await client.post("/users", json={"name": "Alice", "email": "alice@example.com"})
assert resp.status_code == 201
assert resp.json()["name"] == "Alice"
@pytest.mark.asyncio
async def test_create_user_duplicate_email(client):
await client.post("/users", json={"name": "Alice", "email": "alice@example.com"})
resp = await client.post("/users", json={"name": "Bob", "email": "alice@example.com"})
assert resp.status_code == 409

Mock & 真實方案

測試中如何處理外部依賴——mock 替身 vs 真實服務。

Mock 外部 HTTP — respx

你的程式碼呼叫了第三方天氣 API,測試時不應該真的去請求。用 respx 模擬響應:

Python
import respx
from httpx import Response
@respx.mock
@pytest.mark.asyncio
async def test_fetch_weather_success():
respx.get("https://api.weather.com/v1/hangzhou").mock(
return_value=Response(200, json={"temp": 22, "condition": "sunny"})
)
result = await fetch_weather("hangzhou")
assert result.temp == 22
assert result.condition == "sunny"
@respx.mock
@pytest.mark.asyncio
async def test_fetch_weather_fallback_on_error():
respx.get("https://api.weather.com/v1/hangzhou").mock(
return_value=Response(500)
)
result = await fetch_weather("hangzhou")
assert result == DEFAULT_WEATHER # 验证降级逻辑

Mock 內部依賴 — pytest-mock

當被測模組依賴資料庫、檔案系統或其他還未準備好聯調的元件時,用 mocker.patch 隔離:

Python
async def test_get_user_name(client, mocker):
mocker.patch("app.db.find_user", return_value={"name": "Alice"})
resp = await client.get("/users/1/name")
assert resp.json()["name"] == "Alice"
async def test_get_user_name_not_found(client, mocker):
mocker.patch("app.db.find_user", return_value=None)
resp = await client.get("/users/999/name")
assert resp.status_code == 404

原則:只 mock 你不擁有的東西。 資料庫、第三方 API、檔案系統——這些 mock 掉。自己寫的內部模組儘量不 mock,否則測試和實現脫節。

不一定要 Mock——能重置的基礎設施直接用真的

Mock 的目的是隔離不可控的依賴。但如果你的基礎設施本身就能快速重置——比如用 IaC 一鍵拉起的測試資料庫、每次 CI 都重建的 Redis 例項、或者雲廠商提供的臨時環境——那直接跑真實服務反而更可靠。Mock 越多,測試和生產環境的差距越大;能用真的就用真的,只在”不可控、不穩定、有副作用”的地方才 mock。


工具鏈速查表

前面的示例已經把主要工具帶了出來。這裡給一張彙總表,方便速查:

場景推薦工具一句話說明
單元測試pytestPython 測試的事實標準
Mock / Stubunittest.mock, pytest-mock隔離外部依賴
引數化測試@pytest.mark.parametrize一組邏輯,多組資料
屬性測試Hypothesis自動生成隨機輸入,發現邊界 case
形式化驗證z3-solver用 SMT 求解器證明性質恆成立
非同步測試pytest-asyncioasync/await 測試支援
HTTP Mockrespx, pytest-httpx模擬 HTTP 響應,不發真實請求
Web 框架測試FastAPI TestClient, Flask test_client不啟動伺服器,直接測介面
CLI 測試click.testing.CliRunner, typer.testing測命令列工具
資料庫測試真實資料庫 / IaC 臨時環境能重置就用真的,比 mock 更可靠
資料工廠factory_boy構造複雜測試資料
效能基準pytest-benchmark, locust衡量和對比效能
快照測試syrupy輸出對比上次快照,檢測意外變化
端到端 / UIPlaywright (pytest-playwright)瀏覽器自動化測試
覆蓋率pytest-cov檢視測試覆蓋了多少程式碼
靜態分析mypy, ruff不執行程式碼就能發現型別和風格問題

Part 3: WHAT — 工程化落地

知道了為什麼要測、怎麼測之後,最後一個問題是:怎麼在真實專案中落地?

測試不只是寫幾個 test_ 函式的事。專案結構怎麼組織、覆蓋率怎麼衡量、CI 怎麼跑——這些決定了測試能不能長期存活,而不是寫完就爛掉。

專案結構與最佳實踐

推薦目錄結構

my_project/
├── src/
│ └── my_project/
│ ├── __init__.py
│ ├── models.py
│ ├── services.py
│ ├── api.py
│ └── auth/
│ ├── __init__.py
│ ├── login.py
│ └── permissions.py
├── tests/
│ ├── conftest.py # 全局 fixture
│ ├── unit/ # 镜像 src/ 结构,一个源文件对应一个测试文件
│ │ ├── conftest.py
│ │ ├── test_models.py
│ │ ├── test_services.py
│ │ ├── test_api.py
│ │ └── auth/
│ │ ├── test_login.py
│ │ └── test_permissions.py
│ ├── integration/
│ │ ├── conftest.py # 集成测试专用 fixture(数据库、HTTP mock)
│ │ ├── test_api.py
│ │ └── test_db.py
│ └── e2e/
│ ├── conftest.py # 端到端专用 fixture(浏览器、服务启动)
│ └── test_flows.py
└── pyproject.toml

按測試層級分目錄,而不是按業務模組。理由:

  • 不同層級的 fixture 和依賴差異很大,混在一起會互相干擾
  • 可以按層級單獨執行:pytest tests/unit 跑單元,pytest tests/integration 跑整合
  • CI 中可以並行跑不同層級,加速流水線

unit/ 內部映象原始碼目錄結構——src/my_project/auth/login.py 對應 tests/unit/auth/test_login.py,一眼就能看出哪個模組還沒有測試。

conftest.py 分層

conftest.py 是 pytest 的 fixture 共享機制。放在哪個目錄,就對那個目錄下所有測試生效。

Python
# tests/conftest.py — 全局共享
@pytest.fixture
def sample_user():
return {"name": "Alice", "email": "alice@example.com"}
# tests/integration/conftest.py — 集成测试专用
@pytest.fixture(scope="session")
def postgres():
with PostgresContainer("postgres:16") as pg:
yield pg.get_connection_url()
@pytest.fixture
def mock_db(mocker):
return mocker.patch("app.db.session")
@pytest.fixture
async def client():
transport = ASGITransport(app=app)
async with AsyncClient(transport=transport, base_url="http://test") as c:
yield c

測試命名規範

Python
# 好:清楚说明 测什么_在什么条件下_预期什么结果
def test_calculate_discount_with_zero_price_returns_zero(): ...
def test_create_user_with_duplicate_email_returns_409(): ...
# 不好:太模糊
def test_discount(): ...
def test_user(): ...
def test_it_works(): ...

常見反模式

反模式問題正確做法
一個測試驗證十件事失敗時不知道哪裡出了問題一個測試一個斷言(或一組緊密相關的斷言)
Mock 自己寫的程式碼測試和實現脫節,重構後測試還在”透過”只 mock 外部依賴
測試之間有依賴test_A 建立資料,test_B 依賴 test_A 的資料每個測試獨立,用 fixture 準備資料
追求 100% 覆蓋率為了湊數字寫無意義的測試覆蓋率是訊號,不是目標
忽略測試可讀性測試程式碼也是程式碼,也需要維護給測試起好名字,保持簡潔

覆蓋率與質量門禁

覆蓋率是怎麼算出來的? Python 提供了 sys.settrace() 函式,允許註冊一個 trace 回撥。每當直譯器執行 call(函式呼叫)、line(新的一行程式碼)、return(函式返回)、exception(異常丟擲)事件時都會觸發回撥。coverage.py 利用這個機制,在每一行程式碼執行時記錄下 (文件名, 行号),從而知道哪些行被執行過。

配置 pytest-cov

pyproject.toml
[tool.pytest.ini_options]
addopts = "--cov=src --cov-report=term-missing --cov-report=html"
[tool.coverage.run]
source = ["src"]
branch = true
[tool.coverage.report]
show_missing = true
fail_under = 80
exclude_lines = [
"pragma: no cover",
"if TYPE_CHECKING:",
"if __name__ == .__main__.",
]

執行 pytest 時自動輸出覆蓋率報告:

Terminal window
$ pytest
---------- coverage: platform linux, python 3.12 ----------
Name Stmts Miss Branch BrPart Cover Missing
---------------------------------------------------------------------
src/my_project/models.py 45 3 12 2 91% 23, 45-46
src/my_project/services.py 62 8 18 4 84% 31-35, 78-82
src/my_project/api.py 38 0 10 0 100%
---------------------------------------------------------------------
TOTAL 145 11 40 6 90%
Required test coverage of 80% reached. Total coverage: 90.00%

覆蓋率不是目標,是訊號

覆蓋率告訴你哪些程式碼沒被測試到,幫你發現盲區。但:

  • 80% 覆蓋率不意味著 80% 的 bug 被發現了
  • 100% 覆蓋率不意味著沒有 bug
  • 一行程式碼被執行過 ≠ 這行程式碼的行為被驗證過

合理用法:

  • 設定一個基線(比如 80%),新程式碼不能拉低整體覆蓋率
  • 關注 Missing 列,看哪些分支沒覆蓋到,判斷是否需要補測試
  • 不要為了湊數字寫無意義的測試

CI/CD 整合

測試寫好了,不放進 CI 就等於沒寫。

GitHub Actions 示例

.github/workflows/test.yml
name: Tests
on:
push:
branches: [main]
pull_request:
branches: [main]
jobs:
test:
runs-on: ubuntu-latest
strategy:
matrix:
python-version: ["3.11", "3.12", "3.13"]
steps:
- uses: actions/checkout@v4
- name: Set up Python ${{ matrix.python-version }}
uses: actions/setup-python@v5
with:
python-version: ${{ matrix.python-version }}
- name: Cache dependencies
uses: actions/cache@v4
with:
path: ~/.cache/pip
key: ${{ runner.os }}-pip-${{ hashFiles('**/pyproject.toml') }}
restore-keys: ${{ runner.os }}-pip-
- name: Install dependencies
run: pip install -e ".[test]"
- name: Run unit tests
run: pytest tests/unit --cov=src --cov-report=xml -q
- name: Run integration tests
if: success()
run: pytest tests/integration -q
- name: Upload coverage
uses: codecov/codecov-action@v4
with:
file: coverage.xml
fail_ci_if_error: true

關鍵點

多版本矩陣:至少測你宣告支援的最低版本和最新版本。如果你的庫宣告 requires-python = ">=3.11",那 3.11 和 3.13 都要跑。

按層級分步執行:單元測試和整合測試分開跑。單元測試失敗了就不用浪費時間跑整合了。

快取依賴:每次 CI 都重新 pip install 很慢。用 actions/cache 快取 pip 下載的包,只在 pyproject.toml 變化時重新安裝。

覆蓋率門禁:用 --cov-fail-under=80 或 Codecov 的 PR 檢查,確保新程式碼不拉低覆蓋率。

pyproject.toml 完整測試配置參考

TOML
[project.optional-dependencies]
test = [
"pytest>=8.0",
"pytest-cov>=5.0",
"pytest-asyncio>=0.24",
"pytest-mock>=3.14",
"hypothesis>=6.100",
"respx>=0.21",
"httpx>=0.27",
"testcontainers[postgres]>=4.0",
"factory-boy>=3.3",
]
[tool.pytest.ini_options]
testpaths = ["tests"]
asyncio_mode = "auto"
addopts = "-q --tb=short"
markers = [
"slow: marks tests as slow (deselect with '-m \"not slow\"')",
]
[tool.coverage.run]
source = ["src"]
branch = true
[tool.coverage.report]
show_missing = true
fail_under = 80

在 AI 時代,不寫測試的程式碼是不完整的程式碼。而寫測試,從來沒有像今天這麼容易。


參考資料

參考資料

  1. Python 測試全景:單元測試、整合測試與端到端測試實戰指南blog.csdn.net ↗https://blog.csdn.net/windowshht/article/details/149383813 ↩