模拟与桩

作者：陈川阅读数：40362人阅读分类： Node.js

模拟与桩的概念

模拟（Mock）和桩（Stub）是测试中常用的两种技术手段，它们都能隔离被测代码的依赖，但侧重点不同。模拟更关注行为验证，而桩更关注状态控制。在Node.js中，这两种技术经常结合使用来构建可靠的测试套件。

模拟对象会记录调用信息，并在测试结束后验证这些调用是否符合预期。例如，检查某个函数是否被调用、调用次数以及参数是否正确。桩则是预先设定好的固定返回值，用于替代真实依赖的行为。

// 模拟示例
const mockFn = jest.fn();
mockFn('hello');
expect(mockFn).toHaveBeenCalledWith('hello');

// 桩示例
const stub = jest.fn().mockReturnValue(42);
expect(stub()).toBe(42);

Node.js中的测试框架支持

Jest和Sinon是Node.js生态中最常用的测试工具。Jest内置了丰富的模拟功能，而Sinon提供了更细粒度的控制。Mocha通常需要结合Sinon使用。

Jest的自动模拟功能可以轻松创建模块的模拟版本：

// userService.js
export default {
  getUser: async (id) => {
    // 实际实现
  }
};

// test.js
jest.mock('./userService');
import userService from './userService';

test('should mock module', async () => {
  userService.getUser.mockResolvedValue({id: 1, name: 'Mock User'});
  const user = await userService.getUser(1);
  expect(user.name).toBe('Mock User');
});

Sinon提供了三种测试替身：spies（监听函数调用）、stubs（替换函数实现）和mocks（组合功能）：

const sinon = require('sinon');
const fs = require('fs');

const readStub = sinon.stub(fs, 'readFile');
readStub.withArgs('/path/to/file').yields(null, 'file content');

fs.readFile('/path/to/file', (err, data) => {
  console.log(data); // 输出: file content
});

readStub.restore();

模拟HTTP请求

测试涉及HTTP请求的代码时，nock库可以拦截和模拟HTTP请求：

const nock = require('nock');
const axios = require('axios');

nock('https://api.example.com')
  .get('/users/1')
  .reply(200, { id: 1, name: 'John Doe' });

test('should mock HTTP request', async () => {
  const response = await axios.get('https://api.example.com/users/1');
  expect(response.data.name).toBe('John Doe');
});

对于更复杂的场景，可以模拟错误响应：

nock('https://api.example.com')
  .post('/users')
  .reply(500, { error: 'Internal Server Error' });

test('should handle HTTP errors', async () => {
  await expect(axios.post('https://api.example.com/users'))
    .rejects.toThrow('Request failed with status code 500');
});

数据库操作的模拟

测试数据库相关代码时，通常不希望实际连接数据库。可以使用内存数据库或专门的模拟库：

// 使用Jest模拟Mongoose模型
const mongoose = require('mongoose');
const User = mongoose.model('User');

jest.mock('../models/User');

test('should mock Mongoose model', async () => {
  User.findOne.mockResolvedValue({ _id: '123', name: 'Mock User' });
  
  const user = await User.findOne({ _id: '123' });
  expect(user.name).toBe('Mock User');
});

对于Sequelize，可以使用sequelize-mock：

const SequelizeMock = require('sequelize-mock');
const dbMock = new SequelizeMock();

const UserMock = dbMock.define('User', {
  name: 'John Doe',
  email: 'john@example.com'
});

test('should mock Sequelize model', async () => {
  const user = await UserMock.findOne();
  expect(user.name).toBe('John Doe');
});

事件系统的模拟

Node.js的事件系统（EventEmitter）也需要在测试中进行模拟：

const EventEmitter = require('events');
const emitter = new EventEmitter();

jest.spyOn(emitter, 'emit');

test('should verify event emission', () => {
  emitter.emit('data', { value: 42 });
  expect(emitter.emit).toHaveBeenCalledWith('data', { value: 42 });
});

对于更复杂的事件流测试，可以创建专门的模拟实现：

class MockStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
    return true;
  }
}

test('should test stream handling', () => {
  const stream = new MockStream();
  const callback = jest.fn();
  
  stream.on('data', callback);
  stream.write('test data');
  
  expect(callback).toHaveBeenCalledWith('test data');
});

定时器的模拟

测试涉及定时器的代码时，Jest提供了专门的定时器模拟功能：

jest.useFakeTimers();

test('should test setTimeout', () => {
  const callback = jest.fn();
  
  setTimeout(callback, 1000);
  jest.advanceTimersByTime(1000);
  
  expect(callback).toHaveBeenCalled();
});

对于更复杂的定时场景：

test('should test intervals', () => {
  const callback = jest.fn();
  
  setInterval(callback, 1000);
  jest.advanceTimersByTime(5000);
  
  expect(callback).toHaveBeenCalledTimes(5);
});

文件系统的模拟

Node.js的fs模块可以通过jest.mock进行整体模拟：

jest.mock('fs');

const fs = require('fs');

test('should mock fs.readFile', () => {
  fs.readFile.mockImplementation((path, encoding, callback) => {
    callback(null, 'mock file content');
  });
  
  fs.readFile('/path/to/file', 'utf8', (err, data) => {
    expect(data).toBe('mock file content');
  });
});

