Hoppscotch测试脚本与自动化工作流

【免费下载链接】hoppscotch 项目地址: https://gitcode.com/gh_mirrors/hop/hoppscotch

本文深入探讨Hoppscotch平台的测试脚本与自动化工作流功能，涵盖预请求脚本执行机制、后请求测试框架、环境变量管理系统以及批量编辑与自动化测试流程。文章详细分析了Hoppscotch的双层沙盒架构设计、丰富的API接口、安全机制和实用用例设计模式，为开发者提供了完整的API测试自动化解决方案。

预请求脚本执行机制与用例设计

Hoppscotch的预请求脚本功能为API测试提供了强大的动态处理能力，允许开发者在发送HTTP请求前执行自定义JavaScript代码。这一机制通过精心设计的沙盒环境和丰富的API接口，实现了安全、高效的脚本执行。

执行架构与安全机制

Hoppscotch采用双层沙盒架构来执行预请求脚本，确保代码执行的安全性和隔离性：

沙盒执行引擎

Hoppscotch提供了两种执行环境以适应不同场景：

Node.js VM环境：

export const runPreRequestScript = (
  preRequestScript: string,
  envs: TestResult["envs"]
) => {
  const context = createContext();
  const { pw, updatedEnvs } = getPreRequestScriptMethods(envs);
  
  context.pw = pw;
  context.atob = atob;
  context.btoa = btoa;
  
  runInContext(preRequestScript, context);
  return updatedEnvs;
}

Web Worker环境：

export const runPreRequestScript = (
  preRequestScript: string,
  envs: TestResult["envs"]
): Promise<E.Either<string, TestResult["envs"]>> =>
  new Promise((resolve) => {
    const worker = new Worker();
    worker.addEventListener("message", (event) => 
      resolve(event.data.results)
    );
    worker.postMessage({ preRequestScript, envs });
  });

核心API接口设计

预请求脚本通过pw.env对象提供完整的环境变量操作API：

方法名	参数	返回值	功能描述
set	key: string, value: string	undefined	设置环境变量
get	key: string	string \| undefined	获取环境变量值
getResolve	key: string	string \| undefined	获取并解析模板变量
unset	key: string	undefined	删除环境变量
resolve	value: string	string	解析字符串中的模板变量

环境变量管理机制

实用用例设计模式

1. 动态时间戳生成

// 生成当前时间戳环境变量
const timestamp = Date.now();
pw.env.set("current_timestamp", timestamp.toString());

// 生成ISO格式时间
const isoTime = new Date().toISOString();
pw.env.set("iso_time", isoTime);

// 生成自定义格式时间
const formattedTime = new Date().toLocaleString('zh-CN', {
  year: 'numeric',
  month: '2-digit',
  day: '2-digit',
  hour: '2-digit',
  minute: '2-digit',
  second: '2-digit'
});
pw.env.set("formatted_time", formattedTime);

2. 随机数据生成器

// 生成随机数字
function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

const randomId = getRandomInt(1000, 9999);
pw.env.set("random_user_id", randomId.toString());

// 生成随机字符串
function generateRandomString(length = 8) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
  let result = '';
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  return result;
}

pw.env.set("random_token", generateRandomString(16));

// 生成随机邮箱
const randomEmail = `test${getRandomInt(1000, 9999)}@example.com`;
pw.env.set("test_email", randomEmail);

3. 请求签名与认证

