进阶的 API 自动化测试技术

在《进阶API自动化测试技术 — 第1部分》中，我们探讨了API测试的高级策略，重点关注使自动化测试更高效和可靠的技巧。在本文中，我们将继续深入探索更多高级方法，包括能够帮助您进一步改进测试流程的最佳实践。本文将提供更深入的见解，以提升您的自动化技能，并将您的API测试推向新的高度。

API链式调用和组合测试 API链式调用和组合测试是高级API测试中的强大技术，能够执行依赖请求并验证复杂的工作流程。这些技术确保API在系统内协同工作，模拟现实世界的用户交互。

什么是API链式调用？ API链式调用涉及执行一系列依赖的API请求，其中一个请求的响应作为后续请求的输入。这反映了现实世界的场景，例如用户注册后进行登录和更新个人资料。

什么是组合测试？组合测试在一个测试场景中验证多个相关的API。这些测试检查API的组合行为，确保它们作为一个整体无缝工作。

API链式调用和组合测试的好处

真实性测试：模拟现实世界的API工作流程。
覆盖率提高：验证API之间的相互依赖关系。
早期缺陷检测：在开发周期的早期识别集成问题。

API链式调用示例：用户注册和登录场景

注册新用户
使用注册的用户登录
使用登录响应中的令牌获取用户详细信息

Java实现

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.*;
public class APIChainingExample {
    public static void main(String[] args) {
        // 第1步：注册新用户
        String requestBody = "{\"username\": \"testuser\", \"email\": \"testuser@example.com\", \"password\": \"P@ssw0rd\"}";
        Response registerResponse = given()
                .contentType("application/json")
                .body(requestBody)
                .when()
                .post("https://api.example.com/register")
                .then()
                .statusCode(201)
                .extract()
                .response();
        String userId = registerResponse.jsonPath().getString("id");
        System.out.println("已使用ID注册用户：" + userId);
        // 第2步：使用注册的用户登录
        String loginRequestBody = "{\"email\": \"testuser@example.com\", \"password\": \"P@ssw0rd\"}";
        Response loginResponse = given()
                .contentType("application/json")
                .body(loginRequestBody)
                .when()
                .post("https://api.example.com/login")
                .then()
                .statusCode(200)
                .body("token", notNullValue())
                .extract()
                .response();
        String token = loginResponse.jsonPath().getString("token");
        System.out.println("已使用令牌登录用户：" + token);
        // 第3步：使用令牌获取用户详细信息
        given()
                .header("Authorization", "Bearer " + token)
                .when()
                .get("https://api.example.com/users/" + userId)
                .then()
                .statusCode(200)
                .body("email", equalTo("testuser@example.com"))
                .body("username", equalTo("testuser"));
        System.out.println("成功获取用户详细信息。");
    }
}

组合测试示例：产品生命周期测试场景

创建新产品
更新产品详细信息
检索更新后的产品详细信息
删除产品

Java实现

java复制

public class CompositeTestExample {
    public static void main(String[] args) {
        // 基础URL
        RestAssured.baseURI = "https://api.example.com";
        // 第1步：创建新产品
        String createProductRequest = "{\"name\": \"Laptop\", \"price\": 1000, \"stock\": 50}";
        Response createResponse = given()
                .contentType("application/json")
                .body(createProductRequest)
                .when()
                .post("/products")
                .then()
                .statusCode(201)
                .extract()
                .response();
        String productId = createResponse.jsonPath().getString("id");
        System.out.println("已创建产品，ID为：" + productId);
        // 第2步：更新产品详细信息
        String updateProductRequest = "{\"price\": 900, \"stock\": 60}";
        given()
                .contentType("application/json")
                .body(updateProductRequest)
                .when()
                .put("/products/" + productId)
                .then()
                .statusCode(200)
                .body("price", equalTo(900))
                .body("stock", equalTo(60));
        System.out.println("产品更新成功。");
        // 第3步：检索更新后的产品详细信息
        Response getResponse = given()
                .when()
                .get("/products/" + productId)
                .then()
                .statusCode(200)
                .extract()
                .response();
        System.out.println("更新后的产品详细信息：" + getResponse.asString());
        // 第4步：删除产品
        given()
                .when()
                .delete("/products/" + productId)
                .then()
                .statusCode(204);
        System.out.println("产品删除成功。");
    }
}

API链式调用和组合测试的最佳实践

保持独立性：确保链式请求与外部依赖隔离。
使用断言：在每一步验证响应。
令牌管理：动态处理身份验证令牌，以避免会话问题。
错误处理：为中间步骤包含健壮的错误处理机制。
数据清理：确保测试执行后环境干净整洁。

处理异步API调用的常见挑战和解决方案异步API调用允许系统执行非阻塞操作，从而实现更好的可扩展性和响应能力。然而，测试此类API会因请求处理和返回响应的固有延迟而引入挑战。

什么是异步API调用？与同步调用不同，同步调用中客户端等待服务器处理并响应，而异步API允许客户端在服务器处理请求时继续执行其他任务。

异步工作流程示例：

客户端提交长时间运行的任务（例如文件处理）。
服务器立即返回带有任务ID的确认信息。
客户端轮询或订阅通知服务以获取任务状态。

测试异步API的挑战

不确定的响应时间：响应可能不是即时的，使得验证输出更加困难。
轮询或订阅逻辑：客户端需要处理重复的状态检查或事件驱动的回调。
并发问题：如果测试未适当隔离，多个测试可能会发生冲突。

测试异步API的策略轮询机制

持续以间隔轮询API以检查任务状态，直到任务完成。场景：文件上传API接受文件并提供任务ID以稍后检查状态。

Java实现

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;

import static io.restassured.RestAssured.given;

public class PollingExample {

