单元测试框架

单元测试框架是软件开发中不可或缺的工具，它帮助开发者验证代码逻辑的正确性，确保每个独立模块按预期运行。在Node.js生态中，多种测试框架提供了丰富的功能，从基础断言到异步测试支持，覆盖不同场景需求。

常见的Node.js单元测试框架

Node.js社区提供了多个成熟的单元测试框架，每个框架各有特点。以下是几个主流选择：

1. Jest：Facebook开发的测试框架，内置断言库、Mock功能和覆盖率报告
2. Mocha：灵活的测试框架，需要搭配断言库如Chai使用
3. Ava：并行执行测试，专注于性能和简洁性
4. Tape：极简主义的测试框架，适合小型项目

这些框架都支持异步测试和Promise，但语法和配置方式有所不同。

Jest框架详解

Jest是目前Node.js生态中最流行的测试框架之一。它的零配置特性和丰富功能使其成为许多项目的首选。

基本测试示例

// sum.js
function sum(a, b) {
  return a + b;
}
module.exports = sum;

// sum.test.js
const sum = require('./sum');

test('adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
});

异步测试支持

Jest提供了多种方式处理异步代码：

// fetchData.js
async function fetchData() {
  return new Promise(resolve => {
    setTimeout(() => resolve('peanut butter'), 100);
  });
}

// fetchData.test.js
test('the data is peanut butter', async () => {
  const data = await fetchData();
  expect(data).toBe('peanut butter');
});

// 或者使用Promise语法
test('the data is peanut butter', () => {
  return fetchData().then(data => {
    expect(data).toBe('peanut butter');
  });
});

Mock功能

Jest的Mock系统非常强大，可以模拟函数、模块甚至定时器：

// timerGame.js
function timerGame(callback) {
  setTimeout(() => {
    callback && callback();
  }, 1000);
}

// timerGame.test.js
jest.useFakeTimers();

test('waits 1 second before ending the game', () => {
  const callback = jest.fn();
  timerGame(callback);
  
  expect(callback).not.toBeCalled();
  jest.advanceTimersByTime(1000);
  expect(callback).toBeCalled();
  expect(callback).toHaveBeenCalledTimes(1);
});

Mocha框架与Chai断言库

Mocha是另一个广泛使用的测试框架，它更加灵活但需要额外配置。

基本配置

// test/test.js
const assert = require('chai').assert;
const myModule = require('../myModule');

describe('myModule', function() {
  describe('#myFunction()', function() {
    it('should return true when passed true', function() {
      assert.isTrue(myModule.myFunction(true));
    });
    
    it('should handle async operations', function(done) {
      myModule.asyncFunction((result) => {
        assert.equal(result, 'expected');
        done();
      });
    });
  });
});

钩子函数

Mocha提供了多种钩子函数来控制测试流程：

describe('hooks', function() {
  before(function() {
    // 在所有测试之前运行
  });

  after(function() {
    // 在所有测试之后运行
  });

  beforeEach(function() {
    // 在每个测试之前运行
  });

  afterEach(function() {
    // 在每个测试之后运行
  });

  // 测试用例...
});

测试覆盖率报告

大多数测试框架都支持生成覆盖率报告。以Jest为例：

jest --coverage

这会生成一个详细的HTML报告，显示：

• 语句覆盖率
• 分支覆盖率
• 函数覆盖率
• 行覆盖率

测试最佳实践

测试组织结构

良好的测试组织结构能提高可维护性：

project/
├── src/
│   ├── moduleA.js
│   └── moduleB.js
└── test/
    ├── unit/
    │   ├── moduleA.test.js
    │   └── moduleB.test.js
    └── integration/
        └── integration.test.js

测试命名规范

清晰的测试名称有助于快速定位问题：

describe('UserService', () => {
  describe('createUser()', () => {
    it('should return user ID when valid email is provided', () => {
      // 测试代码
    });
    
    it('should throw error when email is invalid', () => {
      // 测试代码
    });
  });
});

测试数据库操作

测试数据库操作时，通常使用内存数据库或Mock：

// 使用内存SQLite测试Sequelize模型
const { Sequelize, DataTypes } = require('sequelize');

describe('User Model', () => {
  let sequelize;
  let User;
  
  beforeAll(async () => {
    sequelize = new Sequelize('sqlite::memory:');
    User = sequelize.define('User', {
      name: DataTypes.STRING,
      email: DataTypes.STRING
    });
    await sequelize.sync();
  });
  
  afterAll(async () => {
    await sequelize.close();
  });
  
  it('can create a user', async () => {
    const user = await User.create({ name: 'John', email: 'john@example.com' });
    expect(user.name).toBe('John');
  });
});

测试HTTP接口

对于HTTP接口测试，可以使用supertest库：

const request = require('supertest');
const app = require('../app');

describe('GET /users', () => {
  it('responds with JSON array', async () => {
    const response = await request(app)
      .get('/users')
      .expect('Content-Type', /json/)
      .expect(200);
      
    expect(Array.isArray(response.body)).toBeTruthy();
  });
});

性能测试考虑

虽然单元测试主要关注正确性，但有时也需要考虑性能：

test('performance test', () => {
  const start = performance.now();
  // 执行需要测试的代码
  const result = expensiveOperation();
  const end = performance.now();
  
  expect(result).toBeDefined();
  expect(end - start).toBeLessThan(100); // 确保执行时间小于100ms
});

测试环境配置

不同的测试环境可能需要不同的配置：

// jest.config.js
module.exports = {
  testEnvironment: 'node',
  coveragePathIgnorePatterns: [
    '/node_modules/',
    '/test/'
  ],
  setupFilesAfterEnv: ['./jest.setup.js']
};

// jest.setup.js
// 全局测试配置
beforeEach(() => {
  // 重置所有Mock
  jest.clearAllMocks();
});

持续集成中的测试

在CI环境中运行测试通常需要额外配置：

# .github/workflows/test.yml
name: Node.js CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v2
    - uses: actions/setup-node@v2
      with:
        node-version: '14'
    - run: npm install
    - run: npm test
    - run: npm run coverage