《AI Agent 游戏产品开发》9.3 QA 的回归、探索与用例生成

三个状态维度、每维六个取值就是 216 种组合,全跑跑不完,随机抽样又说不清覆盖了什么。本节把用例生成拆成单值覆盖、风险优先与时间预算三步,并说明回归为什么按依赖图走一跳而不是按目录全量跑,以及 Agent 生成的用例必须满足可执行、可判定、可去重三条约束。

以下人物、公司与数字均为教学假设,不构成对任何真实产品的评价。维度数量、组合数与时间预算均为教学设定值。

《潮汐消消》的关卡测试有三个状态维度:关卡编号、棋盘状态、设备档位。每维六个代表取值,组合起来是 216 种。

每次发版都有人提议「全跑一遍」。216 条乘以 8 分钟,是 28.8 小时,还没算构造环境与复现的时间。于是实际执行变成「挑几条重要的跑」,而挑的标准每人不同,覆盖了什么没人说得清。

Agent 可以生成用例、可以跑探索、可以选回归,但它解决不了「测什么」这个问题。这一节把「测什么」变成可执行的选择规则。

全组合不可跑,先承认这件事

216 种组合不是异常,而是常态。维度每增加一个,组合数就乘一次;四个维度各六个取值就是 1296 种。

承认全组合不可跑,才能开始做取舍。取舍有三种常见做法:

做法覆盖问题
全量跑100%时间不可接受,最终退化成挑着跑
随机抽样不可知说不清覆盖了什么,回归无法比较
结构化选择可计算需要先定义维度与优先级

本书选第三种。结构化选择的核心是:先保证每个取值至少出现一次,再按风险补组合,最后按时间预算裁剪。

单值覆盖:把乘积降成求和

单值覆盖的做法是:取一个基线组合,然后每次只改变一个维度,让它取遍所有取值。

三个维度各六个取值,基线一条,加上每个维度另外五个取值各一条,共 16 条。16 条就能保证 18 个「维度-取值」对全部出现。

覆盖率的算法要按「维度-取值」对计算,而不是按组合数计算。按组合数算,16 条覆盖 216 种组合只有 7.4%,看起来很差;按维度-取值对算,覆盖率是 100%,准确反映「每个取值都被摸过」。

两种口径不是谁对谁错,而是回答不同问题。单值覆盖回答「有没有完全没碰过的取值」,组合覆盖回答「组合之间是否互相影响」。前者是底线,后者按风险补。

风险优先:先跑会赔钱的那几条

单值覆盖之后,用例数量还是可能超过预算。这时按风险排序:

  • P0: 存档损坏、支付失败、越权访问、进度丢失。失败一次就可能造成资损或投诉。
  • P1: 主流程阻断、关卡无法完成、匹配失败。失败会让玩家卡住。
  • P2: 表现异常、文案错误、非关键动效。失败影响体验但不阻断。

排序规则是:用例命中任一风险取值,就升到 P0。风险取值由团队维护一份清单,例如「存档损坏」「支付回调超时」「越权读他人存档」。

风险清单本身要评审。全是 P0 等于没有优先级;一条 P0 都没有,说明清单没覆盖真正会赔钱的场景。

排序之后还要稳定。同优先级内按用例 id 排序,保证每次跑的顺序一致,失败对比才有意义。

时间预算:按分钟算,不按条数算

「这轮跑 100 条」不是预算,因为不同用例耗时不同。「这轮有 64 分钟」才是预算。

预算换算成条数时向下取整。64 分钟除以每条 8 分钟是 8 条,不是 8.5 条;向上取整会让实际耗时超预算,下一轮又得压缩。

预算要按版本阶段分配。提测版本给探索更多时间,回归版本给固定用例更多时间。两者共用一个总预算,避免各报各的、加起来超时。

预算还要留出复现时间。发现失败后要复现、抓日志、提工单,这部分通常占总时间的两到三成,不能只算执行时间。

回归按依赖走,不按目录走

回归最容易犯的错是「改了配置就把整个配置目录的用例全跑」。目录是文件组织方式,不是影响范围。

正确做法是按依赖图走:从改动模块出发,找到依赖它的模块,走一跳或两跳,命中谁跑谁。

改动一跳命中是否要跑全量
配置表字段战斗、UI否
战斗结算战报、排行否
存档格式存档、云同步、客服工具否,但要加迁移用例
支付回调订单、发货、客服是,涉及资金

最后一行的例外很重要。依赖图给的是默认范围,涉及资金、身份、存档格式变更时,范围要人为放大。规则要写清例外,否则「按图走」会变成「漏测的借口」。

