名称： test-patterns
描述： 跨语言和框架编写与运行测试。适用于搭建测试套件、编写单元/集成/E2E测试、测量覆盖率、模拟依赖项或调试测试失败。涵盖 Node.js (Jest/Vitest)、Python (pytest)、Go、Rust 和 Bash。
元数据： {"clawdbot":{"emoji":"🧪","requires":{"anyBins":["node","python3","go","cargo","bash"]},"os":["linux","darwin","win32"]}}

测试模式

跨语言编写、运行和调试测试。涵盖单元测试、集成测试、端到端测试、模拟、覆盖率以及测试驱动开发工作流。

使用场景

• 为新项目搭建测试套件
• 为函数或模块编写单元测试
• 为 API 或数据库交互编写集成测试
• 设置代码覆盖率测量
• 模拟外部依赖项（API、数据库、文件系统）
• 调试不稳定或失败的测试
• 实施测试驱动开发

Node.js (Jest / Vitest)

环境搭建

# Jest
npm install -D jest
# 添加到 package.json: "scripts": { "test": "jest" }

# Vitest (更快，原生支持 ESM)
npm install -D vitest
# 添加到 package.json: "scripts": { "test": "vitest" }

单元测试

// math.js
export function add(a, b) { return a + b; }
export function divide(a, b) {
  if (b === 0) throw new Error('Division by zero');
  return a / b;
}

// math.test.js
import { add, divide } from './math.js';

describe('add', () => {
  test('两个正数相加', () => {
    expect(add(2, 3)).toBe(5);
  });

  test('处理负数', () => {
    expect(add(-1, 1)).toBe(0);
  });

  test('处理零', () => {
    expect(add(0, 0)).toBe(0);
  });
});

describe('divide', () => {
  test('两数相除', () => {
    expect(divide(10, 2)).toBe(5);
  });

  test('除零时抛出错误', () => {
    expect(() => divide(10, 0)).toThrow('Division by zero');
  });

  test('处理浮点数', () => {
    expect(divide(1, 3)).toBeCloseTo(0.333, 3);
  });
});

异步测试

// api.test.js
import { fetchUser } from './api.js';

test('根据 ID 获取用户', async () => {
  const user = await fetchUser('123');
  expect(user).toHaveProperty('id', '123');
  expect(user).toHaveProperty('name');
  expect(user.name).toBeTruthy();
});

test('用户不存在时抛出错误', async () => {
  await expect(fetchUser('nonexistent')).rejects.toThrow('Not found');
});

模拟

// 模拟模块
jest.mock('./database.js');
import { getUser } from './database.js';
import { processUser } from './service.js';

test('处理来自数据库的用户', async () => {
  // 设置模拟返回值
  getUser.mockResolvedValue({ id: '1', name: 'Alice', active: true });

  const result = await processUser('1');
  expect(result.processed).toBe(true);
  expect(getUser).toHaveBeenCalledWith('1');
  expect(getUser).toHaveBeenCalledTimes(1);
});

// 模拟 fetch
global.fetch = jest.fn();

test('使用正确的参数调用 API', async () => {
  fetch.mockResolvedValue({
    ok: true,
    json: async () => ({ data: 'test' }),
  });

  const result = await myApiCall('/endpoint');
  expect(fetch).toHaveBeenCalledWith('/endpoint', expect.objectContaining({
    method: 'GET',
  }));
});

// 监视现有方法（不替换，仅观察）
const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
// ... 运行代码 ...
expect(consoleSpy).toHaveBeenCalledWith('expected message');
consoleSpy.mockRestore();

覆盖率

# Jest
npx jest --coverage

# Vitest
npx vitest --coverage

# 检查覆盖率阈值 (jest.config.js)
# coverageThreshold: { global: { branches: 80, functions: 80, lines: 80, statements: 80 } }

Python (pytest)

环境搭建

pip install pytest pytest-cov

单元测试

# calculator.py
def add(a, b):
    return a + b

def divide(a, b):
    if b == 0:
        raise ValueError("Division by zero")
    return a / b

# test_calculator.py
import pytest
from calculator import add, divide

def test_add():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, 1) == 0

def test_divide():
    assert divide(10, 2) == 5.0

def test_divide_by_zero():
    with pytest.raises(ValueError, match="Division by zero"):
        divide(10, 0)

def test_divide_float():
    assert divide(1, 3) == pytest.approx(0.333, abs=0.001)

参数化测试

@pytest.mark.parametrize("a,b,expected", [
    (2, 3, 5),
    (-1, 1, 0),
    (0, 0, 0),
    (100, -50, 50),
])
def test_add_cases(a, b, expected):
    assert add(a, b) == expected

夹具

import pytest
import json
import tempfile
import os