    public static void main(String[] args) throws InterruptedException {
        RestAssured.baseURI = "https://api.example.com";

        // 第1步：上传文件（启动任务）
        Response startTaskResponse = given()
                .contentType("multipart/form-data")
                .multiPart("file", "sample.txt", "Sample file content".getBytes())
                .when()
                .post("/upload")
                .then()
                .statusCode(202)
                .extract()
                .response();

        String taskId = startTaskResponse.jsonPath().getString("taskId");
        System.out.println("任务已启动，ID为：" + taskId);

        // 第2步：轮询状态
        String status;
        do {
            Thread.sleep(2000); // 等待2秒后轮询
            Response statusResponse = given()
                    .pathParam("taskId", taskId)
                    .when()
                    .get("/tasks/{taskId}/status")
                    .then()
                    .statusCode(200)
                    .extract()
                    .response();

            status = statusResponse.jsonPath().getString("status");
            System.out.println("当前状态：" + status);
        } while (!status.equals("COMPLETED"));

        System.out.println("任务执行成功！");
    }
}

超时处理

包含超时逻辑以避免轮询期间的无限循环。

java复制

import java.time.Instant;

public class PollingWithTimeout {

    public static void main(String[] args) throws InterruptedException {
        String taskId = "exampleTaskId"; // 假设任务ID从API获取
        Instant startTime = Instant.now();
        long timeoutInSeconds = 30; // 设置30秒的超时

        String status;
        do {
            // 检查超时
            if (Instant.now().isAfter(startTime.plusSeconds(timeoutInSeconds))) {
                throw new RuntimeException("任务在超时期间未完成");
            }

            Thread.sleep(2000); // 轮询前等待
            status = fetchTaskStatus(taskId); // 替换为实际的状态获取逻辑
            System.out.println("当前状态：" + status);
        } while (!"COMPLETED".equals(status));

        System.out.println("任务执行成功！");
    }

    private static String fetchTaskStatus(String taskId) {
        // 模拟状态检查API调用
        return "COMPLETED"; // 替换为实际的API调用逻辑
    }
}

测试基于事件的异步API

对于在完成时通知客户端的API（例如通过Webhooks或SSE），使用模拟服务器来模拟通知。

场景：支付处理API在支付完成后发送Webhook。

使用WireMock的实现：

java复制

import com.github.tomakehurst.wiremock.WireMockServer;

import static com.github.tomakehurst.wiremock.client.WireMock.*;

public class WebhookExample {

    public static void main(String[] args) {
        WireMockServer wireMockServer = new WireMockServer(8080);
        wireMockServer.start();

        // 模拟Webhook通知
        wireMockServer.stubFor(post(urlEqualTo("/webhook"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody("{\"message\": \"Payment completed\"}")));

        // 模拟Webhook通知
        System.out.println("Webhook服务器正在运行。等待事件...");
        // 在此处进行Webhook通知测试...

        wireMockServer.stop();
    }
}

测试带有回调URL的API

需要回调URL的API可以使用本地服务器（如MockServer）进行测试。

场景：电子邮件服务接受回调URL以在发送电子邮件时通知。

使用RestAssured的实现：

java复制

public class CallbackExample {