依赖图本身要维护。模块新增依赖却不更新图,回归范围会系统性偏小,而且这种偏小不会报错。

探索测试:给时间,不给脚本

探索测试不是「随便点点」。它需要三样东西:

  1. 时间盒。 一次两小时,到点停,避免无限扩张。
  2. 探索章程。 这一轮探索什么,例如「连续快速点击结算按钮」「弱网下切换后台」。
  3. 记录模板。 发现了什么、怎么复现、影响范围。

Agent 可以做探索的执行者,但不能同时做章程的制定者。让模型自己决定探索什么,它会倾向于重复已知路径,因为那看起来最安全。

探索的产出不是「跑了多久」,而是「发现了几个可复现的问题」。没有发现的探索也有价值,但价值在于「这块区域暂时可信」,而不是「我们很努力」。

把用例选择写成可运行规则

下面的实现把状态空间、单值覆盖、覆盖率、风险排序、预算裁剪与依赖回归写成纯函数。

// file: src/pipeline/qa.ts
// tier: L1
// verify: node --test test/pipeline/qa.test.ts

// QA 用例生成:先把每个取值覆盖一次,再按风险补组合,最后按时间预算裁。
// 全组合是 216 条,边界与单值覆盖只要 16 条,先保证能跑完。

export type Dimension = {
  readonly name: string;
  readonly values: readonly string[];
};

export type Choice = Readonly<Record<string, string>>;

export type TestCase = {
  readonly id: string;
  readonly choices: Choice;
  readonly priority: 1 | 2 | 3;
};

export function stateSpace(dimensions: readonly Dimension[]): number {
  return dimensions.reduce((acc, dimension) => acc * dimension.values.length, 1);
}

export function baseline(dimensions: readonly Dimension[]): Choice {
  const choices: Record<string, string> = {};
  for (const dimension of dimensions) {
    choices[dimension.name] = dimension.values[0];
  }
  return choices;
}

// 单值覆盖:基线一条,再让每个维度各自取遍其余取值。组合数从乘积降到求和。
export function singleValueCases(
  dimensions: readonly Dimension[],
  priority: 1 | 2 | 3 = 2,
): TestCase[] {
  const base = baseline(dimensions);
  const cases: TestCase[] = [{ id: "baseline", choices: base, priority }];
  const seen = new Set([JSON.stringify(base)]);
  for (const dimension of dimensions) {
    for (const value of dimension.values) {
      const choices = { ...base, [dimension.name]: value };
      const key = JSON.stringify(choices);
      if (seen.has(key)) continue;
      seen.add(key);
      cases.push({ id: `${dimension.name}=${value}`, choices, priority });
    }
  }
  return cases;
}

// 覆盖率按「维度-取值」对计算,不按组合数:后者在维度多时会永远接近零。
export function coverage(cases: readonly TestCase[], dimensions: readonly Dimension[]): number {
  let total = 0;
  let covered = 0;
  for (const dimension of dimensions) {
    for (const value of dimension.values) {
      total += 1;
      const hit = cases.some((testCase) => testCase.choices[dimension.name] === value);
      if (hit) covered += 1;
    }
  }
  return total === 0 ? 0 : covered / total;
}

// 命中风险取值(存档损坏、越权、支付)的用例升到最高优先级,先跑。
export function prioritize(
  cases: readonly TestCase[],
  risky: ReadonlySet<string>,
): TestCase[] {
  return cases
    .map((testCase) => {
      const hit = Object.values(testCase.choices).some((value) => risky.has(value));
      return hit ? { ...testCase, priority: 1 as const } : testCase;
    })
    .sort((a, b) => a.priority - b.priority || a.id.localeCompare(b.id));
}

// 探索时间按小时给,换算成可执行条数;除不尽时向下取整,不虚报预算。
export function withinBudget(
  cases: readonly TestCase[],
  minutes: number,
  minutesPerCase = 8,
): TestCase[] {
  const limit = Math.floor(minutes / minutesPerCase);
  return [...cases].sort((a, b) => a.priority - b.priority).slice(0, limit);
}

// 回归不是全量:从改动模块出发,沿依赖图向外走 depth 跳,命中谁跑谁。
export function regressionSet(
  changed: readonly string[],
  dependencies: Readonly<Record<string, readonly string[]>>,
  depth = 1,
): string[] {
  const hit = new Set(changed);
  let frontier = [...changed];
  for (let hop = 0; hop < depth; hop += 1) {
    const next: string[] = [];
    for (const module of frontier) {
      for (const dependent of dependencies[module] ?? []) {
        if (!hit.has(dependent)) {
          hit.add(dependent);
          next.push(dependent);
        }
      }
    }
    frontier = next;
  }
  return [...hit].sort();
}

