软件测试策略：从单元测试到端到端测试

测试是保证软件质量的重要手段，但很多开发者对测试策略缺乏系统了解。本文将全面介绍软件测试的各种类型和策略，包括单元测试、集成测试、端到端测试、性能测试、安全测试等。文章还会分享测试框架的选择、测试用例设计、测试覆盖率分析、持续集成中的测试策略等。通过学习这些知识，你可以建立更加完善的测试体系，提高代码质量和开发效率。

一、测试金字塔

1.1 测试层次

测试金字塔描述了不同类型测试的理想比例：

单元测试（70%）：快速、独立、可重复
集成测试（20%）：测试组件间的交互
端到端测试（10%）：测试完整的用户流程

1.2 为什么遵循测试金字塔

单元测试运行速度快，反馈及时
集成测试覆盖组件交互
端到端测试确保系统整体功能
合理的测试比例提高开发效率

二、单元测试

2.1 单元测试基础

// 使用Jest
describe('Calculator', () => {
    let calculator;
    
    beforeEach(() => {
        calculator = new Calculator();
    });
    
    test('should add two numbers', () => {
        const result = calculator.add(2, 3);
        expect(result).toBe(5);
    });
    
    test('should subtract two numbers', () => {
        const result = calculator.subtract(5, 3);
        expect(result).toBe(2);
    });
    
    test('should throw error for invalid input', () => {
        expect(() => calculator.add('a', 'b')).toThrow();
    });
});

2.2 测试替身

// Mock函数
const mockFn = jest.fn();
mockFn('arg1', 'arg2');
expect(mockFn).toHaveBeenCalledWith('arg1', 'arg2');

// Mock模块
jest.mock('./api');
const api = require('./api');
api.getUser.mockResolvedValue({ id: 1, name: 'John' });

// Spy函数
const spy = jest.spyOn(calculator, 'add');
calculator.add(2, 3);
expect(spy).toHaveBeenCalled();
spy.mockRestore();

三、集成测试

3.1 API集成测试

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

describe('User API', () => {
    test('should create a new user', async () => {
        const response = await request(app)
            .post('/api/users')
            .send({
                name: 'John Doe',
                email: 'john@example.com'
            })
            .expect(201);
        
        expect(response.body).toHaveProperty('id');
        expect(response.body.name).toBe('John Doe');
    });
    
    test('should get user by id', async () => {
        const response = await request(app)
            .get('/api/users/1')
            .expect(200);
        
        expect(response.body).toHaveProperty('name');
    });
});

3.2 数据库集成测试

// 使用测试数据库
beforeAll(async () => {
    await connectToTestDatabase();
});

afterAll(async () => {
    await closeTestDatabase();
});

beforeEach(async () => {
    await clearTestDatabase();
});

test('should save user to database', async () => {
    const user = new User({
        name: 'John Doe',
        email: 'john@example.com'
    });
    
    await user.save();
    
    const found = await User.findOne({ email: 'john@example.com' });
    expect(found).toBeTruthy();
    expect(found.name).toBe('John Doe');
});

四、端到端测试

4.1 使用Cypress

// cypress/integration/login.spec.js
describe('Login Flow', () => {
    beforeEach(() => {
        cy.visit('/login');
    });
    
    it('should login with valid credentials', () => {
        cy.get('input[name="email"]').type('user@example.com');
        cy.get('input[name="password"]').type('password123');
        cy.get('button[type="submit"]').click();
        
        cy.url().should('include', '/dashboard');
        cy.contains('Welcome, User').should('be.visible');
    });
    
    it('should show error with invalid credentials', () => {
        cy.get('input[name="email"]').type('invalid@example.com');
        cy.get('input[name="password"]').type('wrongpassword');
        cy.get('button[type="submit"]').click();
        
        cy.contains('Invalid credentials').should('be.visible');
    });
});

4.2 使用Playwright

// tests/e2e/login.spec.js
const { test, expect } = require('@playwright/test');

test('login flow', async ({ page }) => {
    await page.goto('http://localhost:3000/login');
    
    await page.fill('input[name="email"]', 'user@example.com');
    await page.fill('input[name="password"]', 'password123');
    await page.click('button[type="submit"]');
    
    await expect(page).toHaveURL(/.*dashboard/);
    await expect(page.locator('text=Welcome, User')).toBeVisible();
});

