API 测试员

// 包含安全和性能的高级 API 测试自动化
import { test, expect } from '@playwright/test';
import { performance } from 'perf_hooks';

describe('User API Comprehensive Testing', () => {
  let authToken: string;
  let baseURL = process.env.API_BASE_URL;

  beforeAll(async () => {
    // 认证并获取 token
    const response = await fetch(`${baseURL}/auth/login`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        email: 'test@example.com',
        password: 'secure_password'
      })
    });
    const data = await response.json();
    authToken = data.token;
  });

  describe('Functional Testing', () => {
    test('should create user with valid data', async () => {
      const userData = {
        name: 'Test User',
        email: 'new@example.com',
        role: 'user'
      };

      const response = await fetch(`${baseURL}/users`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${authToken}`
        },
        body: JSON.stringify(userData)
      });

      expect(response.status).toBe(201);
      const user = await response.json();
      expect(user.email).toBe(userData.email);
      expect(user.password).toBeUndefined(); // 密码不应被返回
    });

    test('should handle invalid input gracefully', async () => {
      const invalidData = {
        name: '',
        email: 'invalid-email',
        role: 'invalid_role'
      };

      const response = await fetch(`${baseURL}/users`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': `Bearer ${authToken}`
        },
        body: JSON.stringify(invalidData)
      });

      expect(response.status).toBe(400);
      const error = await response.json();
      expect(error.errors).toBeDefined();
      expect(error.errors).toContain('Invalid email format');
    });
  });

  describe('Security Testing', () => {
    test('should reject requests without authentication', async () => {
      const response = await fetch(`${baseURL}/users`, {
        method: 'GET'
      });
      expect(response.status).toBe(401);
    });

    test('should prevent SQL injection attempts', async () => {
      const sqlInjection = "'; DROP TABLE users; --";
      const response = await fetch(`${baseURL}/users?search=${sqlInjection}`, {
        headers: { 'Authorization': `Bearer ${authToken}` }
      });
      expect(response.status).not.toBe(500);
      // 应返回安全的结果或 400，而非崩溃
    });

    test('should enforce rate limiting', async () => {
      const requests = Array(100).fill(null).map(() =>
        fetch(`${baseURL}/users`, {
          headers: { 'Authorization': `Bearer ${authToken}` }
        })
      );

      const responses = await Promise.all(requests);
      const rateLimited = responses.some(r => r.status === 429);
      expect(rateLimited).toBe(true);
    });
  });

  describe('Performance Testing', () => {
    test('should respond within performance SLA', async () => {
      const startTime = performance.now();

      const response = await fetch(`${baseURL}/users`, {
        headers: { 'Authorization': `Bearer ${authToken}` }
      });

      const endTime = performance.now();
      const responseTime = endTime - startTime;

      expect(response.status).toBe(200);
      expect(responseTime).toBeLessThan(200); // 低于 200ms SLA
    });

    test('should handle concurrent requests efficiently', async () => {
      const concurrentRequests = 50;
      const requests = Array(concurrentRequests).fill(null).map(() =>
        fetch(`${baseURL}/users`, {
          headers: { 'Authorization': `Bearer ${authToken}` }
        })
      );

      const startTime = performance.now();
      const responses = await Promise.all(requests);
      const endTime = performance.now();

      const allSuccessful = responses.every(r => r.status === 200);
      const avgResponseTime = (endTime - startTime) / concurrentRequests;

      expect(allSuccessful).toBe(true);
      expect(avgResponseTime).toBeLessThan(500);
    });
  });
});

# [API 名称] 测试报告

## 测试覆盖率分析
**功能覆盖**：[95%+ 端点覆盖及详细分解]
**安全覆盖**：[认证、授权、输入验证结果]
**性能覆盖**：[负载测试结果及 SLA 合规情况]
**集成覆盖**：[第三方和服务间验证]

## 性能测试结果
**响应时间**：[第 95 百分位：<200ms 目标达成情况]
**吞吐量**：[各种负载条件下的每秒请求数]
**可扩展性**：[正常负载 10 倍下的性能]
**资源利用率**：[CPU、内存、数据库性能指标]

## 安全评估
**认证**：[Token 验证、会话管理结果]
**授权**：[基于角色的访问控制验证]
**输入验证**：[SQL 注入、XSS 防护测试]
**速率限制**：[滥用防护和阈值测试]

## 问题和建议
**严重问题**：[优先级 1 的安全和性能问题]
**性能瓶颈**：[已识别的瓶颈及解决方案]
**安全漏洞**：[风险评估及缓解策略]
**优化机会**：[性能和可靠性改进]

---
**API 测试员**：[你的名字]
**测试日期**：[日期]
**质量状态**：[PASS/FAIL 及详细理由]
**发布就绪性**：[Go/No-Go 建议及支持数据]