    public static void main(String[] args) {
        String callbackUrl = "http://localhost:8080/callback";

        // 第1步：提交带回调URL的电子邮件任务
        given()
                .contentType("application/json")
                .body("{\"email\": \"test@example.com\", \"callbackUrl\": \"" + callbackUrl + "\"}")
                .when()
                .post("https://api.example.com/sendEmail")
                .then()
                .statusCode(202);

        // 第2步：模拟回调监听器（实际测试中使用本地服务器）
        System.out.println("等待回调...");
        // 在此处模拟接收回调...
    }
}

处理异步API的最佳实践

超时和重试：使用定义的重试限制和超时避免无限循环。
使用模拟工具：使用WireMock或MockServer等工具模拟服务器端行为。
记录中间状态：记录每个状态或响应以便调试。
基于事件的API：使用监听器处理基于Webhook或回调的API。
并行测试：对于并发场景，确保线程安全并隔离测试数据。

Webhook和回调的自动化测试 Webhook和回调是现代应用的重要组成部分，允许API在实时通知客户端事件。与依赖轮询的传统API不同，Webhook和回调将数据发送到指定的端点，需要不同的测试方法以确保可靠性。

什么是Webhook和回调？

Webhook：当特定事件发生（例如支付完成、订单更新）时，服务器端通知发送到客户端指定的URL。
回调：API执行客户端提供的函数或URL以异步发送数据的机制。

为什么要测试Webhook和回调？

确保可靠性：验证Webhook是否按预期触发。
验证数据完整性：确认负载包含正确且完整数据。
优雅处理故障：测试无响应端点的重试和错误处理机制。

测试Webhook和回调的挑战

外部依赖：Webhook要求有可公开访问的端点。
异步性质：响应异步发送，使得验证复杂。
故障场景：模拟网络问题、无效负载或服务器不可用。

自动化测试方法

使用模拟服务器

模拟服务器模拟Webhook负载并测试当Webhook被触发时的客户端行为。

使用工具进行本地测试

工具如ngrok将本地主机暴露到互联网，使得本地测试Webhook成为可能。

端到端测试

验证从触发事件到接收和处理Webhook的整个流程。

实时示例示例1：使用WireMock测试Webhook负载

场景：测试在支付完成时通知客户端的支付服务Webhook。

实现：

java复制

import com.github.tomakehurst.wiremock.WireMockServer;
import static com.github.tomakehurst.wiremock.client.WireMock.*;
public class WebhookTestingWithWireMock {
    public static void main(String[] args) {
        // 启动WireMock服务器
        WireMockServer wireMockServer = new WireMockServer(8080);
        wireMockServer.start();
        System.out.println("WireMock服务器已在http://localhost:8080启动");
        // 模拟Webhook端点
        wireMockServer.stubFor(post(urlEqualTo("/webhook"))
                .willReturn(aResponse()
                        .withStatus(200)
                        .withBody("{\"message\": \"Webhook received successfully\"}")));
        // 模拟Webhook通知
        System.out.println("正在模拟Webhook通知...");
        // 这可以进一步通过REST调用发送负载来自动化。
        wireMockServer.verify(postRequestedFor(urlEqualTo("/webhook")));
        // 停止服务器
        wireMockServer.stop();
        System.out.println("WireMock服务器已停止。");
    }
}

示例2：测试Webhook重试

场景：模拟如果客户端端点不可用时的Webhook重试。

实现：

java复制

public class WebhookRetryTesting {
    public static void main(String[] args) {
        WireMockServer wireMockServer = new WireMockServer(8080);
        wireMockServer.start();
        // 为第一次尝试模拟失败的Webhook
        wireMockServer.stubFor(post(urlEqualTo("/webhook"))
                .inScenario("重试场景")
                .whenScenarioStateIs(STARTED)
                .willReturn(aResponse().withStatus(500))
                .willSetStateTo("第二次尝试"));
        // 为第二次尝试模拟成功的Webhook
        wireMockServer.stubFor(post(urlEqualTo("/webhook"))
                .inScenario("重试场景")
                .whenScenarioStateIs("第二次尝试")
                .willReturn(aResponse().withStatus(200)));
        System.out.println("Webhook重试模拟完成。");
        wireMockServer.stop();
    }
}

示例3：验证回调数据

场景：通知服务使用客户端提供的URL回调状态更新。

实现：

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.given;
public class CallbackTesting {
    public static void main(String[] args) {
        // 模拟回调端点
        RestAssured.baseURI = "http://localhost:8080";
        // 第1步：触发导致回调的事件
        Response triggerResponse = given()
                .contentType("application/json")
                .body("{\"event\": \"file_processed\"}")
                .when()
                .post("/trigger")
                .then()
                .statusCode(202)
                .extract()
                .response();
        System.out.println("已触发事件：" + triggerResponse.asString());
        // 第2步：验证回调负载
        Response callbackResponse = given()
                .when()
                .get("/callback")
                .then()
                .statusCode(200)
                .extract()
                .response();
        String payload = callbackResponse.asString();
        System.out.println("回调负载：" + payload);
    }
}

示例4：使用ngrok进行本地测试

下载并安装ngrok。
运行ngrok以暴露您的本地主机：

bash:

ngrok http 8080 3. 使用ngrok URL（https://random.ngrok.io ）作为测试的Webhook端点。

运行您的Java程序以通过ngrok隧道测试Webhook调用。

Webhook和回调测试的最佳实践

模拟真实场景：测试重试、延迟响应和错误处理。
模拟依赖：使用WireMock和MockServer等工具进行隔离测试。
安全端点：确保回调端点需要身份验证。
记录所有内容：记录所有Webhook调用和响应以便调试。
数据验证：验证负载数据是否符合预期。

Webhook测试的常用工具

WireMock：用于模拟和服务器行为。
MockServer：具有动态行为的高级模拟功能。
ngrok：将本地服务器暴露给公共Webhook测试。
Postman：手动或在集合中测试Webhook请求。

API测试中的缓存缓存是一种技术，用于在更易访问的位置（如本地服务器或内存中）临时存储文件或数据副本。当API返回大型数据集或经常请求的资源时，缓存有助于减少延迟、服务器负载并提高性能。对于API测试，理解和测试缓存机制至关重要，以确保响应的准确性、一致性和高效性。

什么是API测试中的缓存？ API中的缓存指的是存储昂贵API请求的结果（如数据库查询或计算），以便后续重复使用。这通常通过以下方式实现：

HTTP缓存：使用HTTP头部（Cache-Control、ETag、Last-Modified等）来控制缓存行为。
应用级缓存：将响应存储在应用程序的内存中或外部缓存层（例如Redis、Memcached）。
内容交付网络（CDN）：将缓存响应分布得更靠近客户端，以减少网络延迟。

为什么缓存在API测试中很重要？

性能：确保缓存数据提高响应时间。
一致性：验证当数据更改时缓存失效或更新是否按预期工作。
正确性：验证是否正确检索缓存响应，以及是否不会返回过时数据。

测试带有缓存的API的挑战

过时数据：测试用例需要确保不会从缓存返回过时数据。
缓存失效：测试当底层数据更改时缓存数据是否失效。
缓存命中与未命中：区分缓存命中（数据从缓存提供）和缓存未命中（数据从服务器获取）。

测试API中缓存的策略验证缓存控制头部

确保API设置了适当的缓存头部（例如Cache-Control、ETag、Expires）。

Java实现（使用RestAssured）：

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.containsString;
public class CacheHeaderTest {
    public static void main(String[] args) {
        RestAssured.baseURI = "https://api.example.com";
        // 发送请求以获取资源
        Response response = given()
                .when()
                .get("/data")
                .then()
                .statusCode(200)
                .extract()
                .response();
        // 验证是否设置了Cache-Control头部
        String cacheControl = response.header("Cache-Control");
        System.out.println("Cache-Control头部：" + cacheControl);
        // 断言Cache-Control设置正确（例如max-age=3600）
        assert cacheControl.contains("max-age=3600");
    }
}

在此示例中，我们验证了Cache-Control头部是否存在并包含预期的指令（max-age\=3600），指示缓存的生命周期。

测试缓存失效

当API资源更改时，缓存应失效。这对于确保不会提供过时数据至关重要。

Java实现：

java复制

public class CacheInvalidationTest {
    public static void main(String[] args) throws InterruptedException {
        // 第1步：初始请求
        String resourceUrl = "https://api.example.com/resource";
        Response initialResponse = given()
                .when()
                .get(resourceUrl)
                .then()
                .statusCode(200)
                .extract()
                .response();
        // 存储初始响应数据
        String initialResponseBody = initialResponse.getBody().asString();
        System.out.println("初始响应：" + initialResponseBody);
        // 第2步：修改资源
        given()
                .contentType("application/json")
                .body("{ \"data\": \"new_value\" }")
                .when()
                .put(resourceUrl)
                .then()
                .statusCode(200);
        // 第3步：验证缓存失效（确保修改后缓存更新）
        Response updatedResponse = given()
                .when()
                .get(resourceUrl)
                .then()
                .statusCode(200)
                .extract()
                .response();
        String updatedResponseBody = updatedResponse.getBody().asString();
        System.out.println("更新后的响应：" + updatedResponseBody);
        // 断言缓存响应已失效且数据已更改
        assert !updatedResponseBody.equals(initialResponseBody);
    }
}

验证缓存命中和未命中

在测试中，重要的是验证数据是否从缓存提供（缓存命中）或从服务器获取（缓存未命中）。可以通过添加延迟并验证响应时间来模拟缓存命中和未命中。

Java实现（使用RestAssured）：

java复制

public class CacheHitMissTest {

