Node.js 集成测试

核心知识点

集成测试概念

集成测试是在单元测试的基础上，测试多个模块或组件之间的交互是否正常。与单元测试不同，集成测试不依赖于模拟（mock）和存根（stub），而是使用真实的依赖项进行测试。

集成测试的主要特点：

• 测试多个组件的协作
• 使用真实的外部依赖（如数据库、API）
• 测试应用的整体功能流程
• 发现单元测试无法发现的集成问题

集成测试类型

1. API 测试：测试 RESTful API 或 GraphQL API 的功能
2. 数据库测试：测试与数据库的交互，包括 CRUD 操作
3. 端到端测试：测试完整的用户流程，从前端到后端
4. 服务集成测试：测试微服务之间的通信

集成测试工具

• Jest：JavaScript 测试框架，可用于单元测试和集成测试
• Supertest：HTTP 断言库，用于测试 HTTP 服务器
• Puppeteer：Google Chrome 团队开发的无头浏览器工具，用于端到端测试
• Cypress：现代化的端到端测试框架
• Mocha + Chai：传统的测试框架组合

实用案例分析

案例 1：API 测试

使用 Jest 和 Supertest 测试 Express API。

项目结构

├── app.js          # Express 应用
├── routes/         # 路由
├── models/         # 数据模型
├── tests/          # 测试目录
│   └── integration/  # 集成测试
│       └── api.test.js  # API 测试
└── package.json

安装依赖

npm install --save-dev jest supertest

编写 API 测试

app.js

const express = require('express');
const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());

// 简单的用户 API
let users = [
  { id: 1, name: '张三' },
  { id: 2, name: '李四' }
];

// 获取所有用户
app.get('/api/users', (req, res) => {
  res.json(users);
});

// 获取单个用户
app.get('/api/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ message: '用户不存在' });
  res.json(user);
});

// 创建新用户
app.post('/api/users', (req, res) => {
  const newUser = {
    id: users.length + 1,
    name: req.body.name
  };
  users.push(newUser);
  res.status(201).json(newUser);
});

// 更新用户
app.put('/api/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ message: '用户不存在' });
  user.name = req.body.name;
  res.json(user);
});

// 删除用户
app.delete('/api/users/:id', (req, res) => {
  const userIndex = users.findIndex(u => u.id === parseInt(req.params.id));
  if (userIndex === -1) return res.status(404).json({ message: '用户不存在' });
  users.splice(userIndex, 1);
  res.json({ message: '用户已删除' });
});

if (require.main === module) {
  app.listen(port, () => {
    console.log(`服务器运行在 http://localhost:${port}`);
  });
}

module.exports = app;

tests/integration/api.test.js

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

describe('API 集成测试', () => {
  // 测试获取所有用户
  describe('GET /api/users', () => {
    it('应该返回所有用户', async () => {
      const response = await request(app).get('/api/users');
      expect(response.statusCode).toBe(200);
      expect(response.body).toHaveLength(2);
    });
  });

  // 测试获取单个用户
  describe('GET /api/users/:id', () => {
    it('应该返回指定 ID 的用户', async () => {
      const response = await request(app).get('/api/users/1');
      expect(response.statusCode).toBe(200);
      expect(response.body.name).toBe('张三');
    });

    it('应该返回 404 当用户不存在时', async () => {
      const response = await request(app).get('/api/users/999');
      expect(response.statusCode).toBe(404);
      expect(response.body.message).toBe('用户不存在');
    });
  });

  // 测试创建用户
  describe('POST /api/users', () => {
    it('应该创建新用户', async () => {
      const response = await request(app)
        .post('/api/users')
        .send({ name: '王五' });
      expect(response.statusCode).toBe(201);
      expect(response.body.name).toBe('王五');
      expect(response.body.id).toBe(3);
    });
  });

  // 测试更新用户
  describe('PUT /api/users/:id', () => {
    it('应该更新指定用户', async () => {
      const response = await request(app)
        .put('/api/users/1')
        .send({ name: '张三更新' });
      expect(response.statusCode).toBe(200);
      expect(response.body.name).toBe('张三更新');
    });

    it('应该返回 404 当更新不存在的用户时', async () => {
      const response = await request(app)
        .put('/api/users/999')
        .send({ name: '测试用户' });
      expect(response.statusCode).toBe(404);
      expect(response.body.message).toBe('用户不存在');
    });
  });

  // 测试删除用户
  describe('DELETE /api/users/:id', () => {
    it('应该删除指定用户', async () => {
      const response = await request(app).delete('/api/users/2');
      expect(response.statusCode).toBe(200);
      expect(response.body.message).toBe('用户已删除');
    });

    it('应该返回 404 当删除不存在的用户时', async () => {
      const response = await request(app).delete('/api/users/999');
      expect(response.statusCode).toBe(404);
      expect(response.body.message).toBe('用户不存在');
    });
  });
});

运行测试

npm test

案例 2：数据库集成测试

使用 Jest 测试与 MongoDB 的集成。

安装依赖

npm install --save-dev jest mongodb-memory-server mongoose

编写数据库测试

models/User.js

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  age: {
    type: Number,
    min: 0
  }
});

module.exports = mongoose.model('User', userSchema);

tests/integration/database.test.js

