Node.js 高级测试策略：从单元测试到混沌工程的完整实践

// 组件快照测试
import renderer from 'react-test-renderer';
import ProfileCard from './ProfileCard';

it('renders correctly', () => {
  const tree = renderer
    .create(<ProfileCard user={{ name: 'Alice', age: 30 }} />)
    .toJSON();
  expect(tree).toMatchSnapshot();
});

// API 响应快照测试
it('returns expected user structure', async () => {
  const response = await fetchUser(123);
  expect(response).toMatchSnapshot();
});

// jest.config.js
module.exports = {
  maxWorkers: '50%',           // 使用 50% CPU 核心
  testEnvironment: 'node',
  setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
  coverageThreshold: {
    global: {
      branches: 80,
      functions: 80,
      lines: 80,
    },
  },
};

# 开发阶段持续监听变更
npx jest --watch

# 仅运行与上次 Git 提交相关的测试
npx jest --watch --onlyChanged

# 按文件名模式过滤
npx jest --watch --testPathPattern="user"

// 消费者侧契约测试（Node.js + Jest Pact）
const { PactV3 } = require('@pact-foundation/pact');
const axios = require('axios');

const provider = new PactV3({
  consumer: 'order-service',
  provider: 'user-service',
  dir: './pacts',
});

describe('User Service Contract', () => {
  it('returns user by id', () => {
    provider
      .given('user with id 123 exists')
      .uponReceiving('a request for user 123')
      .withRequest({
        method: 'GET',
        path: '/users/123',
        headers: { Accept: 'application/json' },
      })
      .willRespondWith({
        status: 200,
        headers: { 'Content-Type': 'application/json' },
        body: {
          id: 123,
          name: 'Alice',
          email: 'alice@example.com',
        },
      });

    return provider.executeTest(async (mockserver) => {
      const response = await axios.get(
        `${mockserver.url}/users/123`,
        { headers: { Accept: 'application/json' } }
      );
      expect(response.data).toEqual({
        id: 123,
        name: 'Alice',
        email: 'alice@example.com',
      });
    });
  });
});

// Playwright E2E 测试示例
const { test, expect } = require('@playwright/test');

test.describe('电商结账流程', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('http://localhost:3000');
    await page.fill('[data-testid="email"]', 'test@example.com');
    await page.fill('[data-testid="password"]', 'password123');
    await page.click('[data-testid="login-button"]');
  });

  test('用户可完成完整下单流程', async ({ page }) => {
    // 浏览商品
    await page.click('text=商品列表');
    await page.click('[data-testid="product-1"]');
    
    // 添加到购物车
    await page.selectOption('[data-testid="quantity"]', '2');
    await page.click('[data-testid="add-to-cart"]');
    
    // 进入购物车结算
    await page.click('[data-testid="cart-icon"]');
    await page.click('[data-testid="checkout"]');
    
    // 填写配送信息
    await page.fill('[data-testid="address"]', '上海市浦东新区');
    await page.fill('[data-testid="phone"]', '13800138000');
    
    // 提交订单
    await page.click('[data-testid="submit-order"]');
    
    // 验证订单成功页
    await expect(page.locator('h1')).toHaveText('订单提交成功');
    await expect(page.locator('[data-testid="order-id"]')).toBeVisible();
    
    // 截图存档
    await page.screenshot({ path: 'order-success.png' });
  });
});

// playwright.config.js
module.exports = {
  testDir: './e2e',
  fullyParallel: true,
  workers: process.env.CI ? 4 : undefined,
  retries: process.env.CI ? 2 : 0,
  use: {
    baseURL: 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
  },
  projects: [
    { name: 'chromium', use: { browserName: 'chromium' } },
    { name: 'firefox', use: { browserName: 'firefox' } },
    { name: 'webkit', use: { browserName: 'webkit' } },
  ],
};

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