    public static void main(String[] args) throws InterruptedException {
        String resourceUrl = "https://api.example.com/resource";

        // 第1步：初始缓存未命中
        long startTime = System.currentTimeMillis();
        Response firstResponse = given()
                .when()
                .get(resourceUrl)
                .then()
                .statusCode(200)
                .extract()
                .response();

        long endTime = System.currentTimeMillis();
        System.out.println("首次响应时间（缓存未命中）：" + (endTime - startTime) + " 毫秒");

        // 第2步：通过再次请求相同资源模拟缓存命中
        startTime = System.currentTimeMillis();
        Response secondResponse = given()
                .when()
                .get(resourceUrl)
                .then()
                .statusCode(200)
                .extract()
                .response();

        endTime = System.currentTimeMillis();
        System.out.println("第二次响应时间（缓存命中）：" + (endTime - startTime) + " 毫秒");

        // 断言第二次响应更快（表明缓存命中）
        assert (endTime - startTime) < (endTime - startTime);
    }
}

在此示例中，我们比较了首次请求（缓存未命中）和第二次请求（缓存命中）的响应时间。如果第二次请求更快，则表明使用了缓存。

API测试中缓存的最佳实践

确保适当的缓存头部：验证Cache-Control、ETag、Expires和Last-Modified头部以正确控制缓存。
处理缓存过期：测试缓存过期间（max-age）和失效机制，以确保在需要时检索新鲜数据。
验证缓存一致性：确保缓存数据与服务器数据一致，特别是在修改后。
测试边缘情况：模拟缓存故障、网络问题，并测试当缓存不可用时系统的运行情况。
监控性能：定期测试响应时间以识别由于缓存带来的改进或退化。

API测试中的安全性

API安全性是确保数据的机密性、完整性和可用性的关键方面。API通常是攻击者获取敏感数据的门户，因此实施强大的安全措施至关重要。

为什么API安全性很重要？ API越来越多地用于连接系统和交换数据。由于它们处理敏感信息，它们成为攻击者的首要目标。以下是API安全性至关重要的主要原因：

数据保护：如果API未正确保护，可能会暴露敏感数据。
访问控制：配置不当的访问控制可能导致未经授权的访问。
速率限制：如果未实施适当的速率限制，API可能容易遭受拒绝服务（DoS）攻击。
注入攻击：API容易受到SQL注入、XML注入和其他形式的代码注入攻击。
合规性：适当的安全测试确保API符合数据保护法规（如GDPR、HIPAA等）。

常见的API安全漏洞

注入攻击：攻击者通过API输入注入恶意代码（例如SQL、LDAP或XML）。
破坏的身份验证：实现不当的身份验证机制可能允许攻击者冒充用户或提升权限。
敏感数据暴露：不充分的加密或不安全的敏感数据存储可能导致数据泄露。
过度数据暴露：API不应暴露比所需更多的数据；攻击者可能会利用不必要的数据字段。
不当的速率限制：没有适当速率限制的API可能容易遭受DoS攻击。
缺乏日志记录和监控：缺乏日志和监控可能使检测和响应攻击更加困难。
跨站请求伪造（CSRF）：API如果未防止从用户浏览器发送的未经授权的命令，则可能受到攻击。

API安全测试的高级策略身份验证和授权测试

测试的第一个领域是身份验证和授权机制。API必须通过令牌或凭据验证用户，并授权他们访问特定资源。

示例：测试Bearer令牌身份验证：

在本示例中，我们将测试给定的API是否需要有效的Bearer令牌，并对未授权请求返回正确的响应。

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;
public class AuthenticationTest {
    public static void main(String[] args) {
        String baseURI = "https://api.example.com";
        String invalidToken = "invalidToken123";
        // 测试未授权访问（无令牌）
        given()
            .when()
            .get(baseURI + "/protected-resource")
            .then()
            .statusCode(401)
            .body("message", equalTo("Unauthorized"));
        // 测试未授权访问（无效令牌）
        given()
            .header("Authorization", "Bearer " + invalidToken)
            .when()
            .get(baseURI + "/protected-resource")
            .then()
            .statusCode(401)
            .body("message", equalTo("Unauthorized"));
        // 测试授权访问（有效令牌）
        String validToken = "validToken123"; // 替换为有效令牌
        given()
            .header("Authorization", "Bearer " + validToken)
            .when()
            .get(baseURI + "/protected-resource")
            .then()
            .statusCode(200)
            .body("message", equalTo("Access granted"));
    }
}

此测试确保未授权用户无法访问受保护的资源，而有效用户可以访问。

测试输入验证（注入攻击）注入攻击（如SQL注入）发生在未验证的用户输入传递到后端服务器时。确保API对输入进行清理并防止注入漏洞至关重要。

示例：测试SQL注入：

java复制

public class SqlInjectionTest {
    public static void main(String[] args) {
        String baseURI = "https://api.example.com";
        String sqlInjectionPayload = "' OR 1=1 --";
        // 测试'username'参数中的SQL注入
        given()
            .param("username", sqlInjectionPayload)
            .param("password", "anyPassword")
            .when()
            .post(baseURI + "/login")
            .then()
            .statusCode(400) // 确保返回坏请求或错误
            .body("message", equalTo("Invalid credentials"));
    }
}

在此示例中，我们通过在登录表单中注入典型的SQL查询（’ OR 1\=1 -）来测试API是否容易受到SQL注入攻击。API应正确处理此输入并返回失败响应，不泄露敏感数据。

测试敏感数据暴露

敏感数据（如密码或信用卡号码）永远不应在API响应中暴露。重要的是要检查敏感数据要么不返回，要么充分掩码/加密。

示例：检查API响应中的敏感数据：

java复制

public class SensitiveDataExposureTest {
    public static void main(String[] args) {
        String baseURI = "https://api.example.com";  
        // 测试敏感数据暴露
        Response response = given()
            .when()
            .get(baseURI + "/user-profile")
            .then()
            .statusCode(200)
            .extract()
            .response();
        // 确保敏感数据如密码或信用卡号码不被暴露
        String responseBody = response.asString();
        assert !responseBody.contains("password");
        assert !responseBody.contains("credit_card_number");
    }
}

在此测试中，我们确保响应中不暴露敏感字段，如password或credit_card_number。

速率限制和DoS保护

API应实施速率限制以防止滥用和DoS（拒绝服务）攻击。我们可以测试API是否正确强制执行速率限制。

示例：测试API速率限制：

java复制

public class RateLimitingTest {
    public static void main(String[] args) {
        String baseURI = "https://api.example.com";   
        // 模拟快速连续的多次请求以触发速率限制
        for (int i = 0; i < 100; i++) {
            Response response = given()
                .when()
                .get(baseURI + "/resource")
                .then()
                .extract()
                .response();
            if (i > 5) { // 在5次请求后，我们期望速率限制生效
                response.then()
                    .statusCode(429) // 429 请求过多
                    .body("message", equalTo("Rate limit exceeded"));
            }
        }
    }
}

在此测试中，我们模拟对端点的多次请求，并确保API通过返回429请求过多状态，在达到阈值后强制执行速率限制。

CSRF（跨站请求伪造）保护

CSRF攻击可能发生在攻击者诱骗用户向API发出不想要的请求时。为了防止CSRF攻击，API必须验证请求以确保它们来自合法来源。

示例：测试CSRF保护：

java复制

public class CSRFProtectionTest {
    public static void main(String[] args) {
        String baseURI = "https://api.example.com";
        String csrfToken = "validCsrfToken123"; // 假设您有有效的CSRF令牌 
        // 测试无CSRF令牌的请求（应失败）
        given()
            .when()
            .post(baseURI + "/update-profile")
            .then()
            .statusCode(403) // 禁止访问
            .body("message", equalTo("CSRF token missing or invalid"));
        // 测试带有CSRF令牌的有效请求
        given()
            .header("X-CSRF-Token", csrfToken)
            .when()
            .post(baseURI + "/update-profile")
            .then()
            .statusCode(200) // 成功
            .body("message", equalTo("Profile updated successfully"));
    }
}

在此测试中，我们确保需要CSRF令牌的API请求会拒绝没有有效令牌的请求。

API安全测试的最佳实践

使用安全的身份验证：始终使用强大的身份验证方法（例如OAuth、JWT）。
加密敏感数据：确保敏感数据在静态和传输中都被加密。
清理输入：始终验证和清理输入以防止注入攻击。
强制执行速率限制：实施速率限制以防止滥用和DoS攻击。
使用HTTPS：始终使用HTTPS保护传输中的数据。
记录和监控：实施记录和监控以检测异常活动。

API版本控制

当需要保持向后兼容性并确保不同版本API之间的无缝交互时，API版本控制至关重要。它允许开发人员在不影响现有用户的情况下对API进行更改或改进。作为高级API测试策略的一部分，版本控制确保API的更新不会无意间影响现有的客户端应用程序。

为什么API版本控制很重要？随着时间的推移，API会随着新功能的添加、现有功能的改进或弃用而演变。但是，直接更改API可能会破坏依赖于旧版本的应用程序。这就是版本控制发挥作用的地方：

向后兼容性：使用旧版本API的客户端将按预期正常工作。
无缝升级：新版本可以引入功能或修复，而不会扰乱现有用户。
版本特定测试：确保不同版本的API按预期响应，而不会出现跨版本问题。 API版本控制对于需要支持使用同一API不同版本的多个客户端的系统至关重要，特别是当API快速演变时。

API版本控制策略类型

有几种API版本控制策略。让我们探讨一些最常见的策略：

URI版本控制：将版本信息直接包含在API URL中。
头部版本控制：将版本信息包含在请求头部。
查询参数版本控制：将版本信息作为URL中的查询参数传递。
接受头部版本控制：使用接受头部定义版本。
内容协商：使用内容类型或媒体类型定义版本。

常见的API版本控制格式

URI版本控制：https://api.example.com/v1/resource
头部版本控制：请求头部：Accept: application/vnd.example.v1+json
查询参数版本控制：https://api.example.com/resource?version=1
接受头部版本控制：请求头部：Accept: application/json; version\=1

如何使用Java测试版本化API

让我们探讨如何使用Java和RestAssured（API测试中最流行的库之一）测试版本化API。下面，我们将涵盖使用不同版本控制策略测试的各种场景。

URI版本控制

在URI版本控制中，版本信息直接包含在API端点中。让我们看看如何使用此策略测试不同版本的API。

示例：测试API的不同版本

假设我们有一个支持v1和v2版本的API。让我们测试这两个版本以确保跨版本功能的一致性。

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class ApiVersioningTest {

    public static void main(String[] args) {
        String baseURI = "https://api.example.com";

        // 测试版本v1
        Response responseV1 = given()
            .when()
            .get(baseURI + "/v1/resource")
            .then()
            .statusCode(200)
            .body("version", equalTo("v1"))
            .body("message", equalTo("Success"))
            .extract()
            .response();

        // 测试版本v2
        Response responseV2 = given()
            .when()
            .get(baseURI + "/v2/resource")
            .then()
            .statusCode(200)
            .body("version", equalTo("v2"))
            .body("message", equalTo("Success"))
            .extract()
            .response();
    }
}

解释：

在上面的代码中，我们测试了/version和v2版本的/resource端点。响应正文应包含version字段，指示正确的版本和成功消息。

头部版本控制

在头部版本控制中，API版本在请求头部中指定。这允许更干净的URL，但需要在请求中设置自定义头部。

示例：测试头部版本控制

java复制

import io.restassured.RestAssured;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class HeaderVersioningTest {

    public static void main(String[] args) {
        String baseURI = "https://api.example.com";

        // 使用头部版本控制测试v1版本
        given()
            .header("Accept", "application/vnd.example.v1+json")
            .when()
            .get(baseURI + "/resource")
            .then()
            .statusCode(200)
            .body("version", equalTo("v1"))
            .body("message", equalTo("Success"));

        // 使用头部版本控制测试v2版本
        given()
            .header("Accept", "application/vnd.example.v2+json")
            .when()
            .get(baseURI + "/resource")
            .then()
            .statusCode(200)
            .body("version", equalTo("v2"))
            .body("message", equalTo("Success"));
    }
}

解释：

在这里，通过Accept头部进行版本控制，客户端通过设置application/vnd.example.v1+json或application/vnd.example.v2+json的值来指定期望的版本。响应应返回对应的版本。

查询参数版本控制

查询参数版本控制涉及将版本作为URL中的查询参数传递。这种方法简单，但可能不是每个用例的理想选择，因为它将版本控制暴露在URL中。

示例：测试查询参数版本控制

java复制

import io.restassured.RestAssured;

import static io.restassured.RestAssured.*;

import static org.hamcrest.Matchers.*;

public class QueryParamVersioningTest {

