AI 自动化测试生成 SOP：从单测到回归的人审门控流程

# 安装：pip install pytest pytest-cov
# 跑覆盖率：pytest --cov=yourpkg --cov-report=term-missing
# 输出列出每个文件未覆盖的行号，AI 生成测试就冲着这些行去

import subprocess, re

def coverage_by_module(pkg: str) -> dict:
    """跑 pytest-cov 并解析每个模块的语句覆盖率与未覆盖行号"""
    out = subprocess.run(
        ["pytest", f"--cov={pkg}", "--cov-report=term-missing", "-q"],
        capture_output=True, text=True,
    )
    rows = {}
    for line in out.stdout.splitlines():
        # 形如 "src/utils.py    42    8    81%   12-15, 30"
        m = re.match(r"^(\S+\.py)\s+(\d+)\s+(\d+)\s+(\d+)%\s*(.*)$", line)
        if m:
            path, stmts, miss, pct, missing = m.groups()
            rows[path] = {
                "statements": int(stmts),
                "missing_lines": int(miss),
                "percent": int(pct),
                "missing": missing.strip(),
            }
    return rows

// package.json 脚本："test": "jest --coverage --collectCoverageFrom='src/**/*.{js,ts}'"
// 跑：npm test -- --coverage
// 输出表格列出每文件 % Stmts / % Branch / Uncovered Lines

// 解析 jest 的 coverage-summary.json 做基线快照
const fs = require('fs');

function coverageBaseline(reportPath = 'coverage/coverage-summary.json') {
  const summary = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
  const rows = {};
  for (const [file, m] of Object.entries(summary)) {
    rows[file] = {
      lines: m.lines.pct,
      branches: m.branches.pct,
      uncovered: m.lines.pct < 100,
    };
  }
  return rows;
}
// 基线快照对比：AI 生成测试后，未覆盖行号应真正减少

import ast
from openai import OpenAI

client = OpenAI()  # OpenAI 兼容接口；模型名以官网为准

GEN_UNIT_PROMPT = """你是测试工程师。下面是待测函数的源码。请用 pytest 生成单元测试，要求：
1. 覆盖正常路径、边界值（空、零、负、最大值）、异常输入；
2. 每条测试用 given-when-then 注释说明意图；
3. 断言必须检查具体返回值或抛出的异常类型，禁止只写 assert result is not None；
4. 不要 mock 被测函数本身。只输出代码，不要解释。

源码：
{code}
"""

def gen_unit_tests(source_path: str, func_name: str) -> str:
    """读取源码中指定函数，生成 pytest 用例草稿"""
    src = open(source_path, encoding="utf-8").read()
    tree = ast.parse(src)
    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name == func_name:
            seg = ast.get_source_segment(src, node)
            resp = client.chat.completions.create(
                model="qwen-plus",  # 以官网为准
                messages=[{"role": "user",
                           "content": GEN_UNIT_PROMPT.format(code=seg)}],
                temperature=0.2,
            )
            return resp.choices[0].message.content
    raise ValueError(f"未找到函数 {func_name}")

const fs = require('fs');
const { OpenAI } = require('openai'); // npm i openai；模型名以官网为准
const client = new OpenAI();

const GEN_UNIT_PROMPT = `你是测试工程师。下面是待测函数的源码。请用 Jest 生成单元测试，要求：
1. 覆盖正常路径、边界值（空、零、负、最大值）、异常输入；
2. 每条测试用 given-when-then 注释说明意图；
3. 断言必须检查具体返回值或抛出的异常类型，禁止只写 expect(x).toBeDefined()；
4. 不要 mock 被测函数本身。只输出代码。

源码：
{code}
`;

async function genUnitTests(sourcePath, funcName) {
  const src = fs.readFileSync(sourcePath, 'utf8');
  // 正则粗提取函数（生产环境建议用 @babel/parser 做 AST 提取）
  const re = new RegExp(
    `(?:export\\s+)?(?:async\\s+)?function\\s+${funcName}[\\s\\S]*?^\\}`, 'm');
  const match = src.match(re);
  if (!match) throw new Error(`未找到函数 ${funcName}`);
  const resp = await client.chat.completions.create({
    model: 'qwen-plus', // 以官网为准
    messages: [{ role: 'user',
      content: GEN_UNIT_PROMPT.replace('{code}', match[0]) }],
    temperature: 0.2,
  });
  return resp.choices[0].message.content;
}

REGRESSION_PROMPT = """这是一个 GitHub issue。请用 pytest 写一条回归测试：
1. 先按 issue 描述的复现步骤构造能触发 bug 的输入；
2. 该测试在修复前应当失败，修复后应当通过；
3. 用 pytest.raises 或显式断言锁定预期行为；
4. 在测试名和注释里标注 issue 编号。

issue #{number}：
{body}
"""

