---
title: "管理有参数中继的测试用例"
language: "zh"
url: "https://docs.testany.io/zh/docs/managing-test-case-with-relay-case/"
markdown_url: "https://docs.testany.io/zh/docs/managing-test-case-with-relay-case.md"
translation: "https://docs.testany.io/en/docs/managing-test-case-with-relay-case.md"
last_updated: "2026-01-30T21:25:07+08:00"
---

# 管理有参数中继的测试用例

## 概述

重用测试用例的执行在管道编排中非常有价值。某些用例的输出可以作为其他用例的输入，从而在管道执行期间实现更好的编排。

## 理解中继用例

**中继用例**：中继是测试用例的一个属性。具有该属性的测试用例在执行完成后可以将其预先声明的变量值作为输入传递给同一管道中的其他用例。中继用例促进了数据传输和共享，确保了测试用例之间的依赖关系得到适当管理，从而提高了测试过程的自动化和效率。

## 管理中继用例

### 在测试用例中设置中继用例

要将您的用例指定为中继用例，请确保Testany平台和您的测试代码都能识别您使用的环境变量。这需要在两个方面进行配置：

1. 在Testany平台上配置
2. 在您的测试代码中进行配置

### 在Testany平台上的配置

将环境变量键设置为中继键，以便在管道编排中使用。

- 进入测试用例详情页面，点击编辑。

  ![image-20240229-111006.png](https://docs.testany.io/docs/images/zh/image-20240229-111006_ae701d99.png)
- 点击“添加新环境变量集”，并输入您希望用作中继键的**键名称**。键名称必须与您代码中设置的键匹配。您可以配置多个键作为中继键。（例如，设置AAA和NEW\_URL作为中继键。）

  ![image-20240923-080016.png](https://docs.testany.io/docs/images/zh/image-20240923-080016_2c655c77.png)

点击“保存”按钮，AAA和NEW\_URL环境变量将可用于管道编排。

![image-20240229-112019.png](https://docs.testany.io/docs/images/zh/image-20240229-112019_3808f7ac.png)

## 将代码添加到您的测试脚本

在您的测试用例中，使用环境变量`TESTANY_OUTPUT_RELAY_SERVICE`将输出设置为中继键。

### 示例代码

以下是不同测试框架的示例，展示如何将测试执行过程中产生的动态值进行中继传递。

#### Postman

在 Postman 请求的 **Tests** 标签页中，发送 POST 请求来中继动态值：

![image-20240923-080453.png](https://docs.testany.io/docs/images/zh/image-20240923-080453_c6141635.png)

```javascript
// Tests 标签页 - 中继 API 响应中的动态值
const response = pm.response.json();

// 将动态值发送到中继服务
pm.sendRequest({
    url: pm.environment.get('TESTANY_OUTPUT_RELAY_SERVICE'),
    method: 'POST',
    header: { 'Content-Type': 'application/json' },
    body: {
        mode: 'raw',
        raw: JSON.stringify({
            ORDER_ID: response.order_id,      // 响应中的动态值
            CREATED_AT: response.created_at   // 响应中的动态值
        })
    }
});
```

#### curl

```bash
# 使用 curl 中继动态值
curl -X POST ${TESTANY_OUTPUT_RELAY_SERVICE} \
  -H "Content-Type: application/json" \
  -d '{"ORDER_ID": "'"${ORDER_ID}"'", "STATUS": "'"${STATUS}"'"}'
```

#### Python

**输出用例** - 中继执行过程中产生的动态值：

```python
import os
import requests

class TestCreateOrder:
    def test_create_order(self):
        # 调用 API 获取动态响应
        response = requests.post('https://api.example.com/orders', json={
            'product': 'laptop',
            'quantity': 1
        })
        assert response.status_code == 201

        # 从响应中提取动态值
        data = response.json()
        order_id = data['order_id']        # 例如 "ORD-20240129-8A3F"
        created_at = data['created_at']    # 例如 "2024-01-29T10:30:00Z"

        # 将动态值中继给下游用例
        relay_service = os.environ.get('TESTANY_OUTPUT_RELAY_SERVICE')
        requests.post(relay_service, json={
            'ORDER_ID': order_id,
            'CREATED_AT': created_at
        })
```

**输入用例** - 使用上游用例中继过来的值：

```python
import os
import requests

class TestGetOrder:
    def test_get_order_details(self):
        # 从环境变量获取中继过来的值
        order_id = os.environ.get('ORDER_ID')

        # 使用该动态值
        response = requests.get(f'https://api.example.com/orders/{order_id}')
        assert response.status_code == 200
```

#### Playwright

**输出用例** - 中继浏览器交互中产生的动态值：

```typescript
import { test, expect } from '@playwright/test';
import axios from 'axios';

test('create order and relay order ID', async ({ page }) => {
  await page.goto('https://example.com/checkout');

  // 填写表单并提交
  await page.fill('#product', 'laptop');
  await page.fill('#quantity', '1');

  // 捕获 API 响应
  const [response] = await Promise.all([
    page.waitForResponse('**/api/orders'),
    page.click('#submit-order')
  ]);

  const data = await response.json();
  const orderId = data.order_id;

  // 中继动态值
  const relayService = process.env.TESTANY_OUTPUT_RELAY_SERVICE;
  await axios.post(relayService, {
    ORDER_ID: orderId,
    CONFIRMATION_NUMBER: data.confirmation_number
  });
});
```

**输入用例** - 使用中继过来的值：

```typescript
import { test, expect } from '@playwright/test';

test('verify order details', async ({ page }) => {
  // 从环境变量获取中继过来的值
  const orderId = process.env.ORDER_ID;

  await page.goto(`https://example.com/orders/${orderId}`);
  await expect(page.locator('.order-status')).toBeVisible();
});
```

#### Java (JUnit/TestNG)

**输出用例** - 中继动态值：

```java
import org.junit.jupiter.api.Test;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class CreateOrderTest {
    @Test
    public void testCreateOrder() throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        // 调用 API 创建订单
        HttpRequest createRequest = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/orders"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(
                "{\"product\": \"laptop\", \"quantity\": 1}"))
            .build();

        HttpResponse<String> response = client.send(createRequest,
            HttpResponse.BodyHandlers.ofString());

        // 从响应中解析动态值（使用 JSON 库）
        String orderId = parseOrderId(response.body());
        String status = parseStatus(response.body());

        // 中继动态值
        String relayService = System.getenv("TESTANY_OUTPUT_RELAY_SERVICE");
        HttpRequest relayRequest = HttpRequest.newBuilder()
            .uri(URI.create(relayService))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(
                String.format("{\"ORDER_ID\": \"%s\", \"STATUS\": \"%s\"}",
                    orderId, status)))
            .build();

        client.send(relayRequest, HttpResponse.BodyHandlers.ofString());
    }
}
```

**输入用例** - 使用中继过来的值：

```java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class GetOrderTest {
    @Test
    public void testGetOrderDetails() throws Exception {
        // 从环境变量获取中继过来的值
        String orderId = System.getenv("ORDER_ID");

        // 在测试中使用该动态值
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.example.com/orders/" + orderId))
            .GET()
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());
        assertEquals(200, response.statusCode());
    }
}
```

#### JMeter

**输出用例** - 使用 JSR223 PostProcessor 中继动态值：

1. 在 HTTP Request 取样器后添加 **JSR223 PostProcessor**
2. 语言选择 **groovy**
3. 添加以下脚本：

```groovy
import groovy.json.JsonSlurper
import groovy.json.JsonOutput