@pytest.fixture
def sample_users():
    """提供测试用户数据。"""
    return [
        {"id": 1, "name": "Alice", "email": "alice@test.com"},
        {"id": 2, "name": "Bob", "email": "bob@test.com"},
    ]

@pytest.fixture
def temp_db(tmp_path):
    """提供一个临时的 SQLite 数据库。"""
    import sqlite3
    db_path = tmp_path / "test.db"
    conn = sqlite3.connect(str(db_path))
    conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)")
    conn.commit()
    yield conn
    conn.close()

def test_insert_users(temp_db, sample_users):
    for user in sample_users:
        temp_db.execute("INSERT INTO users VALUES (?, ?, ?)",
                       (user["id"], user["name"], user["email"]))
    temp_db.commit()
    count = temp_db.execute("SELECT COUNT(*) FROM users").fetchone()[0]
    assert count == 2

# 带清理的夹具
@pytest.fixture
def temp_config_file():
    path = tempfile.mktemp(suffix=".json")
    with open(path, "w") as f:
        json.dump({"key": "value"}, f)
    yield path
    os.unlink(path)

模拟

from unittest.mock import patch, MagicMock, AsyncMock

# 模拟函数
@patch('mymodule.requests.get')
def test_fetch_data(mock_get):
    mock_get.return_value.status_code = 200
    mock_get.return_value.json.return_value = {"data": "test"}

    result = fetch_data("https://api.example.com")
    assert result == {"data": "test"}
    mock_get.assert_called_once_with("https://api.example.com")

# 模拟异步
@patch('mymodule.aiohttp.ClientSession.get', new_callable=AsyncMock)
async def test_async_fetch(mock_get):
    mock_get.return_value.__aenter__.return_value.json = AsyncMock(return_value={"ok": True})
    result = await async_fetch("/endpoint")
    assert result["ok"] is True

# 上下文管理器模拟
def test_file_reader():
    with patch("builtins.open", MagicMock(return_value=MagicMock(
        read=MagicMock(return_value='{"key": "val"}'),
        __enter__=MagicMock(return_value=MagicMock(read=MagicMock(return_value='{"key": "val"}'))),
        __exit__=MagicMock(return_value=False),
    ))):
        result = read_config("fake.json")
        assert result["key"] == "val"

覆盖率

# 运行并计算覆盖率
pytest --cov=mypackage --cov-report=term-missing

# 生成 HTML 报告
pytest --cov=mypackage --cov-report=html
# 打开 htmlcov/index.html

# 覆盖率低于阈值时使测试失败
pytest --cov=mypackage --cov-fail-under=80

Go

单元测试

// math.go
package math

import "errors"

func Add(a, b int) int { return a + b }

func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// math_test.go
package math

import (
    "testing"
    "math"
)

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive", 2, 3, 5},
        {"negative", -1, 1, 0},
        {"zeros", 0, 0, 0},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Add(tt.a, tt.b)
            if got != tt.expected {
                t.Errorf("Add(%d, %d) = %d, want %d", tt.a, tt.b, got, tt.expected)
            }
        })
    }
}

func TestDivide(t *testing.T) {
    result, err := Divide(10, 2)
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    if math.Abs(result-5.0) > 0.001 {
        t.Errorf("Divide(10, 2) = %f, want 5.0", result)
    }
}

func TestDivideByZero(t *testing.T) {
    _, err := Divide(10, 0)
    if err == nil {
        t.Error("expected error for division by zero")
    }
}

运行测试

# 所有测试
go test ./...

# 详细输出
go test -v ./...

# 特定包
go test ./pkg/math/

# 包含覆盖率
go test -cover ./...
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

# 运行特定测试
go test -run TestAdd ./...

# 竞态条件检测
go test -race ./...

# 基准测试
go test -bench=. ./...

Rust

单元测试

// src/math.rs
pub fn add(a: i64, b: i64) -> i64 { a + b }