五、性能测试

5.1 负载测试

// 使用k6
import http from 'k6/http';
import { check, sleep } from 'k6';

export let options = {
    stages: [
        { duration: '2m', target: 100 },
        { duration: '5m', target: 100 },
        { duration: '2m', target: 0 }
    ],
    thresholds: {
        http_req_duration: ['p(95)<500'],
        http_req_failed: ['rate<0.01']
    }
};

export default function() {
    let res = http.get('http://localhost:3000/api/users');
    check(res, {
        'status was 200': (r) => r.status == 200,
        'response time < 500ms': (r) => r.timings.duration < 500
    });
    sleep(1);
}

5.2 压力测试

// 使用Artillery
config:
  target: "http://localhost:3000"
  phases:
    - duration: 60
      arrivalRate: 10
    - duration: 120
      arrivalRate: 50
    - duration: 60
      arrivalRate: 10

scenarios:
  - name: "User API"
    flow:
      - get:
          url: "/api/users"
      - post:
          url: "/api/users"
          json:
            name: "Test User"
            email: "test@example.com"

六、测试覆盖率

6.1 代码覆盖率

// Jest配置
module.exports = {
    collectCoverage: true,
    collectCoverageFrom: [
        'src/**/*.js',
        '!src/**/*.test.js'
    ],
    coverageThreshold: {
        global: {
            branches: 80,
            functions: 80,
            lines: 80,
            statements: 80
        }
    }
};

6.2 覆盖率报告

// 生成覆盖率报告
npm test -- --coverage

// 查看覆盖率报告
open coverage/lcov-report/index.html

七、测试驱动开发

7.1 TDD流程

编写失败的测试
编写最小代码使测试通过
重构代码
重复

7.2 TDD示例

// 1. 编写失败的测试
test('should calculate discount', () => {
    const cart = new Cart();
    cart.addItem({ price: 100, quantity: 2 });
    const discount = cart.calculateDiscount(10);
    expect(discount).toBe(20);
});

// 2. 编写最小代码
class Cart {
    constructor() {
        this.items = [];
    }
    
    addItem(item) {
        this.items.push(item);
    }
    
    calculateDiscount(percentage) {
        return 0; // 最小实现
    }
}

// 3. 完善实现
calculateDiscount(percentage) {
    const total = this.items.reduce((sum, item) => 
        sum + item.price * item.quantity, 0
    );
    return total * (percentage / 100);
}

八、持续集成中的测试

8.1 GitHub Actions配置

name: Test

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
      - uses: actions/checkout@v2
      
      - name: Setup Node.js
        uses: actions/setup-node@v2
        with:
          node-version: '18'
      
      - name: Install dependencies
        run: npm ci
      
      - name: Run tests
        run: npm test
      
      - name: Generate coverage
        run: npm test -- --coverage
      
      - name: Upload coverage
        uses: codecov/codecov-action@v2
        with:
          files: ./coverage/lcov.info

8.2 测试策略

快速反馈：在每次提交时运行快速测试
完整测试：在合并前运行完整测试套件
夜间测试：在夜间运行长时间测试
性能测试：定期运行性能测试

九、测试最佳实践

9.1 编写可维护的测试

使用描述性的测试名称
保持测试简单和独立
使用测试工具函数
避免测试实现细节
测试行为而非实现

9.2 测试组织

// 按功能组织
src/
  features/
    user/
      user.service.js
      user.service.test.js
    order/
      order.service.js
      order.service.test.js

// 按类型组织
src/
  user.service.js
tests/
  unit/
    user.service.test.js
  integration/
    user.api.test.js
  e2e/
    user.flow.spec.js

十、常见测试问题

10.1 测试不稳定

使用固定的测试数据
避免依赖外部服务
使用适当的等待策略
清理测试环境

10.2 测试运行缓慢

并行运行测试
使用测试数据库
Mock外部依赖
优化测试代码

结语

测试是保证软件质量的重要手段，建立完善的测试体系可以提高代码质量和开发效率。通过遵循测试金字塔，合理组织不同类型的测试，你可以构建更加可靠的软件系统。

记住，测试不是一次性的任务，而是需要持续投入的过程。随着项目的发展，不断调整和优化测试策略，确保测试能够有效地发现和防止问题。

996工具盒博客