自动化测试实践：单元、集成、E2E

// 三种测试替身的区别与使用场景

// 1. Stub - 返回预设值，用于满足被测代码的输入需求
class PaymentGatewayStub {
  constructor(shouldSucceed) {
    this.shouldSucceed = shouldSucceed;
  }
  async charge(amount) {
    if (this.shouldSucceed) {
      return { id: 'ch_stub', status: 'succeeded', amount };
    }
    throw new Error('Charge failed');
  }
}

// 2. Mock - 验证交互行为，用于确认被测代码是否正确调用了依赖
const mockEmailService = {
  sendConfirmation: jest.fn().mockResolvedValue(true),
};
// 验证：是否以正确参数调用了正确方法
expect(mockEmailService.sendConfirmation)
  .toHaveBeenCalledWith('user@example.com', 'ORD-001');

// 3. Spy - 记录调用信息但不改变行为，用于监控真实对象的交互
const spyLogger = jest.spyOn(console, 'log');
// 执行业务代码后验证
expect(spyLogger).toHaveBeenCalledWith('Payment processed for ORD-001');

// .nycrc.json - Istanbul 覆盖率配置
{
  "extends": "@istanbuljs/nyc-config-typescript",
  "all": true,
  "include": ["src/**/*.ts"],
  "exclude": [
    "src/**/*.d.ts",
    "src/**/index.ts",
    "src/**/types.ts",
    "src/migrations/**"
  ],
  "reporter": ["text", "text-summary", "lcov", "cobertura"],
  "report-dir": "./coverage",
  "temp-dir": "./coverage/.nyc_output",
  "check-coverage": true,
  "branches": 80,
  "lines": 80,
  "functions": 80,
  "statements": 80,
  "per-file": true,
  "watermarks": {
    "lines": [70, 90],
    "functions": [70, 90],
    "branches": [60, 85],
    "statements": [70, 90]
  }
}

// consumer-side/tests/integration/order-api.pact.test.js
// 消费者端：定义对 Order API 的期望契约
const { Pact } = require('@pact-foundation/pact');
const path = require('path');

describe('Order API Consumer Contract', () => {
  const provider = new Pact({
    consumer: 'OrderFrontend',
    provider: 'OrderService',
    port: 1234,
    log: path.resolve(process.cwd(), 'logs', 'pact.log'),
    dir: path.resolve(process.cwd(), 'pacts'),
    logLevel: 'WARN',
  });

  beforeAll(() => provider.setup());
  afterAll(() => provider.finalize());
  afterEach(() => provider.verify());

  describe('GET /api/orders/:id', () => {
    test('should return order details', async () => {
      // 定义期望的交互
      await provider.addInteraction({
        state: 'order ORD-001 exists',
        uponReceiving: 'a request for order details',
        withRequest: {
          method: 'GET',
          path: '/api/orders/ORD-001',
          headers: { Accept: 'application/json' },
        },
        willRespondWith: {
          status: 200,
          headers: { 'Content-Type': 'application/json' },
          body: {
            orderId: like('ORD-001'),
            status: like('SUBMITTED'),
            items: eachLike({
              productId: like('PROD-001'),
              quantity: like(2),
              price: like(99.99),
            }),
            totalAmount: like(199.98),
          },
        },
      });

      // 执行消费者代码
      const orderClient = new OrderClient('http://localhost:1234');
      const order = await orderClient.getOrder('ORD-001');

      expect(order.orderId).toBe('ORD-001');
      expect(order.status).toBe('SUBMITTED');
      expect(order.items).toHaveLength(1);
    });
  });
});

// provider-side/tests/integration/order-api.provider.test.js
// 提供者端：验证是否满足消费者定义的契约
const { Verifier } = require('@pact-foundation/pact');
const { app } = require('../../src/app');

describe('Order API Provider Contract Verification', () => {
  test('should verify consumer contracts', async () => {
    const verifier = new Verifier({
      providerBaseUrl: 'http://localhost:8080',
      provider: 'OrderService',
      pactBrokerUrl: process.env.PACT_BROKER_URL,
      pactBrokerToken: process.env.PACT_BROKER_TOKEN,
      consumerVersionTags: ['main'],
      providerVersionTags: ['main'],
      publishVerificationResult: true,
      providerVersion: process.env.GIT_COMMIT,
      stateHandlers: {
        'order ORD-001 exists': async () => {
          // 设置提供者状态：在测试数据库中创建订单
          await seedTestOrder({
            orderId: 'ORD-001',
            status: 'SUBMITTED',
            items: [{ productId: 'PROD-001', quantity: 2, price: 99.99 }],
          });
          return {};
        },
      },
    });

    const result = await verifier.verifyProvider();
    expect(result.match).toBe(true);
  });
});