pub fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 { return Err("division by zero".into()); }
    Ok(a / b)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
        assert_eq!(add(-1, 1), 0);
    }

    #[test]
    fn test_divide() {
        let result = divide(10.0, 2.0).unwrap();
        assert!((result - 5.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_divide_by_zero() {
        assert!(divide(10.0, 0.0).is_err());
    }

    #[test]
    #[should_panic(expected = "overflow")]
    fn test_overflow_panics() {
        let _ = add(i64::MAX, 1); // 调试模式下溢出会 panic
    }
}

cargo test
cargo test -- --nocapture  # 显示 println 输出
cargo test test_add        # 运行特定测试
cargo tarpaulin            # 覆盖率 (安装: cargo install cargo-tarpaulin)

Bash 测试

简易测试运行器

#!/bin/bash
# test.sh - 极简 Bash 测试框架
PASS=0 FAIL=0

assert_eq() {
  local actual="$1" expected="$2" label="$3"
  if [ "$actual" = "$expected" ]; then
    echo "  PASS: $label"
    ((PASS++))
  else
    echo "  FAIL: $label (got '$actual', expected '$expected')"
    ((FAIL++))
  fi
}

assert_exit_code() {
  local cmd="$1" expected="$2" label="$3"
  eval "$cmd" >/dev/null 2>&1
  assert_eq "$?" "$expected" "$label"
}

assert_contains() {
  local actual="$1" substring="$2" label="$3"
  if echo "$actual" | grep -q "$substring"; then
    echo "  PASS: $label"
    ((PASS++))
  else
    echo "  FAIL: $label ('$actual' does not contain '$substring')"
    ((FAIL++))
  fi
}

# --- 测试 ---
echo "Running tests..."

# 测试你的脚本
output=$(./my-script.sh --help 2>&1)
assert_exit_code "./my-script.sh --help" "0" "help flag exits 0"
assert_contains "$output" "Usage" "help shows usage"

output=$(./my-script.sh --invalid 2>&1)
assert_exit_code "./my-script.sh --invalid" "1" "invalid flag exits 1"

# 测试命令输出
assert_eq "$(echo 'hello' | wc -c | tr -d ' ')" "6" "echo hello is 6 bytes"

echo ""
echo "Results: $PASS passed, $FAIL failed"
[ "$FAIL" -eq 0 ] && exit 0 || exit 1

集成测试模式

API 集成测试（任意语言）

#!/bin/bash
# test-api.sh - 启动服务器，运行测试，清理
SERVER_PID=""
cleanup() { [ -n "$SERVER_PID" ] && kill "$SERVER_PID" 2>/dev/null; }
trap cleanup EXIT

# 后台启动服务器
npm start &
SERVER_PID=$!
sleep 2  # 等待服务器启动

# 针对实时服务器运行测试
BASE_URL=http://localhost:3000 npx jest --testPathPattern=integration
EXIT_CODE=$?

exit $EXIT_CODE

数据库集成测试（Python）

import pytest
import sqlite3

@pytest.fixture
def db():
    """为每个测试提供全新的数据库。"""
    conn = sqlite3.connect(":memory:")
    conn.execute("CREATE TABLE items (id INTEGER PRIMARY KEY, name TEXT, price REAL)")
    yield conn
    conn.close()

def test_insert_and_query(db):
    db.execute("INSERT INTO items (name, price) VALUES (?, ?)", ("Widget", 9.99))
    db.commit()
    row = db.execute("SELECT name, price FROM items WHERE name = ?", ("Widget",)).fetchone()
    assert row == ("Widget", 9.99)

def test_empty_table(db):
    count = db.execute("SELECT COUNT(*) FROM items").fetchone()[0]
    assert count == 0

TDD 工作流

红-绿-重构循环：

1. 红：为下一个功能编写一个失败的测试
2. 绿：编写最少量的代码使其通过
3. 重构：在不改变行为的情况下清理代码（测试保持通过）

# 快速反馈循环
# Jest 监视模式
npx jest --watch

# Vitest 监视（默认）
npx vitest

# pytest 监视（使用 pytest-watch）
pip install pytest-watch
ptw

# Go（使用 air 或 entr）
ls *.go | entr -c go test ./...

调试失败的测试

常见问题

测试单独通过，但在套件中失败 → 共享状态问题。检查：
- 测试间修改的全局变量
- 数据库未清理
- 模拟未恢复（afterEach / teardown）

测试间歇性失败（不稳定） → 时序或顺序问题：
- 异步操作未正确 await
- 测试依赖执行顺序
- 时间相关逻辑（使用时钟模拟）
- 单元测试中的网络调用（应被模拟）

覆盖率显示未覆盖的分支 → 缺少边界情况：
- 错误路径（如果 API 返回 500 怎么办？）
- 空输入（空字符串、null、空数组）
- 边界值（0、-1、MAX_INT）

运行单个测试

# Jest
npx jest -t "test name substring"

# pytest
pytest -k "test_divide_by_zero"

# Go
go test -run TestDivideByZero ./...

# Rust
cargo test test_divide

建议

• 测试行为，而非实现。测试应能在重构后存活。
• 每个概念一个断言（不一定是每个测试一个 assert，而是一个逻辑检查）。
• 为测试起描述性名称：test_returns_empty_list_when_no_users_exist 优于 test_get_users_2。
• 不要模拟你不拥有的东西——围绕外部库编写薄包装层，模拟该包装层。
• 集成测试能发现单元测试遗漏的 Bug。不要跳过它们。
• 对于基于文件的测试，使用 tmp_path (pytest)、t.TempDir() (Go) 或 tempfile (Node)。
• 快照测试非常适合检测意外更改，但不适合不断演变的格式。