测试用例里的数据,最开始可能只是几个硬编码的对象。但随着功能变多,你可能会发现,每个用例都要手动拼一份数据,改一个字段,就要翻遍所有文件。更可怕的是,随机生成的数据让测试时好时坏,而共用的数据被一个用例改坏,后面的用例全跟着遭殃。

一、数据堆积,到底卡在哪

在写测试的时候,我们经常面临一个尴尬的局面:明明只是一个小改动,却要花半天时间去改测试数据。这种痛苦,往往来自下面三个地方。

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 清理全局状态,防止用例之间互相干扰。这三者结合起来,能让你的测试数据治理变得井井有条。

记住,工具是为了服务人,而不是为了制造麻烦。当你觉得测试数据越来越乱时,不妨先停下来,看看是不是该用工厂函数了。