    public static void main(String[] args) {

        String baseURI = "https://api.example.com";

        // 使用查询参数测试v1版本

        given()

            .param("version", "1")

            .when()

            .get(baseURI + "/resource")

            .then()

            .statusCode(200)

            .body("version", equalTo("v1"))

            .body("message", equalTo("Success"));

        // 使用查询参数测试v2版本

        given()

            .param("version", "2")

            .when()

            .get(baseURI + "/resource")

            .then()

            .statusCode(200)

            .body("version", equalTo("v2"))

            .body("message", equalTo("Success"));

    }

}

解释：

API版本作为查询参数传递，例如?version\=1或?version\=2。服务器应基于参数返回正确的版本。

接受头部版本控制

接受头部版本控制使用Accept头部定义版本。它类似于头部版本控制，但侧重于通过内容协商定义版本。

示例：测试接受头部版本控制

java复制

import io.restassured.RestAssured;

import static io.restassured.RestAssured.*;

import static org.hamcrest.Matchers.*;

public class AcceptHeaderVersioningTest {

    public static void main(String[] args) {

        String baseURI = "https://api.example.com";

        // 使用Accept头部测试v1版本

        given()

            .header("Accept", "application/json; version=1")

            .when()

            .get(baseURI + "/resource")

            .then()

            .statusCode(200)

            .body("version", equalTo("v1"))

            .body("message", equalTo("Success"));

        // 使用Accept头部测试v2版本

        given()

            .header("Accept", "application/json; version=2")

            .when()

            .get(baseURI + "/resource")

            .then()

            .statusCode(200)

            .body("version", equalTo("v2"))

            .body("message", equalTo("Success"));

    }

}

解释：

版本通过Accept头部指定，内容类型指示版本，例如application/json; version\=1或application/json; version\=2。应基于头部返回正确的版本。

API版本控制的最佳实践

文档化您的版本控制策略：始终明确记录API版本的结构以及客户端如何切换版本。
逐步淘汰版本：在淘汰旧版本之前提供适当的预先通知。
最小化破坏性更改：尽可能避免对API进行破坏性更改。相反，在新版本中添加新功能。
测试新旧版本：通过测试API的多个版本确保向后兼容性。
版本一致性：保持版本命名和API响应格式的一致性。

HATEOAS简介 HATEOAS（超媒体作为应用状态引擎）是REST架构风格的约束之一，提供了一种方式，使客户端应用程序能够动态地与API交互，在运行时发现可用的操作和资源。它使API更加灵活和自描述，服务器提供超媒体链接以及数据，指导客户端可能采取的下一步操作。

例如，想象一个提供书籍列表信息的REST API。除了返回关于书籍的原始数据外，API可能还包含超媒体链接，用于更新书籍、删除书籍或查看更多详细信息等操作。这些链接允许客户端在不需要事先知道API结构的情况下发现新功能。

为什么HATEOAS很重要？

动态客户端行为：客户端无需硬编码端点URL。它们可以按照服务器提供的链接与API交互。
解耦的客户端-服务器交互：客户端不需要事先了解完整的API结构。只要正确实现了HATEOAS，API就可以在不破坏客户端的情况下演变。
自描述API：API响应包含所有必要的链接和操作，使其更容易理解和导航。
简化的导航：客户端可以按照链接从一个资源导航到另一个资源，而不需要额外的文档。

HATEOAS组件

链接：指导客户端可能采取的操作的超媒体链接。
Rel：定义当前资源与链接资源之间的关系（例如“下一个”、“上一个”、“自我”）。
方法：链接支持的HTTP方法（GET、POST、PUT、DELETE）。

JSON复制

{
  "book": {
    "id": 123,
    "title": "The Art of API Testing",
    "author": "John Doe",
    "links": [
      {
        "rel": "self",
        "href": "https://api.example.com/books/123"
      },
      {
        "rel": "update",
        "href": "https://api.example.com/books/123/update",
        "method": "PUT"
      },
      {
        "rel": "delete",
        "href": "https://api.example.com/books/123",
        "method": "DELETE"
      },
      {
        "rel": "author",
        "href": "https://api.example.com/authors/456"
      }
    ]
  }
}

在此示例中，书籍资源包含多个链接（self、update、delete和author），指导客户端可能采取的下一步操作。

API中HATEOAS的高级测试策略在高级API测试中，HATEOAS测试确保这些链接有效、可访问且遵循预期的格式。让我们通过使用Java和RestAssured来测试符合HATEOAS的API。

HATEOAS测试的一个主要方面是验证API响应中存在正确的超媒体链接。下面是一个如何使用Java和RestAssured测试链接存在和正确性的示例。

示例1：测试API响应中的链接

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class HATEOASTest {

    public static void main(String[] args) {
        String baseURI = "https://api.example.com";

        // 获取书籍资源并检查HATEOAS链接
        Response response = given()
            .when()
            .get(baseURI + "/books/123")
            .then()
            .statusCode(200)
            .body("book.links.size()", greaterThan(0))  // 检查链接存在
            .body("book.links[0].rel", equalTo("self"))  // 检查self链接
            .body("book.links[1].rel", equalTo("update"))  // 检查update链接
            .body("book.links[2].rel", equalTo("delete"))  // 检查delete链接
            .body("book.links[3].rel", equalTo("author"))  // 检查author链接
            .extract()
            .response();
    }
}

解释：

book.links.size()确保响应包含非空链接列表。 book.links[0].rel验证self链接的存在，类似地，其他检查确保update、delete和author链接的存在。此简单测试验证响应中包含必要的链接，并且rel属性符合预期关系类型。

接下来，我们可以测试HATEOAS链接本身是否有效（即URL可访问且返回预期的HTTP状态码）。

示例2：验证超媒体链接

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class HATEOASLinkValidationTest {

    public static void main(String[] args) {
        String baseURI = "https://api.example.com";

        // 获取书籍资源
        Response response = given()
            .when()
            .get(baseURI + "/books/123")
            .then()
            .statusCode(200)
            .extract()
            .response();

        // 从响应中提取self链接
        String selfLink = response.jsonPath().getString("book.links.find { it.rel == 'self' }.href");

        // 验证self链接可访问
        given()
            .when()
            .get(selfLink)  // 跟随self链接
            .then()
            .statusCode(200);  // 确保链接有效并返回200 OK
    }
}

解释：

我们使用jsonPath()从响应中提取self链接，然后跟随链接以验证它可访问并返回200 OK状态。此测试确保响应中的HATEOAS链接是功能正常的。

使用HATEOAS测试动态导航

HATEOAS最强大的方面之一是它允许客户端的动态导航。良好的测试将检查通过提供的链接导航是否如预期工作。例如，跟随update链接更新资源，或跟随author链接检索作者信息。

示例3：通过HATEOAS链接测试动态导航

java复制

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

public class HATEOASDynamicNavigationTest {

