各位观众老爷们，晚上好！我是今天的讲座主持人，人称Bug终结者，今天咱们聊点高阶的，关于JavaScript里的Property-Based Testing，也就是基于属性的测试，以及神器fast-check。
开场白：传统测试的痛点
咱们先说说传统测试，也就是单元测试，集成测试，它就像是咱们精心准备的考试，老师出了几道题，咱们吭哧吭哧地算，算对了就万事大吉。但是，问题在于：
- 题目的覆盖面有限： 老师再厉害，也可能漏掉一些奇葩的边界条件，或者意想不到的输入组合。
- 重复劳动： 很多时候，咱们都在写重复的代码，比如测试各种无效的输入。
- 难以发现隐藏的Bug： 有些Bug隐藏得很深，只有在特定的输入组合下才会触发，靠手写测试用例很难发现。
Property-Based Testing：让机器来出题！
Property-Based Testing，简称PBT，就像是咱们雇了个超级监考员，让它随机生成各种各样的试题，然后咱们验证程序的答案是否符合预期的“属性”。
什么是属性（Property）？
属性不是指某个具体的值，而是一种普遍适用的规则。举个例子：
- 加法交换律：
a + b应该等于b + a。 - 排序的稳定性： 排序后，相同的元素之间的相对位置应该不变。
- 反序列化再序列化： 把一个对象序列化成字符串，再反序列化回来，应该和原来的对象相等。
fast-check：PBT的瑞士军刀
fast-check 是一个强大的 JavaScript 库，专门用来做 Property-Based Testing。它能自动生成各种各样的测试数据，然后咱们用断言来验证属性是否成立。
fast-check 的基本用法
首先，安装 fast-check：
npm install fast-check --save-dev然后，咱们来写一个简单的例子，验证加法交换律：
const fc = require('fast-check');
const assert = require('assert');
describe('加法交换律', () => {
it('任意两个数字 a 和 b，a + b 应该等于 b + a', () => {
fc.assert(
fc.property(fc.integer(), fc.integer(), (a, b) => {
assert.strictEqual(a + b, b + a);
})
);
});
});代码解释：
fc.integer()：这是一个 Arbitrary，表示生成任意整数。fc.property(fc.integer(), fc.integer(), (a, b) => { ... })：这是一个 Property，它接受两个 Arbitrary 作为输入，并定义了一个断言函数。assert.strictEqual(a + b, b + a)：这就是断言，用来验证加法交换律是否成立。fc.assert(...)：运行测试，fast-check会自动生成很多组a和b的值，然后执行断言函数。如果断言失败，fast-check会缩小测试用例，找到导致失败的最小输入。
fast-check 的优势
- 自动化测试数据生成： 省去了手动编写大量测试用例的麻烦。
- 覆盖面更广： 能够发现隐藏的边界条件和 corner cases。
- 缩小测试用例： 当断言失败时，
fast-check会自动缩小测试用例，帮助咱们更快地定位 Bug。 - 提高代码质量： 迫使咱们思考代码的属性，从而写出更健壮、更可靠的代码。
生成复杂的测试数据：Arbitrary 的魔力
fast-check 提供了很多内置的 Arbitrary，比如 fc.integer()，fc.string()，fc.boolean() 等。但是，有时候咱们需要生成更复杂的测试数据，比如对象、数组、树等等。这时候，就需要自定义 Arbitrary。
自定义 Arbitrary 的方法
fast-check 提供了多种方式来创建 Arbitrary：
fc.constant(value)： 生成固定的值。fc.oneof(arbitrary1, arbitrary2, ...)： 从多个 Arbitrary 中随机选择一个。fc.array(arbitrary)： 生成数组，数组的元素由指定的 Arbitrary 生成。fc.record(schema)： 生成对象，对象的属性由 schema 定义。fc.tuple(arbitrary1, arbitrary2, ...)： 生成元组，元组的元素由指定的 Arbitrary 生成。fc.option(arbitrary)： 生成可选值，可以是arbitrary的值，也可以是null或undefined。fc.frequency(frequency1, arbitrary1, frequency2, arbitrary2, ...)： 根据给定的频率，从多个 Arbitrary 中随机选择一个。fc.map(arbitrary, f)： 对arbitrary生成的值进行转换。fc.filter(arbitrary, predicate)： 过滤arbitrary生成的值，只保留满足predicate的值。fc.chain(arbitrary, f)： 依赖于arbitrary生成的值，动态生成新的 Arbitrary。fc.letrec(definition): 定义递归 Arbitrary。
实例演示：生成复杂的对象
假设咱们要测试一个处理用户信息的函数，用户信息包含以下字段：
id：整数，唯一标识。name：字符串，用户名。email：字符串，邮箱地址。age：整数，年龄，可选。address：对象，地址信息，包含city和street两个字段。
咱们可以这样定义 Arbitrary：
const fc = require('fast-check');
const addressArbitrary = fc.record({
city: fc.string(),
street: fc.string(),
});
const userArbitrary = fc.record({
id: fc.integer(),
name: fc.string(),
email: fc.string(),
age: fc.option(fc.integer()), // 年龄可选
address: addressArbitrary,
});
describe('用户信息处理', () => {
it('测试用户信息', () => {
fc.assert(
fc.property(userArbitrary, (user) => {
// 在这里写断言，验证用户信息是否符合预期
console.log(user); // 打印生成的用户信息，方便调试
assert.ok(typeof user.id === 'number');
assert.ok(typeof user.name === 'string');
assert.ok(typeof user.email === 'string');
if (user.age !== null && user.age !== undefined) {
assert.ok(typeof user.age === 'number');
}
assert.ok(typeof user.address === 'object');
assert.ok(typeof user.address.city === 'string');
assert.ok(typeof user.address.street === 'string');
// 邮箱验证
if(user.email){
assert.ok(user.email.includes('@'))
}
})
);
});
});这个例子展示了如何使用 fc.record 和 fc.option 来生成复杂的对象。
实例演示：生成二叉树
生成二叉树稍微复杂一些，需要用到 fc.letrec，因为二叉树的定义是递归的。
const fc = require('fast-check');
const treeArbitrary = fc.letrec(tie => ({
tree: fc.oneof(
fc.constant(null), // 空树
fc.record({
value: fc.integer(),
left: tie('tree'), // 递归定义左子树
right: tie('tree'), // 递归定义右子树
})
)
})).tree;
describe('二叉树', () => {
it('测试二叉树', () => {
fc.assert(
fc.property(treeArbitrary, (tree) => {
// 在这里写断言，验证二叉树是否符合预期
console.log(tree); // 打印生成的二叉树，方便调试
if (tree === null) {
return; // 空树，直接返回
}
assert.ok(typeof tree.value === 'number');
// 递归验证左子树和右子树
function validateNode(node) {
if (node === null) {
return;
}
assert.ok(typeof node.value === 'number');
validateNode(node.left);
validateNode(node.right);
}
validateNode(tree.left);
validateNode(tree.right);
})
);
});
});代码解释：
fc.letrec(tie => { ... })：定义递归 Arbitrary。tie是一个函数，用来引用递归定义的 Arbitrary。tie('tree')：引用名为'tree'的 Arbitrary，也就是当前正在定义的 Arbitrary。fc.oneof(fc.constant(null), fc.record({ ... }))：二叉树可以是空树，也可以是一个节点，节点包含value，left和right三个字段。fc.record({ value: fc.integer(), left: tie('tree'), right: tie('tree') })：节点的left和right字段都是递归定义的二叉树。
缩小测试用例（Shrinking）
当 fast-check 发现断言失败时，它会自动缩小测试用例，找到导致失败的最小输入。这个过程叫做 Shrinking。
Shrinking 的原理是：fast-check 会尝试生成更小的、更简单的测试数据，直到找到一个仍然能导致断言失败的最小输入。
举个例子，如果咱们测试一个排序算法，发现对一个包含 1000 个元素的数组进行排序时会出错，fast-check 会尝试生成更小的数组，比如包含 500 个元素，250 个元素，直到找到一个包含最少元素的数组，仍然能导致排序出错。
高级技巧
-
约束条件（Constraints）： 可以使用
fc.filter来限制生成的测试数据，比如只生成正数，或者只生成长度大于 10 的字符串。const positiveIntegerArbitrary = fc.integer().filter(n => n > 0); -
依赖关系（Dependencies）： 可以使用
fc.chain来生成依赖于其他值的测试数据。比如，生成一个字符串，然后生成一个该字符串的子串。const stringArbitrary = fc.string(); const substringArbitrary = stringArbitrary.chain(str => { const start = fc.integer(0, str.length - 1); const end = fc.integer(start, str.length); return fc.tuple(fc.constant(str), start, end); }).map(([str, start, end]) => str.substring(start, end)); -
自定义 Shrinking： 如果
fast-check的默认 Shrinking 策略不满足需求，可以自定义 Shrinking 策略。 -
组合多个 Arbitrary： 可以使用
fc.tuple和fc.record来组合多个 Arbitrary，生成更复杂的测试数据。 -
使用
fc.context()进行调试: 在属性函数中调用fc.context()可以记录信息，这些信息会在测试失败时显示出来，方便调试。fc.assert( fc.property(fc.integer(), fc.integer(), (a, b, ctx) => { ctx.log(`a = ${a}, b = ${b}`); assert.strictEqual(a + b, b + a); }) );
PBT 的适用场景
PBT 并不是万能的，它更适合以下场景：
- 需要测试大量输入的情况： 比如测试一个解析器，需要测试各种各样的输入字符串。
- 逻辑复杂的算法： 比如排序算法，搜索算法。
- 状态相关的系统： 比如状态机，需要测试各种状态转换。
- 需要保证某些属性成立的情况： 比如加法交换律，排序的稳定性。
PBT 的局限性
- 需要定义属性： 定义属性需要一定的思考和抽象能力。
- 可能需要编写复杂的 Arbitrary： 生成复杂的测试数据可能需要编写复杂的 Arbitrary。
- 难以测试副作用： PBT 更适合测试纯函数，对于有副作用的函数，测试起来比较麻烦。
- 测试速度可能较慢： 生成大量测试数据可能会导致测试速度较慢。
总结
Property-Based Testing 是一种强大的测试方法，它可以帮助咱们发现隐藏的 Bug，提高代码质量。fast-check 是一个优秀的 JavaScript 库，专门用来做 PBT。
掌握 fast-check 的基本用法，学会自定义 Arbitrary，可以帮助咱们更好地利用 PBT 来测试 JavaScript 代码。
希望今天的讲座对大家有所帮助！咱们下期再见！