const mongoose = require('mongoose');
const { MongoMemoryServer } = require('mongodb-memory-server');
const User = require('../../models/User');

let mongoServer;

beforeAll(async () => {
  // 启动内存中的 MongoDB 服务器
  mongoServer = await MongoMemoryServer.create();
  const mongoUri = mongoServer.getUri();
  await mongoose.connect(mongoUri);
});

afterAll(async () => {
  // 关闭数据库连接和内存服务器
  await mongoose.disconnect();
  await mongoServer.stop();
});

describe('数据库集成测试', () => {
  // 测试创建用户
  it('应该创建新用户', async () => {
    const user = new User({
      name: '张三',
      email: 'zhangsan@example.com',
      age: 25
    });
    const savedUser = await user.save();
    expect(savedUser._id).toBeDefined();
    expect(savedUser.name).toBe('张三');
    expect(savedUser.email).toBe('zhangsan@example.com');
    expect(savedUser.age).toBe(25);
  });

  // 测试获取用户
  it('应该获取所有用户', async () => {
    // 先创建一些用户
    await User.create([
      { name: '李四', email: 'lisi@example.com', age: 30 },
      { name: '王五', email: 'wangwu@example.com', age: 35 }
    ]);
    
    const users = await User.find();
    expect(users).toHaveLength(3); // 包括之前创建的张三
  });

  // 测试更新用户
  it('应该更新用户信息', async () => {
    const user = await User.findOne({ name: '张三' });
    user.age = 26;
    const updatedUser = await user.save();
    expect(updatedUser.age).toBe(26);
  });

  // 测试删除用户
  it('应该删除用户', async () => {
    const user = await User.findOne({ name: '张三' });
    await user.deleteOne();
    const deletedUser = await User.findOne({ name: '张三' });
    expect(deletedUser).toBeNull();
  });

  // 测试验证
  it('应该在缺少必填字段时抛出错误', async () => {
    const user = new User({ name: '赵六' }); // 缺少 email
    await expect(user.save()).rejects.toThrow();
  });
});

案例 3：端到端测试

使用 Puppeteer 进行端到端测试。

安装依赖

npm install --save-dev jest puppeteer

编写端到端测试

tests/integration/e2e.test.js

const puppeteer = require('puppeteer');
const app = require('../../app');
let server;
let browser;
let page;

beforeAll(async () => {
  // 启动 Express 服务器
  server = app.listen(3001, () => {
    console.log('测试服务器运行在 http://localhost:3001');
  });

  // 启动 Puppeteer
  browser = await puppeteer.launch({
    headless: true, // 无头模式，不显示浏览器窗口
    slowMo: 20, // 减慢操作速度，便于观察
    args: ['--no-sandbox', '--disable-setuid-sandbox'] // 避免权限问题
  });

  // 创建新页面
  page = await browser.newPage();
});

afterAll(async () => {
  // 关闭浏览器和服务器
  await browser.close();
  server.close();
});

describe('端到端测试', () => {
  it('应该能够访问首页并查看标题', async () => {
    // 导航到测试服务器
    await page.goto('http://localhost:3001');
    
    // 获取页面标题
    const title = await page.title();
    console.log('页面标题:', title);
    
    // 这里可以添加更多测试逻辑，例如：
    // - 点击按钮
    // - 填写表单
    // - 验证页面内容
  });
});

集成测试最佳实践

1. 隔离测试环境：使用独立的测试数据库，避免影响生产数据
2. 测试前准备：在测试前设置必要的测试数据
3. 测试后清理：在测试后清理测试数据，保持环境干净
4. 测试顺序：确保测试之间的独立性，避免测试顺序依赖
5. 测试覆盖：重点测试关键业务流程和集成点
6. 测试速度：优化测试速度，避免过长的测试时间
7. 错误处理：测试错误情况，确保应用能够正确处理异常
8. 测试报告：生成详细的测试报告，便于分析测试结果

常见问题与解决方案

问题 1：测试速度慢

解决方案：

• 使用内存数据库（如 MongoDB Memory Server）
• 并行运行测试
• 优化测试代码，减少不必要的操作

问题 2：测试环境不一致

解决方案：

• 使用 Docker 容器化测试环境
• 使用环境变量管理配置
• 编写测试设置脚本，确保环境一致性

问题 3：测试依赖外部服务

解决方案：

• 对于关键服务，使用真实的测试实例
• 对于非关键服务，可以使用模拟服务
• 实现重试机制，处理临时的服务不可用

问题 4：测试数据管理复杂

解决方案：

• 使用测试数据工厂（如 Factory Bot）
• 实现测试数据清理策略
• 使用事务回滚，自动恢复测试前状态

总结

集成测试是保证应用质量的重要手段，它可以发现单元测试无法发现的集成问题。通过本文的学习，你应该：

1. 理解集成测试的概念和重要性
2. 掌握不同类型的集成测试方法
3. 学会使用 Jest、Supertest 和 Puppeteer 等测试工具
4. 能够编写 API 测试、数据库测试和端到端测试
5. 了解集成测试的最佳实践和常见问题解决方案

集成测试虽然比单元测试更复杂，但是它能够更全面地测试应用的功能，确保各个组件之间的协作正常。在实际开发中，应该结合单元测试和集成测试，构建完整的测试套件，提高应用的可靠性和可维护性。