    public static void main(String[] args) {
        String baseURI = "https://api.example.com";

        // 获取书籍资源
        Response response = given()
            .when()
            .get(baseURI + "/books/123")
            .then()
            .statusCode(200)
            .extract()
            .response();

        // 从响应中提取update链接
        String updateLink = response.jsonPath().getString("book.links.find { it.rel == 'update' }.href");

        // 通过跟随update链接测试更新功能
        given()
            .header("Content-Type", "application/json")
            .body("{ \"title\": \"The New Art of API Testing\" }")  // 示例更新负载
            .when()
            .put(updateLink)  // 跟随update链接
            .then()
            .statusCode(200)  // 确保更新请求成功
            .body("message", equalTo("Update successful"));
    }
}

解释：

我们从响应中提取update链接，然后向其发送PUT请求以更新书籍的标题。此测试模拟使用HATEOAS链接的客户端导航，确保服务器定义的动态操作得到适当测试。

HATEOAS测试的最佳实践

验证链接存在：确保响应包含所有相关超媒体链接，如self、update、delete等。
检查链接有效性：验证HATEOAS链接中提供的URL可访问且返回预期的HTTP状态码。
测试动态导航：通过跟随HATEOAS链接并测试预期操作是否成功，模拟客户端行为。
确保链接格式一致：链接应遵循一致的格式（例如rel、href、method）。
自动化链接测试：使用自动化测试验证链接始终有效并指向正确操作。

利用OpenAPI规范和Swagger

API测试已成为现代软件开发的基石，而像OpenAPI规范（OAS）和Swagger这样的工具使设计、记录和有效测试API变得更加容易。本博客深入探讨如何利用OAS和Swagger增强您的API测试策略，重点介绍它们与Java的集成以应对实际测试场景。

什么是OpenAPI规范（OAS）？ OpenAPI规范（前身为Swagger规范）是定义RESTful API的标准化格式。它作为开发者、测试人员和其他利益相关者之间的蓝图，实现无缝的沟通和协作。

主要特点：

提供机器可读和人类可读的API描述。
支持自动生成API客户端、服务器和文档。
增强团队间的一致性。

什么是Swagger？ Swagger是围绕OAS构建的一套工具，简化API设计、记录和测试。工具包括：

Swagger编辑器：用于编写和可视化API规范。
Swagger代码生成器：用于生成API客户端和服务器存根。
Swagger UI：用于交互式API文档。

使用OAS/Swagger在API测试中的好处

标准化：确保一致的API定义。
自动化：促进自动化的测试工作流程。
错误预防：在开发早期验证API契约。
增强协作：为所有利益相关者提供清晰的API文档。

使用Java设置OpenAPI/Swagger

要利用Java中的OpenAPI和Swagger，您可以使用诸如Swagger-Parser、Swagger代码生成器和测试工具如RestAssured等库。

示例1：验证OpenAPI规范步骤1：添加依赖项

在pom.xml中包含以下Maven依赖项：

xml复制

<dependency>
    <groupId>io.swagger.parser.v3</groupId>
    <artifactId>swagger-parser</artifactId>
    <version>2.0.30</version>
</dependency>

步骤2：验证OpenAPI规范

java复制

import io.swagger.v3.parser.OpenAPIV3Parser;
import io.swagger.v3.parser.core.models.SwaggerParseResult;

public class OpenAPISpecValidator {
    public static void main(String[] args) {
        String specUrl = "https://petstore.swagger.io/v2/swagger.json";

        SwaggerParseResult result = new OpenAPIV3Parser().readLocation(specUrl, null, null);
        if (result.getMessages().isEmpty()) {
            System.out.println("OpenAPI规范有效！");
        } else {
            System.out.println("验证错误：" + result.getMessages());
        }
    }
}

示例2：使用Swagger代码生成器生成API客户端步骤1：安装Swagger代码生成器

从Swagger的GitHub发布页面安装Swagger代码生成器CLI。

步骤2：生成Java客户端

运行以下命令：

swagger-codegen generate -i https://petstore.swagger.io/v2/swagger.json -l java -o ./petstore-client

步骤3：在测试中使用生成的客户端

java复制

import io.swagger.client.ApiClient;
import io.swagger.client.ApiException;
import io.swagger.client.api.PetApi;
import io.swagger.client.model.Pet;

public class PetStoreClientTest {
    public static void main(String[] args) {
        ApiClient client = new ApiClient();
        client.setBasePath("https://petstore.swagger.io/v2");

        PetApi api = new PetApi(client);
        try {
            Pet pet = api.getPetById(1L);
            System.out.println("宠物名称：" + pet.getName());
        } catch (ApiException e) {
            System.err.println("API异常：" + e.getMessage());
        }
    }
}

示例3：使用OpenAPI契约自动化API测试步骤1：定义API契约

步骤1：定义API契约

使用Swagger编辑器定义API模式（例如petstore-api.yaml）。

步骤2：编写契约测试

java复制

import io.restassured.module.jsv.JsonSchemaValidator;
import static io.restassured.RestAssured.*;

public class PetStoreAPITest {
    public static void main(String[] args) {
        baseURI = "https://petstore.swagger.io/v2";

        given()
            .when()
            .get("/pet/1")
            .then()
            .assertThat()
            .statusCode(200)
            .body(JsonSchemaValidator.matchesJsonSchemaInClasspath("petstore-schema.json"));
    }
}

实际场景：与Swagger的持续集成

步骤1：将您的API规范存储在仓库中（例如GitHub）。

步骤2：在您的CI/CD管道中使用Swagger验证器确保规范有效。

步骤3：使用生成的客户端和模式验证自动化回归测试。

掌握API测试中的测试数据生成和操作：在API测试中，准确和多样化的测试数据对于验证API的健壮性和可靠性至关重要。测试数据的生成和操作是确保API在所有可能场景（包括边缘情况、边界条件和负面测试用例）下得到测试的高级策略。

为什么测试数据在API测试中很重要？

全面覆盖：测试数据确保API有效处理不同的输入场景。
提高准确性：真实数据有助于发现生产环境中可能出现的问题。
边缘情况验证：不寻常的数据或边界值有助于发现隐藏的错误。
自动化：动态生成的数据可重复使用并加速测试周期。

测试数据生成和操作的关键技术

静态数据：使用存储在文件或数据库中的预定义数据集。
动态数据生成：在测试执行期间程序化创建数据。
参数化数据：使用如TestNG或JUnit等框架传递不同的数据集。
模拟数据：利用如Faker等工具生成随机但有意义的数据。
操作：将数据转换为测试所需的格式或结构。

在Java中设置测试数据生成

依赖项添加以下Maven依赖项以使用如Faker和Jackson等工具：

xml复制

<dependency>
    <groupId>com.github.javafaker</groupId>
    <artifactId>javafaker</artifactId>
    <version>1.0.2</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

示例1：使用Faker生成随机测试数据

使用Faker生成随机数据

java复制

import com.github.javafaker.Faker;

public class TestDataGenerator {
    public static void main(String[] args) {
        Faker faker = new Faker();

        String name = faker.name().fullName();
        String email = faker.internet().emailAddress();
        String phoneNumber = faker.phoneNumber().cellPhone();
        String city = faker.address().city();

        System.out.println("姓名：" + name);
        System.out.println("电子邮件：" + email);
        System.out.println("电话：" + phoneNumber);
        System.out.println("城市：" + city);
    }
}

示例2：为API请求动态创建JSON负载

动态创建JSON负载

java复制

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class DynamicPayload {
    public static void main(String[] args) throws Exception {
        Map<String, Object> payload = new HashMap<>();
        payload.put("id", 101);
        payload.put("name", "Test User");
        payload.put("email", "testuser@example.com");
        payload.put("age", 25);

        ObjectMapper mapper = new ObjectMapper();
        String jsonPayload = mapper.writeValueAsString(payload);

        System.out.println("生成的JSON负载：" + jsonPayload);
    }
}

在API测试中发送生成的负载

java复制

import static io.restassured.RestAssured.*;
import static io.restassured.http.ContentType.JSON;

public class APITestWithDynamicData {
    public static void main(String[] args) {
        String payload = "{ \"id\": 101, \"name\": \"Test User\", \"email\": \"testuser@example.com\", \"age\": 25 }";

        given()
            .contentType(JSON)
            .body(payload)
            .when()
            .post("https://jsonplaceholder.typicode.com/users")
            .then()
            .statusCode(201)
            .log().body();
    }
}

示例3：使用TestNG的DataProviders进行参数化测试

TestNG DataProvider

java复制

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

public class ParameterizedTests {
    @DataProvider(name = "userData")
    public Object[][] getUserData() {
        return new Object[][] {
            { "John Doe", "john.doe@example.com", 30 },
            { "Jane Smith", "jane.smith@example.com", 25 }
        };
    }