// 解析响应以获取动态值
def jsonSlurper = new JsonSlurper()
def response = jsonSlurper.parseText(prev.getResponseDataAsString())

def orderId = response.order_id
def status = response.status

// 中继动态值
def relayService = vars.get("TESTANY_OUTPUT_RELAY_SERVICE")
def relayData = JsonOutput.toJson([
    ORDER_ID: orderId,
    STATUS: status
])

def connection = new URL(relayService).openConnection()
connection.setRequestMethod("POST")
connection.setDoOutput(true)
connection.setRequestProperty("Content-Type", "application/json")
connection.outputStream.write(relayData.getBytes("UTF-8"))
connection.inputStream.text  // 执行请求
```

**输入用例** - 中继过来的值会自动作为 JMeter 变量可用：

```
# 在 HTTP Request 取样器中使用中继过来的值：
https://api.example.com/orders/${ORDER_ID}
```

### 附件示例

附带中继用例示例的测试用例：
[postman-with-relay-case.zip](../../../__attachments/226001345/postman-with-relay-case.zip?inst-v=07864bc4-715d-4f60-b8f8-0d2f7bf42d59)

×

## 本页术语

- [测试用例 (Test Case)](https://docs.testany.io/zh/docs/glossary.md#test-case)
- [执行 (Execution)](https://docs.testany.io/zh/docs/glossary.md#execution)
- [中继用例 (Relay Case)](https://docs.testany.io/zh/docs/glossary.md#relay-case)
- [环境 (Environment)](https://docs.testany.io/zh/docs/glossary.md#environment)
- [测试执行 (Test Execution)](https://docs.testany.io/zh/docs/glossary.md#test-execution)