// WireMock 集成测试示例
const { WireMock } = require('wiremock-captain');

describe('Order Service Integration with Payment Service', () => {
  let wireMock;

  beforeAll(async () => {
    wireMock = new WireMock('http://localhost:8089');
    await wireMock.start();
  });

  afterAll(async () => {
    await wireMock.stop();
  });

  test('should handle payment service timeout gracefully', async () => {
    // 模拟支付服务超时
    await wireMock.register(
      wireMock.stubRequest
        .forEndpoint('/api/payments/charge')
        .withMethod('POST')
        .willReturnTimeout(5000) // 5秒超时
    );

    const orderService = new OrderService({
      paymentServiceUrl: 'http://localhost:8089',
    });

    await expect(orderService.processPayment('ORD-001', 100))
      .rejects.toThrow('Payment service timeout');

    // 验证重试逻辑
    const calls = await wireMock.getCallCount('/api/payments/charge');
    expect(calls).toBe(3); // 初始调用 + 2次重试
  });
});

// e2e/order-flow.spec.js - Playwright E2E 测试
const { test, expect } = require('@playwright/test');

test.describe('Order Management Flow', () => {
  let page;

  test.beforeEach(async ({ browser }) => {
    page = await browser.newPage();
    // 设置网络拦截，Mock 外部支付服务
    await page.route('**/api/payments/**', (route) => {
      route.fulfill({
        status: 200,
        contentType: 'application/json',
        body: JSON.stringify({
          paymentId: 'pay_mock_001',
          status: 'succeeded',
        }),
      });
    });
  });

  test.afterEach(async () => {
    await page.close();
  });

  test('should complete full order flow: browse → add to cart → checkout → payment', async () => {
    // Step 1: 浏览商品列表
    await page.goto('/products');
    await expect(page.locator('[data-testid="product-list"]')).toBeVisible();

    // Step 2: 添加商品到购物车
    await page.click('[data-testid="add-to-cart-PROD-001"]');
    await expect(page.locator('[data-testid="cart-badge"]')).toHaveText('1');

    // Step 3: 进入购物车
    await page.click('[data-testid="cart-icon"]');
    await expect(page.locator('[data-testid="cart-item"]')).toHaveCount(1);
    await expect(page.locator('[data-testid="item-price"]')).toContainText('99.99');

    // Step 4: 应用折扣码
    await page.fill('[data-testid="discount-code-input"]', 'SAVE10');
    await page.click('[data-testid="apply-discount"]');
    await expect(page.locator('[data-testid="discount-amount"]')).toContainText('10.00');
    await expect(page.locator('[data-testid="final-amount"]')).toContainText('89.99');

    // Step 5: 填写配送信息
    await page.click('[data-testid="checkout-button"]');
    await page.fill('[data-testid="shipping-name"]', 'Zhang San');
    await page.fill('[data-testid="shipping-address"]', '123 Main St');
    await page.fill('[data-testid="shipping-city"]', 'Beijing');

    // Step 6: 提交支付
    await page.click('[data-testid="place-order"]');

    // Step 7: 验证订单确认
    await expect(page.locator('[data-testid="order-confirmation"]')).toBeVisible();
    await expect(page.locator('[data-testid="order-id"]')).toMatch(/^ORD-\d+$/);
    await expect(page.locator('[data-testid="order-status"]')).toHaveText('Confirmed');
  });

  test('should show error for invalid discount code', async () => {
    await page.goto('/products');
    await page.click('[data-testid="add-to-cart-PROD-001"]');
    await page.click('[data-testid="cart-icon"]');
    await page.fill('[data-testid="discount-code-input"]', 'INVALID');
    await page.click('[data-testid="apply-discount"]');

    await expect(page.locator('[data-testid="error-message"]'))
      .toContainText('Invalid discount code');
  });

  test('should handle out-of-stock product gracefully', async () => {
    // Mock 库存服务返回缺货
    await page.route('**/api/inventory/PROD-002', (route) => {
      route.fulfill({
        status: 200,
        contentType: 'application/json',
        body: JSON.stringify({ productId: 'PROD-002', inStock: false }),
      });
    });

    await page.goto('/products/PROD-002');
    await expect(page.locator('[data-testid="out-of-stock-badge"]')).toBeVisible();
    await expect(page.locator('[data-testid="add-to-cart-button"]')).toBeDisabled();
  });
});