    @Test(dataProvider = "userData")
    public void testCreateUser(String name, String email, int age) {
        System.out.println("创建用户：" + name + ", " + email + ", " + age);
        // 在此处添加API调用逻辑
    }
}

示例4：修改测试数据以进行边界测试

修改JSON负载以进行边界测试

java复制

import org.json.JSONObject;

public class TestDataManipulation {
    public static void main(String[] args) {
        String payload = "{ \"id\": 101, \"name\": \"Test User\", \"email\": \"testuser@example.com\", \"age\": 25 }";

        JSONObject jsonObject = new JSONObject(payload);
        jsonObject.put("age", 150); // 边界值

        System.out.println("修改后的负载：" + jsonObject.toString());
    }
}

实际用例：为CI/CD管道自动化测试数据步骤1：使用Faker或动态JSON生成创建测试数据。步骤2：将生成的数据存储在内存数据库（例如H2）中以实现可重用性。步骤3：使用Jenkins或GitHub Actions等工具在CI/CD管道中使用多样化数据集验证API。

总结

高级API测试策略使QA工程师和开发人员能够全面评估现代复杂系统中API的可靠性、性能和功能。通过将高效处理HTTP方法、状态码和嵌套资源的概念与过滤、分页和数据驱动测试等策略相结合，这些方法确保API在预期和边缘情况场景下得到全面测试。

包含API链式调用、异步测试和Webhook验证等技术，进一步实现强大的端到端工作流程，而关注缓存、安全性、版本控制和HATEOAS等方面则确保符合行业标准和最佳实践。测试数据的生成和操作，结合模拟数据的使用，增强测试的灵活性和覆盖范围，使这些策略能够扩展以适应实际应用。

总之，掌握这些高级策略不仅能发现潜在的漏洞，还能将API测试过程提升到新的高度，以满足动态和分布式系统的需求。通过采用这些实践，团队可以交付的API不仅是功能性的，而且是安全的、高效的，并且具有前瞻性。

见证我们精心的方法和尖端解决方案如何将质量和性能提升到新高度。开始您的软件测试卓越之旅。有关更多信息，请参阅工具与技术及QA服务。

如果您想了解更多关于我们提供的出色服务，请务必联系我们。

快乐测试 🙂

进阶的 API 自动化测试技术 — 第二部分