测试用例里的数据,最开始可能只是几个硬编码的对象。但随着功能变多,你可能会发现,每个用例都要手动拼一份数据,改一个字段,就要翻遍所有文件。更可怕的是,随机生成的数据让测试时好时坏,而共用的数据被一个用例改坏,后面的用例全跟着遭殃。
一、数据堆积,到底卡在哪
在写测试的时候,我们经常面临一个尴尬的局面:明明只是一个小改动,却要花半天时间去改测试数据。这种痛苦,往往来自下面三个地方。
1.1 硬编码带来的复制粘贴灾难
很多新手写测试,习惯直接写一个对象字面量。比如测试一个用户模块,你会写出这样的代码:
// 技术栈:JavaScript + Jest
const user = {
id: 1,
name: '张三',
age: 28,
email: 'zhangsan@example.com',
role: 'admin'
};
test('用户名字应该正确显示', () => {
expect(formatName(user)).toBe('张三');
});
看起来没问题。但下一个用例可能需要一个普通用户,你只能再复制一份,把 role 改成 'user'。等测试文件越来越大,你可能会复制出几十份几乎一样的数据。最要命的是,有一天你发现用户字段里需要新增一个 'status' 字段,你只能一个文件一个文件地改,改到怀疑人生。
1.2 随机数据带来的不确定噩梦
有些人觉得硬编码太死板,就引入随机数据生成。比如用 faker 生成名字、邮箱。听起来很美,但随机数据有一个致命的缺陷:它不稳定。你这次跑测试通过了,下次跑可能就失败。比如你生成了一个很长的字符串,刚好触发了数据库字段长度限制,或者生成了一个奇怪的字符,导致断言失败。这种“时灵时不灵”的测试,比没有测试还让人头大。
1.3 共享数据的隐性污染
还有一种情况,多个用例共用同一个数据对象。比如你在文件顶部定义了一个 let testUser = createUser(),然后第一个用例修改了 testUser.name,第二个用例本来期望 testUser.name 是默认值,结果发现被改掉了。这就是共享数据带来的污染。如果你不处理,这种问题会像传染病一样蔓延。
二、工厂函数:给数据一个“流水线”
面对上面的乱局,我们最先想到的解决办法,就是给数据生产建一条“流水线”,这就是工厂函数。
2.1 从对象字面量到工厂函数
所谓工厂函数,就是一个普通函数,每次调用都会返回一个全新的对象。这样,每个用例都能拿到一份独立的数据,互不干扰。我们来看一个最简单的例子:
// 技术栈:JavaScript + Jest
function createUser(overrides = {}) {
return {
id: 1,
name: '张三',
age: 28,
email: 'zhangsan@example.com',
role: 'admin',
...overrides
};
}
test('默认用户是管理员', () => {
const user = createUser();
expect(user.role).toBe('admin');
});
test('可以覆盖角色为普通用户', () => {
const user = createUser({ role: 'user' });
expect(user.role).toBe('user');
});
这个 createUser 函数接收一个 overrides 参数,用来覆盖默认值。这样,你在写用例时,只需要指定和默认值不同的字段,其他字段都自动填充。比如想创建一个年龄为 30 的用户,你只需要写 createUser({ age: 30 }),而不是把整个对象重新写一遍。
2.2 支持覆盖字段,灵活调整
工厂函数的精髓,在于“默认值 + 覆盖值”的组合。这样既保留了默认数据的完整性,又允许你按需修改。但要注意,如果你的数据结构里包含嵌套对象,直接展开 ...overrides 可能会出问题。比如:
// 技术栈:JavaScript + Jest
function createOrder() {
return {
id: 100,
customer: {
name: '李四',
phone: '13800138000'
},
items: [
{ sku: 'A001', price: 50 },
{ sku: 'B002', price: 30 }
]
};
}
test('订单包含客户信息', () => {
const order = createOrder();
expect(order.customer.name).toBe('李四');
});
test('可以覆盖客户手机号', () => {
const order = createOrder({
customer: { ...createOrder().customer, phone: '13999999999' }
});
expect(order.customer.phone).toBe('13999999999');
});
你看,覆盖嵌套字段时,你需要手动展开原来的 customer 对象。这虽然有点繁琐,但相比硬编码已经好很多。为了简化,你可以写一个工具函数做深合并,但这里我们不展开,以免偏离主题。
2.3 组合工厂,应对复杂结构
当你的数据结构越来越复杂,单个工厂函数会变得臃肿。这时,你可以用“组合工厂”的方式,把不同的子工厂拼起来。比如一个订单,里面包含用户和商品,你可以分别定义 createUser 和 createProduct,然后再组合成 createOrder:
// 技术栈:JavaScript + Jest
function createUser(overrides = {}) {
return { id: 1, name: '张三', email: 'zhangsan@example.com', ...overrides };
}
function createProduct(overrides = {}) {
return { sku: 'SKU-001', name: '咖啡杯', price: 45, ...overrides };
}
function createOrder(overrides = {}) {
return {
id: 100,
user: createUser(),
items: [createProduct(), createProduct({ sku: 'SKU-002', name: '马克杯' })],
...overrides
};
}
test('订单包含默认用户和两个商品', () => {
const order = createOrder();
expect(order.items).toHaveLength(2);
expect(order.user.name).toBe('张三');
});
组合工厂的好处是,你可以在保持默认结构的同时,针对某个子对象做精细覆盖。比如 createOrder({ user: createUser({ name: '王五' }) }),就能快速创建一个订单,用户名叫王五。
三、固定种子:把随机变成可控
工厂函数解决了数据复用和污染的问题,但还没解决随机数据的“不确定噩梦”。我们能不能让随机数据在每次测试时都一样,同时又看起来像是随机的?答案就是“固定种子”。
3.1 随机数据的诱惑与陷阱
随机数据本身不是坏事,它能帮我们发现一些边界情况。但测试的原则是“可重复”,也就是你跑一百次测试,结果应该一致。如果不加控制,随机数生成器每次都会产生不同的数据,那你的测试可能今天通过,明天失败。这对团队协作是灾难性的。
3.2 用种子生成确定性伪随机
解决这个问题的办法,是使用“伪随机数生成器”,它接受一个种子值,然后根据种子生成一串看似随机但完全确定的数字。只要种子相同,生成的结果就相同。JavaScript 里没有内置的伪随机生成器,但我们可以自己写一个简单的:
// 技术栈:JavaScript + Jest
function createSeededRandom(seed) {
let s = seed;
return function() {
s = (s * 9301 + 49297) % 233280;
return s / 233280;
};
}
test('相同种子生成相同随机数', () => {
const rand1 = createSeededRandom(42);
const rand2 = createSeededRandom(42);
expect(rand1()).toBe(rand2());
});
这个函数通过一个线性同余算法,保证种子相同,返回的序列也相同。你在测试里用 createSeededRandom(42) 来生成随机数,就再也不用担心随机数变了。
3.3 在工厂函数里集成种子
你可以把种子生成器集成到工厂函数中,让工厂函数根据种子生成稳定的数据。比如:
// 技术栈:JavaScript + Jest
function createSeededRandom(seed) {
let s = seed;
return function() {
s = (s * 9301 + 49297) % 233280;
return s / 233280;
};
}
function createUser(overrides = {}, seed = 42) {
const random = createSeededRandom(seed);
const id = Math.floor(random() * 1000) + 1;
const age = Math.floor(random() * 50) + 18;
return {
id,
name: `用户${id}`,
age,
email: `user${id}@example.com`,
...overrides
};
}
test('使用固定种子生成稳定用户', () => {
const user1 = createUser({}, 42);
const user2 = createUser({}, 42);
expect(user1.id).toBe(user2.id);
expect(user1.age).toBe(user2.age);
});
注意,这里我们将种子作为第二个参数传入,默认 42。这样,每个测试只要不指定种子,就会得到同样的“随机”数据。如果你想测试不同的边界,可以传不同的种子。
四、状态复位:让用例之间互不干扰
即使你用工厂函数生成了新对象,但如果这些对象引用了一些全局状态(比如数据库连接、内存缓存、全局变量),它们仍然可能互相影响。这时,你需要做“状态复位”。
4.1 共享数据为什么危险
在 Jest 中,测试文件里的顶层变量是共享的。如果你在 beforeEach 里不清理,上一次测试留下的数据会污染下一次测试。比如:
// 技术栈:JavaScript + Jest
let currentUser = null;
beforeEach(() => {
currentUser = createUser(); // 每次测试前都重新赋值
});
test('默认用户是管理员', () => {
currentUser.role = 'admin';
expect(currentUser.role).toBe('admin');
});
test('用户角色不应被污染', () => {
// 如果上一个测试修改了 currentUser 的 role,这里就会出问题
expect(currentUser.role).toBe('admin');
});
上面的代码,因为每个测试前都重新调用 createUser(),所以 currentUser 是一个全新的对象,上一个测试的修改不会保留。但如果你在测试文件顶部直接定义 const user = createUser(),那么所有测试共用同一个对象,修改就会相互影响。
4.2 beforeEach 与 afterEach 的配合
Jest 提供了 beforeEach 和 afterEach 钩子,用来在测试前后做清理工作。对于数据库、文件系统、全局变量等,你需要在 afterEach 里恢复原状,或者在 beforeEach 里重新初始化。比如:
// 技术栈:JavaScript + Jest
let dbData = [];
beforeEach(() => {
dbData = []; // 清空数据库模拟数据
jest.clearAllMocks();
});
afterEach(() => {
dbData = [];
});
这样,每个用例开始时,数据都是干净的。如果你的测试涉及真实数据库,你需要用 beforeAll 创建连接,afterAll 关闭连接,并在 afterEach 中回滚事务。
4.3 工厂函数与状态复位的完美结合
最理想的组合是:工厂函数负责生成全新的数据对象,而 beforeEach 负责把全局状态复位。这样,你既不用担心对象被修改,也不用担心全局变量被污染。我们来看一个完整的例子:
// 技术栈:JavaScript + Jest
function createUser(overrides = {}) {
return {
id: 1,
name: '张三',
role: 'admin',
...overrides
};
}
let userRepository = null;
beforeEach(() => {
// 每次测试前,都新建一个空的仓库
userRepository = {
users: [],
add(user) { this.users.push(user); },
find(id) { return this.users.find(u => u.id === id); }
};
});
test('添加用户到仓库', () => {
const user = createUser({ id: 2, name: '李四' });
userRepository.add(user);
expect(userRepository.find(2).name).toBe('李四');
});
test('仓库初始为空', () => {
expect(userRepository.users).toHaveLength(0);
});
在这个例子里,userRepository 是模拟的数据库层。beforeEach 每次都重新初始化,所以两个测试之间没有任何数据残留。而工厂函数 createUser 保证每个测试拿到的用户对象都是独立的新对象。
五、技术优缺点
到这里,我们已经把“工厂函数 + 固定种子 + 状态复位”这套组合拳介绍完了。下面来聊一聊它们的优缺点。
5.1 优点
- 可读性高:工厂函数把默认数据集中在一个地方,你一眼就能看出测试数据的结构,不用翻遍整个文件。
- 复用性强:同一个工厂可以被多个测试文件引用,减少重复代码。
- 可预测性高:固定种子让随机数据变成确定性数据,测试结果稳定。
- 隔离性好:状态复位确保每个用例从干净状态开始,避免隐性污染。
- 维护成本低:当业务字段变化时,你只需要改工厂函数一处,所有测试自动更新。
5.2 缺点
- 学习成本:对新手来说,理解“工厂函数”“种子”这些概念需要一点时间。
- 过度设计风险:如果测试数据很简单,强行引入工厂函数反而显得繁琐。
- 种子算法有局限:简单的线性同余算法可能无法覆盖所有边界情况,你需要根据实际需求选择合适的伪随机算法。
- 状态复位不能解决所有问题:比如你依赖外部服务,那
beforeEach只能清理本地状态,无法回滚外部服务的副作用。
六、注意事项
使用这套方案时,有几个细节需要特别注意。
6.1 不要过度设计
如果你的测试数据只有两三个字段,而且永远不会变,那直接用对象字面量也没问题。工厂函数的目的是“复用”和“可维护”,而不是为了炫技。如果一个工厂函数只有一个地方用到,那它可能就不需要存在。
6.2 工厂函数命名要清晰
命名最好能反映业务含义,比如 createUser、createOrder、createProduct。不要用 makeData、getObj 这种模糊的名字,否则同事看到会一头雾水。
6.3 种子库的选择与维护
我们上面手写了一个简单的伪随机生成器,但实际项目中,你可以使用像 seedrandom 这样的成熟库,它支持多种算法,而且可以序列化。注意,一旦你使用了种子,就不要在测试中随意改动种子的生成逻辑,否则之前依赖种子的测试结果都会改变,导致大量失败。
6.4 不要忽略业务约束
测试数据不仅要看起来像,还要符合业务规则。比如年龄不能为负数,邮箱格式要正确。如果工厂函数里写了不合理的默认值,会让测试通过但业务逻辑却可能崩溃。所以,工厂函数里的默认值,一定要来自真实业务场景,而不是拍脑袋。
6.5 保持测试数据的最小化
有些开发者喜欢把对象填得满满当当,认为字段越多越真实。其实,测试数据越精简越好。因为多余的字段会增加维护成本,也会让测试用例变得难以理解。你只需要覆盖当前用例关心的字段即可。
七、文章总结
测试夹具的混乱,往往源于数据复用不当、随机数据不可控、共享状态被污染。工厂函数帮我们把数据生产变成一条标准流水线,每个用例都能拿到独立的新对象;固定种子让随机数据变得可预测,保证测试的可重复性;状态复位则通过 beforeEach / afterEach 清理全局状态,防止用例之间互相干扰。这三者结合起来,能让你的测试数据治理变得井井有条。
记住,工具是为了服务人,而不是为了制造麻烦。当你觉得测试数据越来越乱时,不妨先停下来,看看是不是该用工厂函数了。
评论
围绕“用例数据越堆越乱无从维护?用工厂函数配合 Jest 组织测试夹具,从随机数据、固定种子到状态复位的成体系治理办法”参与讨论