How Browser Request Recording and AI Code Generation Transform E2E API Testing

Testing challenges for complex platform products

Enterprise platforms such as Alibaba Cloud DataWorks contain dozens of sub‑modules and roughly 20 micro‑service endpoints. Most APIs are internal gateway calls without OpenAPI documentation. Test engineers must discover which API creates a data‑quality rule, record the request URL, method, parameters and response structure, and then hand‑code wrappers and test flows. Additional difficulties include complex data‑flow dependencies (e.g., a created directory ID is required by subsequent calls), quarterly version releases that change paths, parameters and response formats, and dual authentication (Cookie + CSRF token).

Traditional manual coding workflow

Open browser developer tools, perform the UI operation, and copy each request from the Network panel.

Search the code base (thousands of methods) to see if a wrapper already exists.

Understand the framework’s HTTP request pattern.

Write the wrapper code by hand.

A medium‑complex test case (10–15 APIs) typically consumes 5–6 hours and suffers from frequent errors such as misspelled parameter names, omitted parameters, type mismatches, or incorrect response‑field paths.

Recording plugin

Four‑state button UI (Start / Pause / Resume / Stop).

Automatically intercepts all XHR/Fetch calls, filters out static resources, heartbeats and pre‑flight requests.

Exports a chronologically ordered JSON array; each entry contains method, url, requestBody and responseBody.

The exported JSON acts as a “perfect API specification” because it reflects the exact request‑response pairs observed in the product.

[
  {
    "method": "GET",
    "url": "https://bff.example.com/api/quality/tree?projectId=100001",
    "requestBody": null,
    "responseBody": "{\"requestId\":\"xxx\",\"data\":[],\"code\":200}"
  },
  {
    "method": "POST",
    "url": "https://bff.example.com/api/quality/catalog?projectId=100001",
    "requestBody": "{\"projectId\":100001,\"parentId\":0,\"level\":1,\"name\":\"测试文件夹\",\"tenantId\":700000000000}",
    "responseBody": "{\"requestId\":\"xxx\",\"data\":{\"id\":12},\"code\":200}"
  }
]

AI programming tool

Smart filtering : removes non‑business requests (static files, heartbeats, pre‑flight).

Framework reuse check : searches existing wrapper layers (business, HTTP, SDK) and decides whether to reuse an existing method or create a new one.

Request comparison : compares each captured request with existing wrappers; if differences are found, a new version method is generated while preserving the old version.

Full code generation : produces the HTTP wrapper, test‑case class, initialization, step methods, assertions and cleanup, automatically wiring data flow (e.g., using a returned ID as the next request’s parameter).

Efficiency comparison

Interface discovery : 1 hour manually → 5–10 minutes with recording (≈6–12× faster).

Wrapper coding : 2 hours manually → 1–3 minutes with AI (≈40–80× faster).

Test‑case orchestration : 1–2 hours manually → 1–3 minutes with AI (≈20–40× faster).

Debug & fix : 1 hour manually → 10–30 minutes with AI assistance (≈3–6× faster).

Overall development time : 5–6 hours reduced to 20–50 minutes (≈7–15× improvement).

Accuracy comparison

Parameter‑name typo: high probability → negligible.

Parameter omission: medium probability → negligible.

Type mismatch: medium probability → negligible.

Response‑field path error: high probability → negligible.

Incorrect call order: low probability → negligible (recording preserves order).

Coding‑standard violation: high probability → negligible (AI embeds team conventions).

Why recording + description fits AI

Recorded data provides absolute truth (real request/response), complete context (field names, types, example values), correct chronological order, and explicit data dependencies (e.g., a returned ID appears in the next request). The natural‑language description adds business intent and validation goals, enabling the AI to generate code that is both technically correct and semantically aligned with the test scenario.

Limitations and preconditions

Suitable scenarios: internal platforms with many undocumented APIs, complex data‑flow dependencies, frequent version changes, and teams that already have a structured test framework. Preconditions: the recording must be performed on a correct workflow, the product must be stable, the framework’s specifications must be documented for the AI, and experienced engineers must review the generated code. Unsuitable cases: lightweight apps with few APIs, pure UI‑only automation, or situations requiring extensive external mocks.

Core advantages

Recording data is the best “interface specification” : it is absolutely real, contains full request and response bodies, preserves the correct call order, and makes data dependencies derivable.

Natural‑language description supplies business semantics : it tells the AI “what” to do, “why” it matters and what to assert.

Near‑zero coding errors : because the AI parses the exact JSON payloads, errors such as typos, omissions or type mismatches disappear.

Version‑compatible generation : when an interface changes, re‑recording triggers the AI to create a new version method while leaving existing versions untouched.

Knowledge democratization : newcomers can produce senior‑level code when assisted by the AI.

Consistent coding standards : the AI’s knowledge base embeds the team’s style rules, guaranteeing uniform output.

Example workflow (Data‑Quality Custom Template Management)

Step 1 – Recording : The engineer clicks the plugin’s “Start” button, executes the full UI flow (query directory tree, create folder, check name uniqueness, create template, verify), and stops recording. The plugin exports a JSON file containing five request‑response entries.

Step 2 – Test case description (natural language):

测试用例名称: 数据质量自定义模板管理
测试步骤:
1. 查询质量目录树，确认初始为空
2. 创建目录文件夹
3. 检查模板名称唯一性
4. 创建自定义规则模板
5. 查询用户自定义模板列表，验证创建成功

Step 3 – AI analysis & generation :

Identify the scenario as a Data‑Quality module test.

Search existing wrappers; some methods exist but parameters differ.

Compare captured requests with existing code; generate new version methods where needed.

Produce a complete test‑case class that wires the data flow (e.g., passing the catalog ID returned by stepCreateCatalog to subsequent steps).

Generated HTTP wrapper (excerpt):

public ApiResponse createCatalog(Long projectId, Long tenantId, Integer parentId, Integer level, String name) {
    return httpClient.post("/api/quality/catalog")
        .queryParam("projectId", projectId)
        .body(new JSONObject()
            .put("projectId", projectId)
            .put("parentId", parentId)
            .put("level", level)
            .put("name", name)
            .put("tenantId", tenantId))
        .execute();
}

Generated test case (excerpt):

@Test(description = "数据质量自定义模板管理")
public void testCustomTemplateManagement() {
    var catalogId = stepCreateCatalog();          // 创建目录，获取 ID
    var isUnique = stepCheckNameUnique();        // 检查名称唯一性
    var templateId = stepCreateTemplate(catalogId); // 使用目录 ID 创建模板
    stepVerifyTemplateCreated(templateId);      // 验证创建结果
    reportTestResults();
}

The AI correctly propagates the catalogId from the first step to the template‑creation step because the recorded JSON shows the ID in the response and its presence in the subsequent request body.

Summary

Recording‑driven AI automation transforms test engineers from “API information movers” into “scenario designers and AI reviewers.” It yields massive efficiency gains (up to 15× faster), near‑zero coding errors, knowledge democratization, and seamless multi‑version support, establishing a collaborative model where AI handles repetitive implementation while engineers focus on test logic and validation.