第4章 - 测试中的网络调试

// GET 请求示例
GET https://api.example.com/users

Headers:
Authorization: Bearer {{access_token}}
Content-Type: application/json

// 使用环境变量
{{base_url}}/users/{{user_id}}

// Pre-request Script (请求前执行)
// 生成随机数据
pm.globals.set("random_email", `test${Math.random()}@example.com`);

// 获取当前时间戳
pm.globals.set("timestamp", Date.now());

// 从环境变量获取 token
const token = pm.environment.get("access_token");
console.log("Token:", token);

// Tests (响应后执行)
// 测试状态码
pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

// 测试响应时间
pm.test("Response time is less than 500ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

// 测试响应体
pm.test("Response has success field", function () {
    const jsonData = pm.response.json();
    pm.expect(jsonData).to.have.property('success');
    pm.expect(jsonData.success).to.be.true;
});

// 测试响应头
pm.test("Content-Type is JSON", function () {
    pm.response.to.have.header("Content-Type");
    pm.expect(pm.response.headers.get("Content-Type")).to.include("application/json");
});

// 保存响应数据到环境变量
const responseData = pm.response.json();
if (responseData.data && responseData.data.id) {
    pm.environment.set("user_id", responseData.data.id);
    console.log("Saved user_id:", responseData.data.id);
}

// 验证数组
pm.test("Response has users array", function () {
    const jsonData = pm.response.json();
    pm.expect(jsonData.data).to.be.an('array');
    pm.expect(jsonData.data.length).to.be.above(0);
});

// 验证对象结构
pm.test("User has required fields", function () {
    const user = pm.response.json().data[0];
    pm.expect(user).to.have.property('id');
    pm.expect(user).to.have.property('name');
    pm.expect(user).to.have.property('email');
});

// Collection Runner 变量
// 创建 data.json 文件
[
  {
    "username": "user1",
    "email": "user1@example.com",
    "password": "password123"
  },
  {
    "username": "user2",
    "email": "user2@example.com",
    "password": "password456"
  }
]

// 在请求中使用
POST {{base_url}}/register

Body (JSON):
{
  "username": "{{username}}",
  "email": "{{email}}",
  "password": "{{password}}"
}

// 使用 Chrome DevTools Network 面板

// 1. 打开 DevTools (F12)
// 2. 切换到 Network 标签
// 3. 刷新页面或触发请求

// 查看请求详情：
// - Headers: 请求头和响应头
// - Preview: 格式化的响应数据
// - Response: 原始响应数据
// - Timing: 请求各阶段耗时

// 过滤请求：
// - XHR: 只显示 Ajax 请求
// - JS: 只显示 JavaScript 文件
// - CSS: 只显示样式文件
// - Img: 只显示图片

// 性能分析：
// - DOMContentLoaded: DOM 加载完成时间（蓝线）
// - Load: 页面完全加载时间（红线）
// - 瀑布图: 查看资源加载顺序和耗时

// Breakpoints (断点)
// 右键请求 -> Breakpoints
// 可以修改请求头、请求体、响应头、响应体

// Map Local (映射本地文件)
// Tools -> Map Local
// 将远程资源映射到本地文件，测试修改后的代码

// Map Remote (映射远程地址)
// Tools -> Map Remote
// 将一个地址的请求重定向到另一个地址

// Rewrite (重写)
// Tools -> Rewrite
// 添加/修改/删除 请求头、响应头、请求参数

// Throttling (限速)
// Proxy -> Throttle Settings
// 模拟慢速网络环境

// 1. 在 Postman 中创建 Collection
// 2. 点击 "Mock Servers" -> "Create Mock Server"
// 3. 为每个请求添加 Example

// Example 响应示例：
{
  "success": true,
  "data": [
    {
      "id": 1,
      "name": "张三",
      "email": "zhangsan@example.com"
    }
  ]
}

// 使用 Mock Server URL
// https://xxxxx.mock.pstmn.io/users

// 1. 打开 DevTools (F12)
// 2. 切换到 Network 标签
// 3. 点击 "No throttling" 下拉菜单

// 预设选项：
// - Fast 3G: 1.5Mbps 下载, 750Kbps 上传, 100ms 延迟
// - Slow 3G: 500Kbps 下载, 500Kbps 上传, 400ms 延迟
// - Offline: 模拟离线

// 自定义网络条件：
// - Download: 下载速度
// - Upload: 上传速度
// - Latency: 延迟时间

// 测试连接超时
fetch('https://api.example.com/users', {
  signal: AbortSignal.timeout(5000)  // 5秒超时
})
  .then(response => response.json())
  .catch(error => {
    if (error.name === 'TimeoutError') {
      console.log('请求超时');
    }
  });

// 手动实现超时
const timeout = (ms) => new Promise((_, reject) => 
  setTimeout(() => reject(new Error('Timeout')), ms)
);

Promise.race([
  fetch('https://api.example.com/users'),
  timeout(5000)
])
  .then(response => response.json())
  .catch(error => console.error('请求失败:', error));

// test-api.js
const axios = require('axios');

const BASE_URL = 'https://api.example.com';
const results = [];

// 测试用例
const testCases = [
  {
    name: '获取用户列表',
    method: 'GET',
    url: '/users',
    expectedStatus: 200,
    validateResponse: (data) => Array.isArray(data.data)
  },
  {
    name: '创建用户',
    method: 'POST',
    url: '/users',
    data: { name: '测试用户', email: 'test@example.com' },
    expectedStatus: 201,
    validateResponse: (data) => data.success === true
  },
  {
    name: '获取不存在的用户',
    method: 'GET',
    url: '/users/99999',
    expectedStatus: 404
  }
];

// 运行测试
async function runTests() {
  console.log('开始测试...\n');
  
  for (const testCase of testCases) {
    try {
      const startTime = Date.now();
      
      const response = await axios({
        method: testCase.method,
        url: BASE_URL + testCase.url,
        data: testCase.data
      });
      
      const duration = Date.now() - startTime;
      
      // 验证状态码
      const statusMatch = response.status === testCase.expectedStatus;
      
      // 验证响应内容
      let responseValid = true;
      if (testCase.validateResponse) {
        responseValid = testCase.validateResponse(response.data);
      }
      
      const passed = statusMatch && responseValid;
      
      results.push({
        name: testCase.name,
        passed,
        duration,
        status: response.status,
        message: passed ? '✅ 通过' : '❌ 失败'
      });
      
      console.log(`${testCase.name}: ${results[results.length - 1].message} (${duration}ms)`);
      
    } catch (error) {
      const expectedError = error.response?.status === testCase.expectedStatus;
      
      results.push({
        name: testCase.name,
        passed: expectedError,
        status: error.response?.status || 'Error',
        message: expectedError ? '✅ 通过' : '❌ 失败',
        error: error.message
      });
      
      console.log(`${testCase.name}: ${results[results.length - 1].message}`);
    }
  }
  
  // 输出汇总
  console.log('\n=== 测试汇总 ===');
  const passed = results.filter(r => r.passed).length;
  const total = results.length;
  console.log(`通过: ${passed}/${total}`);
  console.log(`成功率: ${(passed / total * 100).toFixed(2)}%`);
}

runTests();

// 边界值测试
const testCases = [
  { input: -1, expected: 'error' },    // 负数
  { input: 0, expected: 'error' },     // 零
  { input: 1, expected: 'success' },   // 最小正数
  { input: 100, expected: 'success' }, // 正常值
  { input: 999, expected: 'success' }, // 最大值
  { input: 1000, expected: 'error' }   // 超过最大值
];

// 异常情况测试
const errorTestCases = [
  { desc: '缺少必填参数', data: {} },
  { desc: '参数类型错误', data: { id: 'abc' } },
  { desc: '参数格式错误', data: { email: 'invalid' } },
  { desc: '请求体过大', data: 'x'.repeat(10000000) }
];

// 配置不同环境
const environments = {
  dev: {
    baseURL: 'http://localhost:3000',
    timeout: 10000
  },
  test: {
    baseURL: 'https://test-api.example.com',
    timeout: 5000
  },
  prod: {
    baseURL: 'https://api.example.com',
    timeout: 3000
  }
};

const env = process.env.NODE_ENV || 'dev';
const config = environments[env];

const api = axios.create(config);