从方法表生成调用用例:组合类型变换

组合参数与返回类型、保留配对,并从方法表生成可筛选的测试条目。

本章目录CONTENTS ↓

API 已经定义了方法名、参数与返回类型。调用用例还要保存这些信息,能否让它自动跟随原声明,并排除非函数字段?手写每种用例会重复签名;把名称、参数和结果分别取联合,会允许三者交叉配对。

目标输出是一条条完整记录的联合。先选中一个键,确认该属性是函数,再同时提取它的参数和结果,把三者装进同一个成员,最后合并。这里学习类型计算;如何选择测试案例和验证行为,见软件设计中的实现验证。

完整模型:方法表到用例联合

type API = {
parse: (text: string) => number;
format: (value: number) => string;
version: string;
};
type FunctionApiCases<T> = {
[K in keyof T]: T[K] extends (...args: infer P) => infer R
? { name: K; test: { args: P; expected: R } }
: never
}[keyof T];
type ApiTest = FunctionApiCases<API>;
const parseCase: ApiTest = { name: "parse", test: { args: ["42"], expected: 42 } };
const formatCase: ApiTest = { name: "format", test: { args: [42], expected: "42" } };
// @ts-expect-error parse 的结果形状应该是 number
const crossed: ApiTest = { name: "parse", test: { args: ["42"], expected: "42" } };
// @ts-expect-error 非函数字段不生成测试条目
const config: ApiTest = { name: "version", test: { args: [], expected: "1" } };

这个模型检查测试数据的类型形状,无法证明 expected 是实际正确答案。比如 parse 返回 number,类型不会证明某个输入必须等于 42;这仍需执行行为测试。

把组合表达式读成处理过程

步骤 职责 parse 的结果
映射 K 逐个选择方法表的键。 K 为 "parse"。
匹配 T[K] 判断当前值是否为函数。 parse 匹配成功。
提取 P、R 从同一签名读取参数和返回类型。 [text: string] 与 number。
构造条目 把名称、参数、结果放进同一成员。 完整 parse 用例对象。
最后索引 合并条目值,消去 never。 parse 与 format 条目的联合。

这些操作解决不同问题:映射负责逐键,infer 负责提取,条件负责是否生成整个条目,索引负责取联合。表达式虽紧凑,推导时可以逐步命名和检查。

筛选要控制整个成员

如果把条件放进 test 属性,就会产生 { name: "version"; test: never }。它仍是一个对象类型,其 name 仍含 version;这不等于整个联合成员消失。

当前实现让不匹配的整个条目得到 never。中间映射仍有 version: never,最后索引得到条目联合时,never 才被消去。删除对象的键与筛选联合成员是不同目标。

函数联合需要保留每次匹配的配对

type CallCase<F> = F extends (...args: infer P) => infer R
? { args: P; expected: R }
: never;
type Convert = ((text: string) => number) | ((value: number) => string);
type Cases = CallCase<Convert>;
// { args: [text: string]; expected: number }
// | { args: [value: number]; expected: string }
type Loose = { args: Cases["args"]; expected: Cases["expected"] };
const allowedByLoose: Loose = { args: ["42"], expected: "42" };
// @ts-expect-error 完整联合成员不允许交叉配对
const rejectedByCases: Cases = { args: ["42"], expected: "42" };
type NoArgs = CallCase<() => number>; // { args: []; expected: number }
type NonFunction = CallCase<string>; // never

CallCase 的裸参数 F 会分配,所以先对每个函数生成完整配对,再合并。Loose 则拆散参数与结果后重新组合,丢失它们来自同一函数的信息。

上面的 FunctionApiCases 直接检查 T[K],不具有相同的裸参数分配形状。本章方法表限定必填属性、每个函数属性为单个普通签名;若属性本身是函数联合,需要重新设计并验证分配层次,不能把工具抽取当成无语义变化的整理。

异步方法:筛选并取 Promise 完成值

如果测试条目记录的是异步调用完成后的结果,要从函数返回的 Promise<R> 中取出 R。同一方法表中还可能有元数据和同步方法,应让这些条目的整个联合成员成为 never。

type Service = {
version: string;
load: (id: string) => Promise<{ id: string }>;
search: (query: string, limit?: number) => Promise<string[]>;
ping: () => boolean;
};
type AsyncCall<T> = {
[K in keyof T]: T[K] extends (...args: infer A) => Promise<infer R>
? { method: K; args: A; result: R }
: never
}[keyof T];
type Call = AsyncCall<Service>;
const load: Call = { method: "load", args: ["u1"], result: { id: "u1" } };
// @ts-expect-error load 的参数必须是 string
const wrong: Call = { method: "load", args: [1], result: { id: "u1" } };

映射中 version 和 ping 两个键仍存在,只是值为 never;最后索引取联合时,这两个值不贡献成员。infer A 提取整个参数元组,infer R 提取 Promise 的完成值,二者与方法名 K 留在同一条记录中。这个例子只匹配直接返回 Promise<R> 的普通方法;更广泛的 Promise 类结构与嵌套兑现可查阅 Awaited。

使用边界与后续设计

异步方法要先定义“预期值是 Promise 还是兑现后的值”;上面的 AsyncCall 选择后者。重载、泛型函数也不保证可以完整提取所有关系,遇到时需检查具体声明与最小调用。

本章建立用例模型,没有实现通用测试运行器。机制回查:infer、分配、映射;官方入口:Conditional Types、Utility Types。回到全景。

这一页,先记到这里。