// playwright.config.js - Playwright 配置
const { defineConfig, devices } = require('@playwright/test');

module.exports = defineConfig({
  testDir: './e2e',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 4 : '50%',
  reporter: process.env.CI
    ? [['github'], ['html', { open: 'never' }], ['junit', { outputFile: 'test-results.xml' }]]
    : [['list'], ['html', { open: 'on-failure' }]],
  timeout: 30000,
  expect: { timeout: 10000 },

  use: {
    baseURL: process.env.E2E_BASE_URL || 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
    video: 'retain-on-failure',
  },

  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
    },
    {
      name: 'mobile-chrome',
      use: { ...devices['Pixel 5'] },
    },
  ],
});

# .github/workflows/test-pipeline.yml
name: Test Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

env:
  NODE_VERSION: '20'

jobs:
  # ---- 第一阶段：单元测试（最快反馈）----
  unit-tests:
    name: Unit Tests
    runs-on: ubuntu-latest
    strategy:
      matrix:
        shard: [1, 2, 3, 4]  # 拆分为4个分片并行执行
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
      - run: npm ci
      - name: Run Unit Tests (Shard ${{ matrix.shard }}/4)
        run: npx jest --shard=${{ matrix.shard }}/4 --coverage --forceExit
        env:
          CI: true
      - name: Upload Coverage
        if: matrix.shard == 1
        uses: actions/upload-artifact@v4
        with:
          name: unit-coverage
          path: coverage/

  # ---- 第二阶段：集成测试（依赖单元测试通过）----
  integration-tests:
    name: Integration Tests
    needs: unit-tests
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_DB: test_db
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
      redis:
        image: redis:7
        ports:
          - 6379:6379
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    strategy:
      matrix:
        shard: [1, 2, 3]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
      - run: npm ci
      - name: Run Integration Tests (Shard ${{ matrix.shard }}/3)
        run: npx jest --config jest.integration.config.js --shard=${{ matrix.shard }}/3
        env:
          CI: true
          DATABASE_URL: postgresql://test:test@localhost:5432/test_db
          REDIS_URL: redis://localhost:6379

  # ---- 第三阶段：E2E 测试（依赖集成测试通过）----
  e2e-tests:
    name: E2E Tests
    needs: integration-tests
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        project: [chromium, firefox]
        shard: [1, 2]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ env.NODE_VERSION }}
          cache: 'npm'
      - run: npm ci
      - name: Install Playwright Browsers
        run: npx playwright install --with-deps ${{ matrix.project }}
      - name: Build Application
        run: npm run build
      - name: Start Application
        run: npm run start &
        env:
          PORT: 3000
      - name: Wait for Application
        run: npx wait-on http://localhost:3000 --timeout 60000
      - name: Run E2E Tests (${{ matrix.project }} Shard ${{ matrix.shard }}/2)
        run: npx playwright test --project=${{ matrix.project }} --shard=${{ matrix.shard }}/2
        env:
          E2E_BASE_URL: http://localhost:3000
      - name: Upload Test Results
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: e2e-results-${{ matrix.project }}-${{ matrix.shard }}
          path: |
            test-results/
            playwright-report/

  # ---- 第四阶段：测试报告汇总 ----
  test-report:
    name: Test Report
    needs: [unit-tests, integration-tests, e2e-tests]
    if: always()
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Download All Artifacts
        uses: actions/download-artifact@v4
      - name: Publish Test Report
        uses: mikepenz/action-junit-report@v4
        with:
          report_paths: '**/test-results.xml'
          require_tests: true

// scripts/flaky-test-detector.js
const { execSync } = require('child_process');
const fs = require('fs');

/**
 * Flaky Test 检测器
 * 通过多次运行同一测试集，识别结果不一致的测试
 */
class FlakyTestDetector {
  constructor(config = {}) {
    this.runs = config.runs || 10;          // 运行次数
    this.testCommand = config.testCommand;   // 测试命令
    this.threshold = config.threshold || 0.1; // 失败率阈值（10%）
    this.results = new Map();                // 测试名 -> 通过/失败记录
  }

  async run() {
    console.log(`Running tests ${this.runs} times to detect flaky tests...`);

    for (let i = 1; i <= this.runs; i++) {
      console.log(`\n--- Run ${i}/${this.runs} ---`);
      const output = this._executeTests();
      this._parseResults(output, i);
    }

    return this._generateReport();
  }