describe('POST /api/orders', () => {
  it('creates a new order with valid data', async () => {
    const response = await request(app)
      .post('/api/orders')
      .send({
        productId: 'prod-001',
        quantity: 2,
        customerEmail: 'alice@example.com',
      })
      .set('Accept', 'application/json');

    expect(response.status).toBe(201);
    expect(response.body).toMatchObject({
      productId: 'prod-001',
      quantity: 2,
      status: 'pending',
    });
    expect(response.body).toHaveProperty('id');
    expect(response.body).toHaveProperty('createdAt');
  });

  it('returns 400 for invalid email', async () => {
    const response = await request(app)
      .post('/api/orders')
      .send({ productId: 'prod-001', quantity: 2, customerEmail: 'invalid' });

    expect(response.status).toBe(400);
    expect(response.body.errors).toContainEqual(
      expect.objectContaining({ field: 'customerEmail' })
    );
  });
});

# 导出 Postman Collection 后使用 Newman 执行
npx newman run api-tests.json \
  --environment prod-env.json \
  --reporters cli,html,junit \
  --reporter-junit-export newman-report.xml

// load-test.js — k6 负载测试脚本
import http from 'k6/http';
import { check, sleep, group } from 'k6';
import { Rate, Counter, Trend } from 'k6/metrics';

// 自定义指标
const errorRate = new Rate('errors');
const orderTrend = new Trend('order_duration');
const orderCounter = new Counter('orders_created');

export const options = {
  stages: [
    { duration: '2m', target: 50 },     // 逐渐上升至 50 VU
    { duration: '5m', target: 50 },     // 保持 50 VU
    { duration: '2m', target: 200 },    // 峰值负载 200 VU
    { duration: '3m', target: 100 },    // 回落至 100 VU
    { duration: '2m', target: 0 },      // 逐渐下降
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],   // 95% 延迟 < 500ms
    http_req_failed: ['rate<0.01'],     // 错误率 < 1%
    errors: ['rate<0.05'],
  },
};

export default function () {
  group('用户登录', () => {
    const loginRes = http.post('http://localhost:3000/api/auth/login', JSON.stringify({
      email: `user${__VU}@test.com`,
      password: 'testpass123',
    }), { headers: { 'Content-Type': 'application/json' } });

    const success = check(loginRes, {
      'login status is 200': (r) => r.status === 200,
      'login returns token': (r) => r.json('token') !== undefined,
    });
    errorRate.add(!success);
  });

  sleep(1);

  group('创建订单', () => {
    const start = Date.now();
    const orderRes = http.post('http://localhost:3000/api/orders', JSON.stringify({
      productId: 'prod-001',
      quantity: Math.floor(Math.random() * 5) + 1,
      customerEmail: `user${__VU}@test.com`,
    }), { headers: { 'Content-Type': 'application/json' } });

    const duration = Date.now() - start;
    orderTrend.add(duration);
    orderCounter.add(1);

    const success = check(orderRes, {
      'order status is 201': (r) => r.status === 201,
      'order has id': (r) => r.json('id') !== undefined,
    });
    errorRate.add(!success);
  });

  sleep(Math.random() * 3 + 1);  // 模拟真实用户间隔
}

# 本地执行
k6 run load-test.js

# 云端分布式执行（k6 Cloud）
k6 cloud run load-test.js

# 输出 JSON 报告供 CI 分析
k6 run --out json=results.json load-test.js

# artillery-config.yml
config:
  target: 'http://localhost:3000'
  phases:
    - duration: 60
      arrivalRate: 10
    - duration: 120
      arrivalRate: 50
scenarios:
  - name: 'GET products'
    requests:
      - get:
          url: '/api/products'

# 使用 Gremlin CLI 注入 CPU 压力
gremlin attack cpu --length 120 --cpus 2 --percent 90

# 注入网络延迟
gremlin attack network latency --length 60 --ms 500 --percent 100

# 注入内存压力
gremlin attack memory --length 120 --percent 80

// user-repository.test.js
const { GenericContainer } = require('testcontainers');
const { Client } = require('pg');