stateSpace 只做乘法,用来让人直观看到组合爆炸。它不参与选择,因为选择恰恰要避免按组合数思考。

baseline 取每维第一个取值。基线的选择会影响单值覆盖的具体用例,但不影响覆盖率;团队应把基线定在最常见的线上组合,这样 16 条里有一条直接对应主路径。

singleValueCases 用 JSON 序列化去重。某个维度取基线值时,生成的组合与基线相同,必须跳过,否则会多出一条重复用例。

用例 id 用「维度=取值」命名,而不是序号。序号在用例增删后会错位,名字不会;失败时也能一眼看出是哪个取值出的问题。

coverage 按维度-取值对计算,分母是所有对的数量。维度为空时返回 0,而不是 1,避免空集合被误判为「完全覆盖」。

prioritize 命中风险取值就升到 P0,并按优先级与 id 排序。排序保证重跑顺序一致,失败对比时才不会因为顺序不同而误判。

withinBudget 向下取整,并且先排序再切。如果先切再排序,会把后面的 P0 用例切掉,留下前面的 P2。

regressionSet 用广度优先走依赖图,depth 控制跳数。已经命中的模块不重复入队,避免环导致死循环。

Agent 生成用例的三条约束

模型生成用例很快,但生成的用例经常不可用。三条约束可以先筛掉大部分废品:

  • 可执行。 用例要能落到具体操作与具体环境,不能是「验证战斗正常」这种描述。
  • 可判定。 要有明确的通过条件,例如「结算面板显示的金币数与服务端一致」,而不是「表现合理」。
  • 可去重。 用例要有稳定的键,例如「维度=取值」组合,重复生成时能合并。

三条都满足的用例才进入候选池。候选池还要人工抽检,因为模型可能生成「可执行、可判定、但测的是无关功能」的用例。

生成用例的数量不是目标。一百条互相重复的用例,不如十六条覆盖全部取值的用例。

回归选择的三个坑

  • 按目录选。 目录是文件组织,不是影响范围,会漏掉跨目录依赖。
  • 按上次失败选。 只跑上次挂的用例,会把「上次碰巧通过」的新问题留到线上。
  • 按时间选。 有时间就多跑、没时间就少跑,覆盖范围随排期波动,无法比较。

三个坑的共同点是:选择标准与「这次改了什么」无关。回归的起点永远是改动,不是目录、历史或剩余时间。

小结

  • 三个维度各六个取值就是 216 种组合,全量跑不可行,随机抽样说不清覆盖。
  • 结构化选择分三步:单值覆盖、风险优先、时间预算。
  • 单值覆盖把组合数从乘积降到求和,16 条覆盖 18 个维度-取值对。
  • 覆盖率按维度-取值对算,不按组合数算,两种口径回答不同问题。
  • 风险分 P0、P1、P2,命中风险取值直接升 P0,风险清单要评审。
  • 预算按分钟算并向下取整,同时留出复现时间。
  • 回归按依赖图走一跳或两跳,涉及资金、身份、存档格式时人为放大范围。
  • 探索测试要有时间盒、章程与记录模板,Agent 不做章程制定者。
  • Agent 生成的用例必须可执行、可判定、可去重,再进入人工抽检。
  • 回归的起点是改动,不是目录、历史失败或剩余时间。

阅读导航:上一节:9.2 美术与音频的批处理一致性 · 下一节:10.1 活动与内容的生产化 。

常见错误与边界

  1. 承诺全量回归。 组合数随维度指数增长,承诺之后必然退化成挑着跑。
  2. 用随机抽样代替覆盖设计。 说不清覆盖了什么,两轮之间也无法比较。
  3. 覆盖率按组合数算。 16 条看起来只覆盖 7%,团队会误以为工作没做够。
  4. 风险清单全是 P0。 等于没有优先级,真正会赔钱的用例混在长队里。
  5. 按目录选回归。 跨目录依赖被漏掉,而且漏掉的部分不会报错。
  6. 让 Agent 自己定探索章程。 模型倾向重复已知路径,探索退化成走过场。

研发流程的 Agent 到这里告一段落。第 10 章把视角移到线上:活动怎么批量生产、玩家服务怎么分级接管、Agent 行为异常时怎么响应。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图