def gen_regression_test(number: int, body: str) -> str:
    resp = client.chat.completions.create(
        model="qwen-plus",  # 以官网为准
        messages=[{"role": "user",
                   "content": REGRESSION_PROMPT.format(number=number, body=body)}],
        temperature=0.2,
    )
    return resp.choices[0].message.content

const REGRESSION_PROMPT = `这是一个 GitHub issue。请用 Jest 写一条回归测试：
1. 先按 issue 描述的复现步骤构造能触发 bug 的输入；
2. 该测试在修复前应当失败，修复后应当通过；
3. 用 expect(() => fn(...)).toThrow(...) 或显式断言锁定预期行为；
4. 在测试名和注释里标注 issue 编号。

issue #{number}：
{body}
`;

async function genRegressionTest(number, body) {
  const resp = await client.chat.completions.create({
    model: 'qwen-plus', // 以官网为准
    messages: [{ role: 'user',
      content: REGRESSION_PROMPT
        .replace('{number}', number).replace('{body}', body) }],
    temperature: 0.2,
  });
  return resp.choices[0].message.content;
}

import pytest

# AI 只产出这张表，人审后套进参数化模板
PARAMS = [
    ("", 0),              # 空串
    ("abc", 3),           # 正常
    ("a" * 1000, 1000),   # 长串
    (None, TypeError),    # 非法类型
    ("中文测试", 4),       # 多字节
]

@pytest.mark.parametrize("s,expected", PARAMS,
                         ids=["empty", "normal", "long", "invalid", "multibyte"])
def test_len_safe(s, expected):
    """带类型校验的安全长度函数"""
    if s is None:
        with pytest.raises(TypeError):
            len_safe(s)
    else:
        assert len_safe(s) == expected

def len_safe(s):
    if s is None:
        raise TypeError("input must be a string")
    return len(s)

// Jest 参数化：test.each 套用 AI 生成的表
const PARAMS = [
  { input: '', expected: 0, id: 'empty' },
  { input: 'abc', expected: 3, id: 'normal' },
  { input: 'a'.repeat(1000), expected: 1000, id: 'long' },
  { input: null, expected: 'throw', id: 'invalid' },
  { input: '中文测试', expected: 4, id: 'multibyte' },
];

test.each(PARAMS)('lenSafe($id) -> $expected', ({ input, expected }) => {
  if (expected === 'throw') {
    expect(() => lenSafe(input)).toThrow(TypeError);
  } else {
    expect(lenSafe(input)).toBe(expected);
  }
});

function lenSafe(s) {
  if (s === null || s === undefined) {
    throw new TypeError('input must be a string');
  }
  return s.length;
}

import ast, re

def find_smell_tests(test_path: str) -> dict:
    """扫描 pytest 文件，定位三类测试坏味"""
    src = open(test_path, encoding="utf-8").read()
    tree = ast.parse(src)
    always_pass, tautology, names = [], [], []

    for node in ast.walk(tree):
        if isinstance(node, ast.FunctionDef) and node.name.startswith("test_"):
            body_src = ast.get_source_segment(src, node)
            names.append(node.name)
            # 坏味1：只 assert True / assert 1
            if re.search(r"assert\s+(True|1)\b", body_src):
                always_pass.append(node.name)
            # 坏味2：恒真断言 assert x == x（带捕获组做反向引用）
            if re.search(r"assert\s+(\w+)\s*==\s*\1\b", body_src):
                tautology.append(node.name)
    # 坏味3：同名测试（pytest 只跑一个，其余静默丢失）
    seen, dups = set(), []
    for n in names:
        if n in seen:
            dups.append(n)
        seen.add(n)
    return {"always_pass": always_pass,
            "tautology": tautology, "duplicates": dups}

const fs = require('fs');

function findSmellTests(testPath) {
  const src = fs.readFileSync(testPath, 'utf8');
  const smells = { noAssertions: [], tautology: [], duplicateNames: [] };
  const names = new Set();

  // 正则粗扫（精确分析建议用 @babel/parser 或 ts-morph）
  const testBlocks = src.match(/(?:test|it)\(['"`](.+?)['"`][\s\S]*?\}\);/g) || [];
  for (const block of testBlocks) {
    const nameMatch = block.match(/(?:test|it)\(['"`](.+?)['"`]/);
    const name = nameMatch ? nameMatch[1] : '<anon>';
    if (names.has(name)) smells.duplicateNames.push(name);
    names.add(name);
    if (!/expect\(/.test(block)) smells.noAssertions.push(name);
    // 恒真断言 expect(x).toBe(x)（带捕获组）
    if (/expect\(([^)]+)\)\.toBe\(\1\)/.test(block)) smells.tautology.push(name);
  }
  return smells;
}

# .github/workflows/ai-tests.yml — AI 测试门控 CI
name: ai-test-gate
on: [pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with: { python-version: '3.12' }
      - run: pip install pytest pytest-cov
      # 全量测试 + 覆盖率门槛，失败即拦截合并
      - run: pytest --cov=src --cov-fail-under=70 -q
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm ci && npm test -- --coverage