// HMAC签名生成
async function generateHMACSignature(secret, data) {
  const encoder = new TextEncoder();
  const key = await crypto.subtle.importKey(
    'raw',
    encoder.encode(secret),
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['sign']
  );
  
  const signature = await crypto.subtle.sign(
    'HMAC',
    key,
    encoder.encode(data)
  );
  
  return Array.from(new Uint8Array(signature))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

// 使用示例
const apiSecret = pw.env.get("API_SECRET");
const timestamp = Date.now().toString();
const payload = `${timestamp}GET/api/v1/users`;

const signature = await generateHMACSignature(apiSecret, payload);
pw.env.set("auth_timestamp", timestamp);
pw.env.set("auth_signature", signature);

4. 复杂业务逻辑处理

// 动态计算请求参数
function calculatePagination(page, size) {
  const offset = (page - 1) * size;
  const limit = size;
  
  return { offset, limit };
}

const currentPage = parseInt(pw.env.get("current_page") || "1");
const pageSize = parseInt(pw.env.get("page_size") || "20");

const pagination = calculatePagination(currentPage, pageSize);
pw.env.set("query_offset", pagination.offset.toString());
pw.env.set("query_limit", pagination.limit.toString());

// 条件性环境变量设置
const environment = pw.env.get("APP_ENV");
if (environment === "production") {
  pw.env.set("api_base_url", "https://api.production.com");
  pw.env.set("debug_mode", "false");
} else {
  pw.env.set("api_base_url", "https://api.staging.com");
  pw.env.set("debug_mode", "true");
}

错误处理与调试策略

脚本执行错误处理

try {
  // 可能出错的代码
  const complexCalculation = someRiskyOperation();
  pw.env.set("calculated_value", complexCalculation.toString());
} catch (error) {
  // 优雅降级
  console.error("预请求脚本执行失败:", error.message);
  pw.env.set("calculated_value", "default_value");
  
  // 设置错误标志
  pw.env.set("script_error", "true");
  pw.env.set("error_message", error.message);
}

输入验证模式

function validateAndSetEnvironment(key, value, expectedType = "string") {
  if (typeof key !== "string") {
    throw new Error("环境变量键必须是字符串");
  }
  
  if (typeof value !== expectedType) {
    throw new Error(`环境变量值必须是${expectedType}类型`);
  }
  
  if (expectedType === "string" && value.length > 1000) {
    throw new Error("环境变量值长度不能超过1000字符");
  }
  
  pw.env.set(key, value.toString());
}

// 使用验证函数
validateAndSetEnvironment("user_id", "12345", "string");
validateAndSetEnvironment("max_retries", 3, "number");

性能优化与最佳实践

1. 脚本执行优化

// 避免在循环中频繁操作环境变量
const results = [];
for (let i = 0; i < 100; i++) {
  results.push(calculateSomething(i));
}

// 批量设置环境变量
pw.env.set("batch_results", JSON.stringify(results));

// 使用局部变量减少环境变量操作
let tempValue = pw.env.get("base_value");
for (let i = 0; i < 10; i++) {
  tempValue = processValue(tempValue);
}
pw.env.set("processed_value", tempValue);

2. 内存管理策略

// 及时清理不再需要的环境变量
function cleanupTemporaryVariables() {
  const tempVars = ["temp_result", "intermediate_value", "cache_data"];
  tempVars.forEach(varName => {
    if (pw.env.get(varName) !== undefined) {
      pw.env.unset(varName);
    }
  });
}

// 执行清理
cleanupTemporaryVariables();

高级用例：工作流自动化

1. 多步骤API调用准备

// 第一步：生成认证令牌
const authToken = generateAuthToken();
pw.env.set("auth_token", authToken);

// 第二步：准备请求头
const requestId = generateRequestId();
pw.env.set("x_request_id", requestId);

// 第三步：计算签名
const signature = calculateRequestSignature();
pw.env.set("request_signature", signature);

// 第四步：设置超时时间
const timeout = calculateDynamicTimeout();
pw.env.set("request_timeout", timeout.toString());

2. 数据依赖解析

// 解析依赖关系并顺序执行
const dependencies = [
  { name: "user_id", generator: generateUserId },
  { name: "session_token", generator: generateSessionToken, dependsOn: ["user_id"] },
  { name: "api_key", generator: generateApiKey, dependsOn: ["session_token"] }
];

function resolveDependencies(deps) {
  const resolved = new Set();
  const results = {};
  
  while (resolved.size < deps.length) {
    let madeProgress = false;
    
    for (const dep of deps) {
      if (resolved.has(dep.name)) continue;
      
      const canResolve = !dep.dependsOn || 
        dep.dependsOn.every(d => resolved.has(d));
      
      if (canResolve) {
        const value = dep.generator();
        results[dep.name] = value;
        pw.env.set(dep.name, value);
        resolved.add(dep.name);
        madeProgress = true;
      }
    }
    
    if (!madeProgress) {
      throw new Error("无法解析依赖关系，可能存在循环依赖");
    }
  }
  
  return results;
}

resolveDependencies(dependencies);

测试与验证策略

单元测试示例

// 模拟预请求脚本测试
describe("预请求脚本功能测试", () => {
  test("应该正确设置环境变量", async () => {
    const script = `
      pw.env.set("test_var", "test_value");
      pw.env.set("number_var", "42");
    `;
    
    const result = await runPreRequestScript(script, {
      global: [],
      selected: []
    });
    
    expect(result.selected).toContainEqual({
      key: "test_var",
      value: "test_value",
      secret: false
    });
    
    expect(result.selected).toContainEqual({
      key: "number_var",
      value: "42",
      secret: false
    });
  });
  
  test("应该处理类型错误", async () => {
    const script = `
      pw.env.set(123, "value"); // 错误的key类型
    `;
    
    const result = await runPreRequestScript(script, {
      global: [],
      selected: []
    });
    
    expect(result.isLeft()).toBe(true);
  });
});

集成测试场景

// 完整工作流测试
describe("完整预请求工作流", () => {
  test("应该处理复杂的业务逻辑", async () => {
    const complexScript = `
      // 生成时间相关变量
      const now = new Date();
      pw.env.set("request_time", now.toISOString());
      
      // 计算业务逻辑
      const userId = Math.floor(Math.random() * 10000);
      pw.env.set("user_id", userId.toString());
      
      // 设置请求签名
      const signature = CryptoJS.HmacSHA256(
        userId + now.toISOString(),
        "secret_key"
      ).toString();
      
      pw.env.set("request_signature", signature);
      
      // 设置调试信息
      pw.env.set("debug_mode", "true");
      pw.env.set("request_source", "automated_test");
    `;
    
    const result = await runPreRequestScript(complexScript, {
      global: [],
      selected: []
    });
    
    // 验证所有预期的环境变量都被设置
    const envKeys = result.selected.map(item => item.key);
    expect(envKeys).toEqual(
      expect.arrayContaining([
        "request_time",
        "user_id", 
        "request_signature",
        "debug_mode",
        "request_source"
      ])
    );
  });
});

Hoppscotch的预请求脚本机制通过强大的沙盒环境、丰富的API接口和灵活的执行策略，为API测试提供了前所未有的动态处理能力。无论是简单的环境变量设置，还是复杂的业务逻辑处理，开发者都可以通过精心设计的脚本实现高度自动化的测试工作流。

后请求测试框架与断言实现

Hoppscotch的后请求测试框架是一个强大而灵活的JavaScript沙箱环境，允许用户在API请求完成后执行自定义测试脚本。该框架提供了丰富的断言方法和环境管理功能，使得API测试变得简单而高效。

测试脚本执行架构

Hoppscotch采用Web Worker技术来实现安全的测试脚本执行环境，确保用户脚本不会影响主应用的稳定性。测试框架的核心架构如下：

核心断言方法实现

Hoppscotch内置了一套完整的断言库，支持多种类型的验证操作。以下是主要的断言方法：

基础比较断言

// 相等性断言
pw.expect(actualValue).toBe(expectedValue)
pw.expect(actualValue).not.toBe(unexpectedValue)

// 类型断言  
pw.expect(variable).toBeType('string')
pw.expect(response.body).toBeType('object')

HTTP状态码断言

// 状态码范围断言
pw.expect(response.status).toBeLevel2xx()  // 200-299
pw.expect(response.status).toBeLevel3xx()  // 300-399
pw.expect(response.status).toBeLevel4xx()  // 400-499
pw.expect(response.status).toBeLevel5xx()  // 500-599

// 精确状态码断言
pw.expect(response.status).toBe(200)
pw.expect(response.status).toBe(404)

响应内容断言

// JSON响应验证
pw.expect(response.body.user.name).toBe('John Doe')
pw.expect(response.body.items.length).toBe(5)

// 头部信息验证
pw.expect(response.headers['content-type']).toBe('application/json')

环境变量管理系统

测试框架提供了完整的环境变量管理功能，支持动态设置和获取环境值：

// 设置环境变量
pw.env.set('api_key', 'your-secret-key')
pw.env.set('base_url', 'https://api.example.com')

// 获取环境变量
const apiKey = pw.env.get('api_key')
const baseUrl = pw.env.getResolve('base_url')

// 解析模板字符串
const fullUrl = pw.env.resolve('${base_url}/users')

// 删除环境变量
pw.env.unset('temp_token')

测试脚本执行流程

测试脚本的执行遵循严格的沙箱隔离原则：

错误处理与安全机制

框架实现了多层错误处理和安全保护：

1. 语法错误捕获：自动检测脚本语法问题
2. 循环引用防护：使用preventCyclicObjects防止JSON序列化问题
3. 类型安全检查：所有输入参数都进行类型验证
4. 执行超时控制：防止无限循环脚本

完整的测试示例

以下是一个完整的后请求测试脚本示例：

// 验证HTTP状态码
pw.expect(response.status).toBeLevel2xx()

// 验证响应内容类型
pw.expect(response.headers['content-type']).toBe('application/json')

// 验证JSON响应结构
pw.expect(response.body.success).toBe(true)
pw.expect(response.body.data.user.id).toBeType('number')
pw.expect(response.body.data.user.email).toBeType('string')

// 验证数组长度
pw.expect(response.body.data.items.length).toBeGreaterThan(0)

// 设置环境变量供后续请求使用
pw.env.set('auth_token', response.body.data.token)
pw.env.set('user_id', response.body.data.user.id.toString())

// 复杂的业务逻辑验证
if (response.body.data.role === 'admin') {
    pw.expect(response.body.data.permissions.length).toBeGreaterThan(5)
} else {
    pw.expect(response.body.data.permissions.length).toBeLessThan(3)
}

测试结果数据结构

测试执行完成后，框架返回结构化的测试结果：

字段	类型	描述
tests	TestDescriptor[]	测试块执行结果数组
envs.global	EnvironmentVariable[]	全局环境变量
envs.selected	EnvironmentVariable[]	当前环境变量

每个测试块包含详细的断言结果信息，包括状态（通过/失败/错误）和详细消息。

Hoppscotch的后请求测试框架通过这种设计，为API测试提供了强大而灵活的工具集，既保证了安全性又提供了丰富的功能，使得开发者能够轻松编写复杂的API验证逻辑。

环境变量管理与动态配置

Hoppscotch作为一款强大的API开发工具，其环境变量管理系统提供了灵活的配置机制，支持动态值替换、安全存储和多环境管理。本文将深入探讨Hoppscotch环境变量的核心实现机制、使用模式以及最佳实践。

环境变量架构设计

Hoppscotch的环境变量系统采用分层架构，包含以下几个核心组件：

环境变量语法与解析机制

Hoppscotch使用双尖括号语法 <<variableName>> 来标识环境变量，这种设计既直观又易于识别。解析器采用递归替换机制，支持多层嵌套变量替换。

核心解析函数

// 环境变量解析核心实现
const REGEX_ENV_VAR = /<<([^>]*)>>/g // "<<myVariable>>"
const ENV_MAX_EXPAND_LIMIT = 10

export function parseTemplateStringE(
  str: string,
  variables: Environment["variables"],
  maskValue = false
) {
  if (!variables || !str) {
    return E.right(str)
  }

  let result = str
  let depth = 0

  while (result.match(REGEX_ENV_VAR) != null && depth <= ENV_MAX_EXPAND_LIMIT) {
    result = decodeURI(encodeURI(result)).replace(REGEX_ENV_VAR, (_, p1) => {
      const variable = variables.find((x) => x && x.key === p1)
      if (variable && "value" in variable) {
        // 对敏感值进行掩码处理
        if (variable.secret && maskValue) {
          return "*".repeat(variable.value.length)
        }
        return variable.value
      }
      return ""
    })
    depth++
  }

  return depth > ENV_MAX_EXPAND_LIMIT
    ? E.left("ENV_EXPAND_LOOP")
    : E.right(result)
}

安全环境变量管理

Hoppscotch实现了敏感环境变量的安全存储机制，确保敏感信息不会泄露到持久化存储中。

秘密环境变量服务

export class SecretEnvironmentService extends Service {
  public secretEnvironments = reactive(new Map<string, SecretVariable[]>())

  public addSecretEnvironment(id: string, secretVars: SecretVariable[]) {
    this.secretEnvironments.set(id, secretVars)
  }

  public getSecretEnvironmentVariableValue(id: string, varIndex: number) {
    const secretVar = this.getSecretEnvironmentVariable(id, varIndex)
    return secretVar?.value
  }
}

环境变量替换流程

多环境支持与变量继承

Hoppscotch支持多种环境类型，包括全局环境、个人环境和团队环境，形成了完整的环境继承体系。

环境类型定义

export type SelectedEnvironmentIndex =
  | { type: "NO_ENV_SELECTED" }
  | { type: "MY_ENV"; index: number }
  | {
      type: "TEAM_ENV"
      teamID: string
      teamEnvID: string
      environment: Environment
    }

变量解析优先级

环境变量的解析遵循特定的优先级规则：

1. 全局变量 - 最低优先级，适用于所有环境
2. 环境变量 - 中等优先级，覆盖全局变量
3. 前置脚本变量 - 最高优先级，动态生成的变量

动态环境变量生成

通过前置脚本，用户可以动态生成环境变量，实现复杂的配置逻辑。

常用前置脚本示例

// 设置时间戳变量
const currentTime = Date.now();
pw.env.set("timestamp", currentTime.toString());

// 生成随机数变量
const min = 1
const max = 1000
const randomArbitrary = Math.random() * (max - min) + min
pw.env.set("randomNumber", randomArbitrary.toString());

// 基于响应设置变量
pw.env.set("authToken", pw.response.json().token);

环境变量在请求各部分的替换

环境变量可以在请求的各个部分中使用，包括URL、请求头、参数和请求体。

URL中的变量替换

// 原始URL
https://api.example.com/<<version>>/users/<<userId>>

// 替换后（version="v1", userId="123"）
https://api.example.com/v1/users/123

请求头中的变量替换

// 认证头动态生成
const getComputedAuthHeaders = (envVars: Environment["variables"], req: HoppRESTRequest) => {
  if (req.auth.authType === "bearer") {
    return [{
      key: "Authorization",
      value: `Bearer ${parseTemplateString(req.auth.token, envVars)}`
    }]
  }
  return []
}

请求体中的变量替换

对于不同内容类型的请求体，Hoppscotch提供了相应的变量替换机制：

• JSON请求体: 直接替换字符串中的变量模板
• Form Data: 对每个键值对分别进行变量替换
• Multipart Form Data: 支持文件和文本混合内容的变量替换

环境变量管理最佳实践

1. 敏感信息管理

始终将API密钥、令牌等敏感信息标记为秘密变量，确保它们不会意外泄露。

// 正确：使用秘密变量
{
  key: "api_key",
  value: "secret_value",
  secret: true
}

// 避免：明文存储敏感信息
{
  key: "api_key", 
  value: "secret_value",
  secret: false // 错误！
}

2. 环境命名规范

采用一致的命名约定，便于识别和管理多个环境。

[项目]-[环境]-[用途]
示例: 
- myapp-production-database
- myapp-staging-auth
- myapp-development-logging

3. 变量版本控制

Hoppscotch的环境变量系统支持版本控制，确保向后兼容性。

export const EnvironmentSchemaVersion = 1

export const V1_SCHEMA = z.object({
  v: z.literal(1),
  id: z.string(),
  name: z.string(),
  variables: z.array(
    z.union([
      z.object({ key: z.string(), secret: z.literal(true) }),
      z.object({ key: z.string(), value: z.string(), secret: z.literal(false) })
    ])
  ),
})

4. 循环引用防护

系统内置了循环引用检测机制，防止无限递归替换。

const ENV_MAX_EXPAND_LIMIT = 10

while (result.match(REGEX_ENV_VAR) != null && depth <= ENV_MAX_EXPAND_LIMIT) {
  // 替换逻辑
  depth++
}

if (depth > ENV_MAX_EXPAND_LIMIT) {
  return E.left("ENV_EXPAND_LOOP")
}

环境变量调试与故障排除

当环境变量替换出现问题时，可以采用以下调试策略：

1. 检查变量作用域: 确认变量在正确的环境中定义
2. 验证语法: 确保使用正确的 <<variableName>> 语法
3. 查看替换结果: 使用控制台输出或调试工具查看实际替换值
4. 检查循环引用: 避免变量之间的相互引用

Hoppscotch的环境变量管理系统提供了强大而灵活的配置能力，通过合理利用这些功能，开发者可以构建出高度可配置和易于维护的API测试工作流。环境变量的动态特性使得测试用例能够适应不同的运行环境和场景，大大提高了测试的覆盖率和有效性。

批量编辑与自动化测试流程

Hoppscotch提供了强大的批量编辑和自动化测试能力，让开发者能够高效地管理和执行API测试工作流。通过结合环境变量、预请求脚本和测试脚本，您可以构建复杂的自动化测试流程。

环境变量批量管理

Hoppscotch支持环境变量的批量配置和管理，使您能够在不同环境中轻松切换。环境变量可以存储在JSON文件中，并通过CLI工具批量加载：

[
  {
    "v": 1,
    "name": "开发环境",
    "variables": [
      {
        "key": "BASE_URL",
        "value": "https://dev-api.example.com",
        "secret": false
      },
      {
        "key": "API_KEY",
        "value": "dev_123456789",
        "secret": true
      }
    ]
  },
  {
    "v": 1,
    "name": "生产环境", 
    "variables": [
      {
        "key": "BASE_URL",
        "value": "https://api.example.com",
        "secret": false
      },
      {
        "key": "API_KEY",
        "value": "prod_987654321",
        "secret": true
      }
    ]
  }
]

预请求脚本自动化

预请求脚本允许您在发送请求前执行JavaScript代码，实现动态参数生成、认证令牌刷新等功能：

// 设置动态时间戳
pw.env.set("TIMESTAMP", Date.now());

// 生成随机字符串
const randomString = Math.random().toString(36).substring(7);
pw.env.set("RANDOM_ID", randomString);

// 从环境变量构建认证头
const apiKey = pw.env.get("API_KEY");
pw.env.set("AUTH_HEADER", `Bearer ${apiKey}`);

// 条件逻辑设置变量
if (pw.env.get("ENV") === "production") {
  pw.env.set("RETRY_COUNT", 3);
} else {
  pw.env.set("RETRY_COUNT", 1);
}

测试脚本批量验证

测试脚本提供了一套完整的断言框架，用于验证API响应：

// 状态码验证
pw.test("状态码应为200", () => {
  pw.expect(pw.response.status).toBe(200);
});

// 响应头验证
pw.test("Content-Type应为JSON", () => {
  pw.expect(pw.response.headers["Content-Type"]).toContain("application/json");
});

// JSON响应体验证
pw.test("响应包含用户数据", () => {
  const response = JSON.parse(pw.response.body);
  pw.expect(response).toHaveProperty("data.user");
  pw.expect(response.data.user.id).toBeType("number");
  pw.expect(response.data.user.email).toBeType("string");
});

// 性能测试
pw.test("响应时间应小于500ms", () => {
  pw.expect(pw.response.time).toBeLessThan(500);
});

// 数组验证
pw.test("用户列表包含项目", () => {
  const users = JSON.parse(pw.response.body);
  pw.expect(users).toBeArray();
  pw.expect(users.length).toBeGreaterThan(0);
});

CLI自动化测试流程

Hoppscotch CLI工具支持批量执行测试集合，集成到CI/CD流程中：

# 执行测试集合
hopp test collections/api-tests.json

# 使用特定环境变量
hopp test collections/api-tests.json -e environments/production.json

# 添加请求延迟
hopp test collections/api-tests.json --delay 1000

# 组合使用
hopp test collections/api-tests.json -e environments/staging.json --delay 500

测试集合组织结构

一个完整的测试集合可以包含多个请求和文件夹，支持层次化组织：

[
  {
    "v": 1,
    "name": "用户API测试套件",
    "folders": [
      {
        "name": "认证模块",
        "folders": [],
        "requests": [
          {
            "name": "用户登录",
            "endpoint": "{{BASE_URL}}/auth/login",
            "method": "POST",
            "preRequestScript": "pw.env.set('LOGIN_TIMESTAMP', Date.now());",
            "testScript": "pw.test('登录成功', () => { pw.expect(pw.response.status).toBe(200); });"
          }
        ]
      }
    ],
    "requests": [
      {
        "name": "健康检查",
        "endpoint": "{{BASE_URL}}/health",
        "method": "GET",
        "testScript": "pw.test('服务健康', () => { pw.expect(pw.response.status).toBe(200); });"
      }
    ]
  }
]

批量测试执行流程

Hoppscotch的批量测试执行遵循清晰的流程：

测试报告与结果分析

CLI工具提供详细的测试报告，包括：

指标类型	通过数	失败数	总耗时
测试用例	15	2	3.2s
测试套件	5	1	-
预请求脚本	6	0	0.5s
API请求	6	1	2.7s

高级批量编辑技巧

1. 环境变量继承：子文件夹可以继承父集合的环境变量配置
2. 脚本模块化：将常用功能封装为可重用的脚本片段
3. 条件测试：根据环境变量值动态跳过或执行特定测试
4. 数据驱动测试：使用外部数据文件驱动参数化测试

// 条件测试示例
if (pw.env.get("RUN_PERF_TESTS") === "true") {
  pw.test("性能阈值测试", () => {
    pw.expect(pw.response.time).toBeLessThan(1000);
  });
}

// 数据驱动测试示例
const testData = JSON.parse(pw.env.get("TEST_DATA"));
testData.forEach((data, index) => {
  pw.test(`测试用例 ${index + 1}`, () => {
    pw.expect(pw.response.body).toContain(data.expectedValue);
  });
});

集成CI/CD管道

将Hoppscotch测试集成到GitHub Actions工作流：

name: API Tests
on: [push, pull_request]

jobs:
  api-testing:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
    - name: Install Hoppscotch CLI
      run: npm install -g @hoppscotch/cli
    - name: Run API Tests
      run: hopp test collections/ci-tests.json -e environments/ci.json
    - name: Upload test results
      uses: actions/upload-artifact@v3
      with:
        name: test-results
        path: test-report.json

通过这种批量编辑和自动化测试流程，团队可以实现高效的API测试自动化，确保代码质量和系统稳定性。

总结

Hoppscotch通过其强大的测试脚本功能和自动化工作流能力，为API测试提供了全面的解决方案。从预请求脚本的动态处理到后请求测试的断言验证，从环境变量的灵活管理到批量测试的自动化执行，Hoppscotch展现出了卓越的技术架构和用户体验设计。其沙盒安全机制、丰富的API接口和多环境支持使得开发者能够构建复杂而可靠的测试工作流，显著提升了API测试的效率和质量。这些功能不仅适用于简单的接口测试，也能满足企业级应用的复杂测试需求，是现代API开发过程中不可或缺的强大工具。

【免费下载链接】hoppscotch 项目地址: https://gitcode.com/gh_mirrors/hop/hoppscotch