测试金字塔与测试策略

// src/domain/Order.js - 订单领域模型
class Order {
  constructor(orderId, customerId, items = []) {
    if (!orderId) throw new Error('OrderId is required');
    if (!customerId) throw new Error('CustomerId is required');
 
    this.orderId = orderId;
    this.customerId = customerId;
    this.items = items;
    this.status = 'CREATED';
    this.createdAt = new Date();
    this.totalAmount = 0;
  }
 
  addItem(product, quantity) {
    if (this.status !== 'CREATED') {
      throw new Error(`Cannot add items to order in ${this.status} status`);
    }
    if (quantity <= 0) {
      throw new Error('Quantity must be positive');
    }
    if (!product || !product.price || !product.id) {
      throw new Error('Invalid product');
    }
 
    const existingItem = this.items.find(item => item.productId === product.id);
    if (existingItem) {
      existingItem.quantity += quantity;
    } else {
      this.items.push({
        productId: product.id,
        productName: product.name,
        price: product.price,
        quantity
      });
    }
    this._recalculateTotal();
    return this;
  }
 
  removeItem(productId) {
    if (this.status !== 'CREATED') {
      throw new Error(`Cannot remove items from order in ${this.status} status`);
    }
    const index = this.items.findIndex(item => item.productId === productId);
    if (index === -1) {
      throw new Error(`Product ${productId} not found in order`);
    }
    this.items.splice(index, 1);
    this._recalculateTotal();
    return this;
  }
 
  applyDiscount(discountCode) {
    const DISCOUNT_RULES = {
      'SAVE10': { type: 'percentage', value: 0.10, minOrder: 100 },
      'SAVE20': { type: 'percentage', value: 0.20, minOrder: 200 },
      'FLAT50': { type: 'fixed', value: 50, minOrder: 200 },
    };
 
    const rule = DISCOUNT_RULES[discountCode];
    if (!rule) throw new Error('Invalid discount code');
 
    if (this.totalAmount < rule.minOrder) {
      throw new Error(`Minimum order amount ${rule.minOrder} required for ${discountCode}`);
    }
 
    if (rule.type === 'percentage') {
      this.discountAmount = this.totalAmount * rule.value;
    } else {
      this.discountAmount = Math.min(rule.value, this.totalAmount);
    }
 
    this.discountCode = discountCode;
    this._recalculateTotal();
    return this;
  }
 
  submit() {
    if (this.status !== 'CREATED') {
      throw new Error(`Cannot submit order in ${this.status} status`);
    }
    if (this.items.length === 0) {
      throw new Error('Cannot submit empty order');
    }
    this.status = 'SUBMITTED';
    this.submittedAt = new Date();
    return this;
  }
 
  _recalculateTotal() {
    this.totalAmount = this.items.reduce(
      (sum, item) => sum + (item.price * item.quantity), 0
    );
    if (this.discountAmount) {
      this.finalAmount = Math.max(0, this.totalAmount - this.discountAmount);
    } else {
      this.finalAmount = this.totalAmount;
    }
  }
}
 
module.exports = { Order };

// tests/unit/Order.test.js - 单元测试
const { Order } = require('../../src/domain/Order');
 