对于更精细的控制，可以使用memfs创建内存文件系统：

const { vol } = require('memfs');

beforeEach(() => {
  vol.reset();
  vol.mkdirpSync('/path/to');
  vol.writeFileSync('/path/to/file', 'content');
});

test('should use memory fs', () => {
  const content = vol.readFileSync('/path/to/file', 'utf8');
  expect(content).toBe('content');
});

模拟与桩的最佳实践

保持测试隔离：每个测试应该设置自己的模拟和桩，避免测试间相互影响
避免过度模拟：只模拟必要的依赖，保留尽可能多的真实实现
优先使用真实实现：当依赖足够简单且不会引入不确定性时，使用真实实现
命名清晰：给模拟和桩变量加上Mock/Stub后缀提高可读性

// 不好的做法
const user = jest.fn();

// 好的做法
const userMock = jest.fn();
const dbStub = sinon.stub(db, 'query');

及时清理：测试完成后恢复原始实现，避免影响其他测试

afterEach(() => {
  jest.clearAllMocks();
  sinon.restore();
});

高级模拟技巧

对于需要复杂行为的模拟，可以结合多个功能：

const complexMock = jest.fn()
  .mockImplementationOnce(() => 'first call')
  .mockImplementationOnce(() => { throw new Error('second call') })
  .mockImplementation(() => 'subsequent calls');

test('should use complex mock', () => {
  expect(complexMock()).toBe('first call');
  expect(() => complexMock()).toThrow('second call');
  expect(complexMock()).toBe('subsequent calls');
  expect(complexMock()).toBe('subsequent calls');
});

模拟模块的部分功能而保留其他真实实现：

jest.mock('some-module', () => {
  const originalModule = jest.requireActual('some-module');
  
  return {
    ...originalModule,
    unstableFunction: jest.fn()
  };
});

测试异步代码的模式

模拟异步操作时需要考虑各种场景：

// 模拟成功响应
apiMock.getUsers.mockResolvedValue([{id: 1}]);

// 模拟错误响应
apiMock.getUsers.mockRejectedValue(new Error('Network error'));

// 模拟延迟响应
apiMock.getUsers.mockImplementation(
  () => new Promise(resolve => 
    setTimeout(() => resolve([{id: 1}]), 100)
);

测试回调风格的异步代码：

test('should test callback', done => {
  fs.readFile('/path', 'utf8', (err, data) => {
    expect(data).toBe('expected content');
    done();
  });
  
  // 触发回调
  process.nextTick(() => 
    fs.readFile.mock.calls[0][2](null, 'expected content')
  );
});

模拟与桩的性能考量

虽然模拟和桩能提高测试速度，但也需要注意：

初始化开销：复杂的模拟设置会增加测试启动时间
维护成本：当被模拟的接口变化时，需要更新所有相关测试
测试价值：过度模拟可能导致测试无法发现真实集成问题

平衡建议：

单元测试：大量使用模拟和桩
集成测试：减少模拟，使用真实依赖
E2E测试：避免模拟，使用完整系统

模拟与桩的调试技巧

当测试失败时，可以检查模拟的状态：

console.log(mockFn.mock.calls);  // 查看所有调用记录
console.log(mockFn.mock.results); // 查看所有返回结果

Jest还提供了详细的模拟诊断信息：

expect(mockFn).toHaveBeenCalledTimes(3);
expect(mockFn).toHaveBeenLastCalledWith('expected-arg');

对于复杂的模拟场景，可以临时禁用自动模拟：

jest.dontMock('some-module');

模拟与桩的类型安全

在TypeScript项目中，需要保持模拟的类型正确：

const mockService: jest.Mocked<UserService> = {
  getUser: jest.fn().mockResolvedValue({id: 1, name: 'Test'})
} as any; // 有时需要类型断言

// 更好的做法是使用工具类型
type Mocked<T> = { [P in keyof T]: jest.Mock<T[P]> };
const mockService: Mocked<UserService> = {
  getUser: jest.fn()
};

对于Sinon的桩：

const stub = sinon.stub<[number], Promise<User>>();
stub.resolves({id: 1, name: 'Test'});

模拟与桩的边界情况

处理一些特殊场景需要特别注意：

模拟ES6类：需要同时模拟类和原型方法
模拟构造函数：需要跟踪实例创建
模拟第三方库：注意版本兼容性

// 模拟类示例
jest.mock('./Logger', () => {
  return jest.fn().mockImplementation(() => ({
    log: jest.fn(),
    error: jest.fn()
  }));
});

const Logger = require('./Logger');
const logger = new Logger();

test('should mock class', () => {
  logger.log('message');
  expect(Logger).toHaveBeenCalled();
  expect(logger.log).toHaveBeenCalledWith('message');
});

模拟与桩的常见陷阱

忘记恢复模拟：导致测试污染
过度指定验证：使测试过于脆弱
忽略异步性：未正确处理异步模拟
模拟过多层级：失去测试价值

// 反模式：过度指定
expect(mockFn).toHaveBeenCalledWith(
  expect.objectContaining({
    id: expect.any(Number),
    name: expect.stringMatching(/^[A-Z]/)
  })
);

// 更好的做法：只验证必要部分
expect(mockFn).toHaveBeenCalledWith(
  expect.objectContaining({ id: 1 })
);