describe('UserRepository Integration', () => {
  let container;
  let client;
  let userRepository;

  beforeAll(async () => {
    // 启动 PostgreSQL 容器
    container = await new GenericContainer('postgres:15-alpine')
      .withEnvironment({ POSTGRES_USER: 'test', POSTGRES_PASSWORD: 'test', POSTGRES_DB: 'testdb' })
      .withExposedPorts(5432)
      .start();

    const host = container.getHost();
    const port = container.getMappedPort(5432);

    client = new Client({
      host, port,
      user: 'test', password: 'test', database: 'testdb',
    });
    await client.connect();

    // 初始化 Schema
    await client.query(`
      CREATE TABLE users (
        id SERIAL PRIMARY KEY,
        email VARCHAR(255) UNIQUE NOT NULL,
        name VARCHAR(255),
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
      )
    `);

    userRepository = new UserRepository(client);
  }, 30000);  // 容器启动需要更长的超时

  afterAll(async () => {
    await client.end();
    await container.stop();
  });

  it('creates and retrieves user', async () => {
    const user = await userRepository.create({
      email: 'alice@example.com',
      name: 'Alice',
    });

    expect(user.id).toBeDefined();
    expect(user.email).toBe('alice@example.com');

    const found = await userRepository.findById(user.id);
    expect(found.name).toBe('Alice');
  });

  it('enforces email uniqueness', async () => {
    await userRepository.create({ email: 'dup@example.com', name: 'First' });
    await expect(
      userRepository.create({ email: 'dup@example.com', name: 'Second' })
    ).rejects.toThrow('duplicate key');
  });
});

const fc = require('fast-check');

// 属性：排序后数组应该是非递减的
fc.assert(
  fc.property(
    fc.array(fc.integer()),
    (arr) => {
      const sorted = [...arr].sort((a, b) => a - b);
      for (let i = 1; i < sorted.length; i++) {
        if (sorted[i] < sorted[i - 1]) return false;
      }
      return true;
    }
  )
);

// 属性：字符串反转两次应等于原字符串
fc.assert(
  fc.property(
    fc.string(),
    (str) => str === str.split('').reverse().join('').split('').reverse().join('')
  )
);

// 属性：购物车总价 = 各商品价格之和
fc.assert(
  fc.property(
    fc.array(fc.record({
      price: fc.integer({ min: 0, max: 10000 }),
      quantity: fc.integer({ min: 1, max: 100 }),
    })),
    (items) => {
      const total = items.reduce((sum, item) => sum + item.price * item.quantity, 0);
      const cart = new ShoppingCart();
      items.forEach(item => cart.addItem(item.price, item.quantity));
      return cart.getTotal() === total;
    }
  )
);

# 安装与配置
npm install --save-dev @stryker-mutator/core @stryker-mutator/jest-runner

# 初始化配置
npx stryker init

// stryker.config.js
module.exports = {
  packageManager: 'npm',
  reporters: ['html', 'clear-text', 'progress'],
  testRunner: 'jest',
  coverageAnalysis: 'perTest',
  mutate: ['src/**/*.js', '!src/**/*.test.js'],
  threshold: {
    high: 80,
    low: 60,
    break: 40,
  },
};

# 执行变异测试
npx stryker run

# .github/workflows/test.yml — 测试分片示例
name: Test
on: [push, pull_request]
jobs:
  unit-tests:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        shard: [1/4, 2/4, 3/4, 4/4]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
      - run: npm ci
      - run: npx jest --shard=${{ matrix.shard }}
      - uses: actions/upload-artifact@v4
        with:
          name: coverage-${{ matrix.shard }}
          path: coverage/

  e2e-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
      - run: npm ci
      - run: npx playwright install --with-deps
      - run: npx playwright test
      - uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: playwright-traces
          path: test-results/

  mutation-tests:
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm
      - run: npm ci
      - run: npx stryker run

# 仅测试自 main 分支以来的变更
npx jest --changedSince=origin/main --coverage=false

# 测试分片：第 1/4 份
npx jest --shard=1/4

// jest.config.js
module.exports = {
  testRunner: 'jest-circus/runner',
  errorOnDeprecated: true,
  retry: process.env.CI ? 2 : 0,
  testSequencer: './custom-sequencer.js',  // 控制测试执行顺序
};