测试策略制定

测试策略制定的核心目标

测试策略的核心在于明确测试范围、方法和资源分配。在Node.js项目中，测试策略需要针对异步特性、模块化架构和I/O密集型操作进行专门设计。有效的测试策略能够平衡测试覆盖率与执行效率，确保关键路径的可靠性。

Node.js测试分层策略

单元测试层

单元测试聚焦独立模块的功能验证。Jest和Mocha是常用框架，针对纯函数和独立类效果最佳。例如验证工具函数：

// utils/calculate.js
function calculateDiscount(price, discountRate) {
  if (discountRate < 0 || discountRate > 1) throw new Error('Invalid rate')
  return price * (1 - discountRate)
}

// __tests__/calculate.test.js
test('should apply 20% discount', () => {
  expect(calculateDiscount(100, 0.2)).toBe(80)
})

test('should reject invalid rates', () => {
  expect(() => calculateDiscount(100, 1.2)).toThrow()
})

集成测试层

重点验证模块间交互和外部服务集成。Supertest适合测试HTTP接口：

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

describe('GET /api/products', () => {
  it('should return paginated results', async () => {
    const res = await request(app)
      .get('/api/products?page=2')
      .expect('Content-Type', /json/)
      .expect(200)
    
    expect(res.body).toHaveProperty('meta.totalPages')
    expect(res.body.data).toBeInstanceOf(Array)
  })
})

E2E测试层

使用Cypress或Playwright验证完整用户流程：

// cypress/integration/checkout.spec.js
describe('Checkout Process', () => {
  it('completes purchase with guest account', () => {
    cy.visit('/products/123')
    cy.get('[data-testid="add-to-cart"]').click()
    cy.contains('Proceed to Checkout').click()
    cy.fillGuestForm()
    cy.selectPaymentMethod('credit_card')
    cy.contains('Order Confirmation').should('be.visible')
  })
})

异步代码测试策略

Promise处理

针对不同异步模式需要特定断言方式：

// 返回Promise的测试
test('fetches user data', () => {
  return fetchUser(123).then(data => {
    expect(data.id).toBe(123)
  })
})

// async/await语法
test('updates user profile', async () => {
  const result = await updateProfile({ name: 'New Name' })
  expect(result.success).toBeTruthy()
})

定时器模拟

使用Jest的假定时器测试延迟逻辑：

// services/notifier.js
async function delayedNotify(message, delayMs) {
  await new Promise(resolve => setTimeout(resolve, delayMs))
  sendNotification(message)
}

// __tests__/notifier.test.js
jest.useFakeTimers()
test('sends notification after delay', () => {
  const mockSend = jest.fn()
  sendNotification = mockSend
  
  delayedNotify('Test', 1000)
  jest.advanceTimersByTime(1000)
  
  expect(mockSend).toHaveBeenCalledWith('Test')
})

测试数据管理策略

工厂函数模式

创建可定制的测试数据：

// test/factories/user.js
const buildUser = (overrides = {}) => ({
  id: faker.datatype.uuid(),
  name: faker.name.fullName(),
  email: faker.internet.email(),
  ...overrides
})

// 测试用例中使用
test('handles premium users', () => {
  const user = buildUser({ isPremium: true })
  expect(hasPremiumAccess(user)).toBe(true)
})

数据库夹具

使用mongodb-memory-server进行隔离测试：

const { MongoMemoryServer } = require('mongodb-memory-server')

describe('UserRepository', () => {
  let mongoServer
  let repository

  beforeAll(async () => {
    mongoServer = await MongoMemoryServer.create()
    const uri = mongoServer.getUri()
    repository = new UserRepository(uri)
  })

  afterAll(async () => {
    await repository.disconnect()
    await mongoServer.stop()
  })

  test('saves and retrieves users', async () => {
    const testUser = { name: 'Test', email: 'test@example.com' }
    const saved = await repository.create(testUser)
    const found = await repository.findById(saved.id)
    expect(found.name).toBe(testUser.name)
  })
})

性能测试策略

基准测试

使用benchmark.js测量关键路径性能：

const Benchmark = require('benchmark')
const crypto = require('crypto')

new Benchmark.Suite()
  .add('SHA256', () => {
    crypto.createHash('sha256').update('test').digest('hex')
  })
  .add('MD5', () => {
    crypto.createHash('md5').update('test').digest('hex')
  })
  .on('cycle', event => {
    console.log(String(event.target))
  })
  .run()

压力测试

使用Artillery进行API负载测试：

# load-test.yml
config:
  target: "http://api.example.com"
  phases:
    - duration: 60
      arrivalRate: 50
scenarios:
  - flow:
      - get:
          url: "/products"
      - post:
          url: "/checkout"
          json:
            items: ["prod_123"]

测试环境差异化策略

环境敏感配置

使用dotenv管理测试环境变量：

// jest.config.js
module.exports = {
  setupFiles: ['<rootDir>/tests/setupEnv.js']
}

// tests/setupEnv.js
require('dotenv').config({ path: '.env.test' })

// .env.test
DB_URI=mongodb://localhost:27017/test_db
LOG_LEVEL=silent

服务模拟策略

根据环境切换真实服务或模拟器：

// config/test.js
module.exports = {
  paymentService: process.env.USE_REAL_PAYMENTS 
    ? require('../services/realPayment')
    : require('../mocks/paymentMock')
}

// 测试中明确声明
process.env.USE_REAL_PAYMENTS = 'true'

覆盖率分析策略

定制覆盖率标准

在jest配置中定义阈值：

// jest.config.js
module.exports = {
  coverageThreshold: {
    global: {
      branches: 80,
      functions: 85,
      lines: 90,
      statements: 90
    },
    'src/utils/': {
      branches: 100,
      lines: 100
    }
  }
}

路径排除策略

忽略无需测试的代码：

/* istanbul ignore next */
function deprecatedMethod() {
  console.warn('This will be removed in v2.0')
  // ...原有逻辑
}

持续集成策略

阶段化测试流程

GitLab CI示例配置：

stages:
  - test

unit_tests:
  stage: test
  image: node:16
  script:
    - npm run test:unit
    - npm run coverage:upload

integration_tests:
  stage: test
  services:
    - mongodb:4.4
  script:
    - npm run test:integration

e2e_tests:
  stage: test
  script:
    - npm run start:test-server &
    - npm run test:e2e

并行执行优化

利用Jest的shard参数：

# 在CI脚本中
jest --shard=1/3 & jest --shard=2/3 & jest --shard=3/3

错误追踪策略

错误注入测试

故意触发错误场景：

// tests/errorHandling.test.js
const mockRequest = () => {
  const req = { params: {}, body: {} }
  req.header = jest.fn().mockReturnValue('application/json')
  return req
}

test('handles DB connection errors', async () => {
  const req = mockRequest()
  const res = { status: jest.fn().mockReturnThis(), json: jest.fn() }
  const next = jest.fn()

  // 模拟数据库连接错误
  jest.spyOn(db, 'connect').mockRejectedValue(new Error('Connection failed'))
  
  await databaseMiddleware(req, res, next)
  expect(res.status).toHaveBeenCalledWith(503)
})

混沌工程

使用chaos-js引入随机故障：

const Chaos = require('chaos-js')

Chaos
  .experiment('Payment Service Resilience')
  .withService('payment')
  .method('processPayment')
  .errorRate(0.3) // 30%失败率
  .latency({ min: 100, max: 2000 }) // 随机延迟
  .start()