describe('Order Domain Model', () => {
  // --- 构造函数测试 ---
  describe('constructor', () => {
    test('should create order with valid parameters', () => {
      const order = new Order('ORD-001', 'CUST-001');
      expect(order.orderId).toBe('ORD-001');
      expect(order.customerId).toBe('CUST-001');
      expect(order.status).toBe('CREATED');
      expect(order.items).toEqual([]);
      expect(order.totalAmount).toBe(0);
    });
 
    test('should throw error when orderId is missing', () => {
      expect(() => new Order(null, 'CUST-001'))
        .toThrow('OrderId is required');
    });
 
    test('should throw error when customerId is missing', () => {
      expect(() => new Order('ORD-001', ''))
        .toThrow('CustomerId is required');
    });
  });
 
  // --- 添加商品测试 ---
  describe('addItem', () => {
    let order;
    const product = { id: 'PROD-001', name: 'TypeScript Guide', price: 99.00 };
 
    beforeEach(() => {
      order = new Order('ORD-001', 'CUST-001');
    });
 
    test('should add item to empty order', () => {
      order.addItem(product, 2);
      expect(order.items).toHaveLength(1);
      expect(order.items[0]).toEqual({
        productId: 'PROD-001',
        productName: 'TypeScript Guide',
        price: 99.00,
        quantity: 2
      });
      expect(order.totalAmount).toBe(198.00);
    });
 
    test('should merge quantity when adding same product', () => {
      order.addItem(product, 1);
      order.addItem(product, 2);
      expect(order.items).toHaveLength(1);
      expect(order.items[0].quantity).toBe(3);
      expect(order.totalAmount).toBe(297.00);
    });
 
    test('should throw error for non-positive quantity', () => {
      expect(() => order.addItem(product, 0))
        .toThrow('Quantity must be positive');
      expect(() => order.addItem(product, -1))
        .toThrow('Quantity must be positive');
    });
 
    test('should throw error for invalid product', () => {
      expect(() => order.addItem(null, 1)).toThrow('Invalid product');
      expect(() => order.addItem({ id: 'P1' }, 1)).toThrow('Invalid product');
    });
 
    test('should throw error when adding item to submitted order', () => {
      order.addItem(product, 1).submit();
      expect(() => order.addItem(product, 1))
        .toThrow('Cannot add items to order in SUBMITTED status');
    });
  });
 
  // --- 折扣测试 ---
  describe('applyDiscount', () => {
    let order;
 
    beforeEach(() => {
      order = new Order('ORD-001', 'CUST-001');
      order.addItem({ id: 'P1', name: 'Book', price: 150 }, 1);
    });
 
    test('should apply percentage discount SAVE10', () => {
      order.applyDiscount('SAVE10');
      expect(order.discountAmount).toBe(15.00);
      expect(order.finalAmount).toBe(135.00);
    });
 
    test('should apply percentage discount SAVE20', () => {
      order.addItem({ id: 'P2', name: 'Course', price: 100 }, 1);
      order.applyDiscount('SAVE20');
      expect(order.discountAmount).toBe(50.00);
      expect(order.finalAmount).toBe(200.00);
    });
 
    test('should apply fixed discount FLAT50', () => {
      order.addItem({ id: 'P2', name: 'Course', price: 100 }, 1);
      order.applyDiscount('FLAT50');
      expect(order.discountAmount).toBe(50.00);
      expect(order.finalAmount).toBe(200.00);
    });
 
    test('should throw error for invalid discount code', () => {
      expect(() => order.applyDiscount('INVALID'))
        .toThrow('Invalid discount code');
    });
 
    test('should throw error when order amount below minimum', () => {
      const smallOrder = new Order('ORD-002', 'CUST-002');
      smallOrder.addItem({ id: 'P1', name: 'Pen', price: 50 }, 1);
      expect(() => smallOrder.applyDiscount('SAVE10'))
        .toThrow('Minimum order amount 100 required');
    });
  });
 
  // --- 提交订单测试 ---
  describe('submit', () => {
    test('should submit order with items', () => {
      const order = new Order('ORD-001', 'CUST-001');
      order.addItem({ id: 'P1', name: 'Book', price: 50 }, 1);
      order.submit();
      expect(order.status).toBe('SUBMITTED');
      expect(order.submittedAt).toBeInstanceOf(Date);
    });
 
    test('should throw error when submitting empty order', () => {
      const order = new Order('ORD-001', 'CUST-001');
      expect(() => order.submit()).toThrow('Cannot submit empty order');
    });
 
    test('should not allow double submission', () => {
      const order = new Order('ORD-001', 'CUST-001');
      order.addItem({ id: 'P1', name: 'Book', price: 50 }, 1);
      order.submit();
      expect(() => order.submit())
        .toThrow('Cannot submit order in SUBMITTED status');
    });
  });
 
  // --- 链式调用测试 ---
  describe('method chaining', () => {
    test('should support fluent API', () => {
      const order = new Order('ORD-001', 'CUST-001')
        .addItem({ id: 'P1', name: 'Book', price: 150 }, 2)
        .addItem({ id: 'P2', name: 'Course', price: 100 }, 1)
        .applyDiscount('SAVE10')
        .submit();
 
      expect(order.status).toBe('SUBMITTED');
      expect(order.totalAmount).toBe(400.00);
      expect(order.discountAmount).toBe(40.00);
      expect(order.finalAmount).toBe(360.00);
    });
  });
});

// jest.config.js - Jest 配置
module.exports = {
  testEnvironment: 'node',
  coverageDirectory: './coverage',
  collectCoverageFrom: [
    'src/**/*.js',
    '!src/**/*.d.ts',
    '!src/index.js',
  ],
  coverageThresholds: {
    global: {
      branches: 80,
      functions: 80,
      lines: 80,
      statements: 80,
    },
  },
  // 测试并行化
  maxWorkers: '50%',
  // 测试超时
  testTimeout: 5000,
};