  _executeTests() {
    try {
      return execSync(this.testCommand, {
        encoding: 'utf-8',
        timeout: 300000,
        env: { ...process.env, CI: 'true' },
      });
    } catch (error) {
      // Jest 在测试失败时返回非零退出码，但输出仍包含结果
      return error.stdout || error.message;
    }
  }

  _parseResults(output, runIndex) {
    // 解析 Jest 输出，提取每个测试的结果
    const testPattern = /\s+(✓|✕|✗|PASS|FAIL)\s+(.*)/g;
    let match;
    while ((match = testPattern.exec(output)) !== null) {
      const [, status, testName] = match;
      const passed = ['✓', 'PASS'].includes(status.trim());

      if (!this.results.has(testName.trim())) {
        this.results.set(testName.trim(), []);
      }
      this.results.get(testName.trim()).push({
        run: runIndex,
        passed,
      });
    }
  }

  _generateReport() {
    const flakyTests = [];

    for (const [testName, runs] of this.results) {
      const passCount = runs.filter(r => r.passed).length;
      const failCount = runs.filter(r => !r.passed).length;
      const failureRate = failCount / runs.length;

      if (failureRate > 0 && failureRate < 1) {
        // 既非总是通过也非总是失败 = Flaky
        flakyTests.push({
          test: testName,
          passRate: passCount / runs.length,
          failureRate,
          isFlaky: failureRate >= this.threshold,
          runs: runs.map(r => r.passed ? 'PASS' : 'FAIL'),
        });
      }
    }

    // 按失败率降序排列
    flakyTests.sort((a, b) => b.failureRate - a.failureRate);

    const report = {
      totalTests: this.results.size,
      flakyTestCount: flakyTests.filter(t => t.isFlaky).length,
      suspectTestCount: flakyTests.filter(t => !t.isFlaky).length,
      flakyTests,
      generatedAt: new Date().toISOString(),
    };

    // 输出报告
    console.log('\n========== FLAKY TEST REPORT ==========');
    console.log(`Total Tests: ${report.totalTests}`);
    console.log(`Flaky Tests (failure rate >= ${this.threshold * 100}%): ${report.flakyTestCount}`);
    console.log(`Suspect Tests (failure rate < ${this.threshold * 100}%): ${report.suspectTestCount}`);

    if (report.flakyTests.length > 0) {
      console.log('\n--- Flaky Tests Detail ---');
      report.flakyTests.forEach(t => {
        console.log(`  [${t.isFlaky ? 'FLAKY' : 'SUSPECT'}] ${t.test}`);
        console.log(`    Pass Rate: ${(t.passRate * 100).toFixed(1)}% | Runs: ${t.runs.join(', ')}`);
      });
    }

    // 保存 JSON 报告
    fs.writeFileSync(
      'flaky-test-report.json',
      JSON.stringify(report, null, 2)
    );

    return report;
  }
}

// 执行检测
if (require.main === module) {
  const detector = new FlakyTestDetector({
    runs: 10,
    testCommand: 'npx jest --forceExit --no-coverage tests/unit/',
    threshold: 0.1,
  });
  detector.run().then(report => {
    process.exit(report.flakyTestCount > 0 ? 1 : 0);
  });
}

module.exports = { FlakyTestDetector };

// tests/helpers/OrderBuilder.js - 测试数据构建器
class OrderBuilder {
  constructor() {
    this.orderId = `ORD-${Date.now()}`;
    this.customerId = 'CUST-DEFAULT';
    this.items = [];
    this.discountCode = null;
  }

  withOrderId(orderId) {
    this.orderId = orderId;
    return this;
  }

  withCustomer(customerId) {
    this.customerId = customerId;
    return this;
  }

  withItem(productId, price, quantity = 1) {
    this.items.push({
      id: productId,
      name: `Product ${productId}`,
      price,
      quantity,
    });
    return this;
  }

  withMultipleItems(count, price = 50) {
    for (let i = 1; i <= count; i++) {
      this.withItem(`PROD-${i.toString().padStart(3, '0')}`, price);
    }
    return this;
  }

  withDiscount(code) {
    this.discountCode = code;
    return this;
  }

  build() {
    const order = new Order(this.orderId, this.customerId);
    this.items.forEach(item => {
      order.addItem({ id: item.id, name: item.name, price: item.price }, item.quantity);
    });
    if (this.discountCode) {
      order.applyDiscount(this.discountCode);
    }
    return order;
  }
}

// 使用示例
const order = new OrderBuilder()
  .withCustomer('CUST-001')
  .withItem('PROD-001', 150, 2)
  .withItem('PROD-002', 100, 1)
  .withDiscount('SAVE10')
  .build();