# 安装依赖
npm install --save-dev jest
 
# 运行测试
npx jest tests/unit/Order.test.js
 
# 生成覆盖率报告
npx jest --coverage tests/unit/Order.test.js
 
# 输出示例：
# PASS  tests/unit/Order.test.js
#   Order Domain Model
#     constructor
#       ✓ should create order with valid parameters (3ms)
#       ✓ should throw error when orderId is missing
#       ✓ should throw error when customerId is missing
#     addItem
#       ✓ should add item to empty order
#       ✓ should merge quantity when adding same product
#       ✓ should throw error for non-positive quantity
#       ✓ should throw error for invalid product
#       ✓ should throw error when adding item to submitted order
#     applyDiscount
#       ✓ should apply percentage discount SAVE10
#       ✓ should apply percentage discount SAVE20
#       ✓ should apply fixed discount FLAT50
#       ✓ should throw error for invalid discount code
#       ✓ should throw error when order amount below minimum
#     submit
#       ✓ should submit order with items
#       ✓ should throw error when submitting empty order
#       ✓ should not allow double submission
#     method chaining
#       ✓ should support fluent API (1ms)
#
# ----------|---------|----------|---------|---------|-------------------
# File      | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
# ----------|---------|----------|---------|---------|-------------------
# All files |     100 |      100 |     100 |     100 |
# ----------|---------|----------|---------|---------|-------------------

// ❌ 不可测试的代码：硬编码依赖
class PaymentService {
  processPayment(orderId, amount) {
    // 硬编码依赖，无法 Mock
    const stripe = new Stripe('sk_live_xxx');
    const result = stripe.charges.create({
      amount: amount * 100,
      currency: 'usd',
    });
    // 硬编码数据库连接
    const db = new PostgreSQL('localhost:5432');
    db.query('INSERT INTO payments ...');
    return result;
  }
}
 
// ✅ 可测试的代码：依赖注入
class PaymentService {
  constructor(paymentGateway, paymentRepository) {
    this.paymentGateway = paymentGateway;
    this.repository = paymentRepository;
  }
 
  async processPayment(orderId, amount) {
    const result = await this.paymentGateway.charge(amount);
    await this.repository.save({ orderId, ...result });
    return result;
  }
}
 
// 测试时注入 Mock
describe('PaymentService', () => {
  test('should process payment successfully', async () => {
    const mockGateway = {
      charge: jest.fn().mockResolvedValue({ id: 'ch_123', status: 'succeeded' })
    };
    const mockRepo = {
      save: jest.fn().mockResolvedValue(true)
    };
    const service = new PaymentService(mockGateway, mockRepo);
 
    const result = await service.processPayment('ORD-001', 99.99);
 
    expect(mockGateway.charge).toHaveBeenCalledWith(99.99);
    expect(mockRepo.save).toHaveBeenCalledWith(
      expect.objectContaining({ orderId: 'ORD-001' })
    );
    expect(result.status).toBe('succeeded');
  });
});

// 推荐的测试组织模式：Given-When-Then
describe('Order.applyDiscount', () => {
  test('GIVEN order amount >= 100 WHEN applying SAVE10 THEN 10% discount applied', () => {
    // Given
    const order = new Order('ORD-001', 'CUST-001');
    order.addItem({ id: 'P1', name: 'Book', price: 150 }, 1);
 
    // When
    order.applyDiscount('SAVE10');
 
    // Then
    expect(order.discountAmount).toBe(15.00);
    expect(order.finalAmount).toBe(135.00);
  });
});

测试 ROI = (缺陷预防收益 - 测试投入成本) / 测试投入成本
 
其中：
缺陷预防收益 = 逃逸缺陷数减少 × 平均缺陷修复成本（生产环境）
测试投入成本 = 测试编写时间 + 测试维护时间 + 测试执行时间 × 执行频率 + 基础设施成本
 
典型数据：
- 生产缺陷修复成本：$5,000 - $50,000 / 缺陷
- 测试阶段缺陷修复成本：$50 - $500 / 缺陷
- 单元测试编写成本：$5 - $20 / 测试
- E2E 测试编写成本：$100 - $500 / 测试
- 单元测试执行成本：$0.001 / 次
- E2E 测试执行成本：$0.5 - $5 / 次