
# 测试检查点
在测试步骤请求中可以设置请求结果的检查点，方便用户检测当前接口的返回值，验证测试步骤是否得到预期结果。
#### 设置建议
- 推荐用户设置检查点。针对接口类请求，请提供判断响应码的检查点。
- 当检查点设置为空，不论接口的响应码是什么，都会判断结果为成功。
 
#### 检查点说明
测试检查点即请求结果的断言，通过检查接口响应是否符合预期，判定系统是否满足预期。
在接口自动化用例中，测试步骤的"检查点"页签中可以定义测试检查点。
![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002483544010.png)
检查点内容包括属性、比较符和目标值定义。
| 字段     | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|:---|:---|
| 重试次数   | 如果检查点失败，重新执行该测试步骤的次数，重试次数范围：0\~5的正整数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 重试间隔   | 如果检查点失败，每次重试的间隔时长，单位为ms，重试间隔范围：0\~10,000的正整数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 来源     | 被检测字段的来源，如响应体（JSON）、响应头、响应码、变量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 属性     | - 若来源是响应码，属性可为空。详细介绍请参见[响应码检查]。  - 若来源是响应头，属性为响应头中字段的名称。详细介绍请参见[响应头检查]。  - 若来源是响应体（JSON），属性有两种填写方法： - 普通提取表达式（非"$"开头），例如"item.name"。 取字段中的值，支持嵌套取值。详细介绍请参见[响应体（JSON）检查]。 从响应体中提取数组时，下标可以是数字，也可以是"key:value"表达式，详细介绍请参见[示例：根据给定的key:value从响应体中获取字符串]。   - JsonPath表达式("$."或"$\["开头)，例如"$.store.book\[0\].title"。 详细介绍请参见[示例：根据JsonPath从响应体中获取数据]。     - 若来源是变量，属性为全局变量，局部变量，响应提取后的变量。详细介绍请参见[变量检查]。   |
| 高级提取类型 | 可选项，使用高级提取类型，辅助提取检查点信息，若选择不涉及，则视为不使用额外的方式匹配。 目前有两种方式： - [字符串提取](https://support.huaweicloud.com/usermanual-testman/cloudtest_01_0014.html)，也就是字符串的截取。  - [正则表达式](https://support.huaweicloud.com/usermanual-testman/cloudtest_01_0014.html)，即使用正则方式对来源字符串进行过滤。   高级提取类型优先使用字符串提取功能，若不能满足需求可考虑使用正则表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 类型值    | 高级提取类型中所需的参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| 比较符    | 支持数字、字符串、JSON对象比较、类型比较等多种比较符，详细介绍请参见[比较符说明]。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| 目标值    | 检查点期望值。目标值支持使用内置参数，请参考[内置参数](https://support.huaweicloud.com/usermanual-testman/cloudtest_01_0016.html#cloudtest_01_0016__section81678094617)了解如何使用内置参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
   
例如，检查响应体（JSON格式）中"item.name"字段的第零位（首位）到第四位之间是不是petty，参数配置如下：
| 字段     | 值         |
|:---|:---|
| 来源     | 响应体（JSON） |
| 属性     | item.name |
| 高级提取类型 | 字符串提取     |
| 类型值    | 0、5       |
| 比较符    | 等于(字符串)   |
| 目标值    | petty     |
   
 #### 比较符说明
支持以下比较类型：
| 比较类型     | 比较符                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 是否需要填入值 | 举例                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|:---|
| 数字比较     | - 等于(数字)  - 不等于(数字)  - 大于等于(数字)  - 小于等于(数字)  - 大于(数字)  - 小于(数字)   | 是       | - 响应码 等于 200  - 响应码 不等于 200  - 响应码 大于等于 200  - 响应码 小于等于 200  - 响应码 大于 200  - 响应码 小于 200   |
| 字符串比较    | - 等于(字符串、区分大小写)  - 不等于(字符串、区分大小写)  - 等于(字符串、不区分大小写)  - 包含(字符串)  - 不包含(字符串)                                                                    | 是       | - 响应体中的属性param1 等于 test  - 响应体中的属性param2 不等于 test  - 响应体中的属性param3 等于 TEST  - 响应体中的属性param4包含 tri  - 响应体中的属性param5不包含 tri                                  |
| 正则比较     | 正则表达式                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 是       | - 响应体中的属性param1 正则表达式 \^\[A-Za-z0-9\]{1,32}$                                                                                                                                                                                                                                                                                                                                                                                                          |
| 通用比较     | - 是空（该字段是否为空，即是否没有该字段）  - 不是空（该字段是否不为空，即是否有该字段）                                                                                                                                                                                                                                                                                                         | 否       | - 响应体中的属性param1 是空  - 响应体中的属性param2 不是空                                                                                                                                                                                                                                                                                                                                    |
| Json数组比较 | - JSON数组为空数组（json数组是否为空数组）  - JSON数组为非空数组（json数组是否为非空数组）                                                                                                                                                                                                                                                                                             | 否       | - 响应体中的属性param1 JSON数组为空数组  - 响应体中的属性param2 JSON数组为非空数组                                                                                                                                                                                                                                                                                                                         |
| Json数组比较 | JSON数组的大小（json数组的大小是否为...）                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 是       | - 响应体中的属性param1 JSON数组的大小                                                                                                                                                                                                                                                                                                                                                                                                                             |
| 类型比较     | - 是JSON类型（是否是json对象类型）  - 是JSON数组类型（是否是json数组类型）                                                                                                                                                                                                                                                                                                              | 否       | - 响应体中的属性param1 是JSON类型  - 响应体中的属性param2 是JSON数组类型                                                                                                                                                                                                                                                                                                                            |
| Json对象比较 | JSON等于（json等于）                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 是       | - 响应体中的属性param1 JSON等于 {"name":"zhangsan"}                                                                                                                                                                                                                                                                                                                                                                                                              |
   
 #### 响应码检查
将响应码与目标值进行比较，例如：检查响应码是否等于"200"。
![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002515584001.png)
 #### 响应头检查
响应头中字段的值和目标值进行比较，例如：检查响应头中"content-type"的值是否等于"text/plain;charset=UTF-8"。
![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002483384052.png)
 #### 响应体（JSON）检查
1. 检查响应体（JSON）中对象字段的值。例如： 响应体结构如下：
   ![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002515583997.png)
   检查响应体对象中字段名为"status"的值，检查点配置如下：
   ![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002515583999.png)
   
2. 检查响应体（JSON）中某个数组的对象的字段值（数组条件采用下标确定对象，下标从0开始）。例如： 响应体结构如下：
   ![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002483544012.png)
   检查响应体"result"数组的第1个元素对象字段名为"userId"的值，检查点配置如下：
   ![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002515584005.png)
   
3. 检查响应体（JSON）中某个数组的对象的字段值（数组条件采用模糊匹配功能确定对象）。例如： 响应体结构如下：
   ![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002515584003.png)
   a.检查响应体"result"数组下"name"是"啤酒"的所有对象取第1个之后获取id的值，检查点配置如下：
   ![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002483544008.png)
   ![](https://support.huaweicloud.com/usermanual-apiarts/public_sys-resources/note_3.0-zh-cn.png)
   当获取的数组下的对象只有一个，"\[0\]"可以省略，示例中的表达式可以写为"result\[name==啤酒\].id"。
   b.检查响应体"result"数组下"name"是"啤酒"的并且"obj"对象下属性"a"的值是"2"的对象的id值，检查点配置如下：
   ![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002483544014.png)
   
 
 #### 变量检查
检查比较全局变量，局部变量，响应提取后的变量值和目标值。例如：
- 检查全局变量"hostIp"的值是否等于"127.0.0.1"。
- 检查局部变量"local"的值是否等于"text"。
- 检查响应提取后的变量"name"的值是否等于"白酒"。
![](https://support.huaweicloud.com/usermanual-apiarts/zh-cn_image_0000002515664009.png)
 #### 示例：根据给定的key:value从响应体中获取字符串
检查体的"属性"字段，可输入下标为"key:value"格式的数组，用以实现根据给定的"key:value"从响应体中获取满足该条件的json串。
"key:value"之间支持以下连接符：
| 连接符 | 说明                | 举例                                                  |
|:---|:---|:---|
| ==  | 等于（字符串、数值），支持汉字。  | name==张三 age==20 |
| !=  | 不等于（字符串、数值），支持汉字。 | name!=张三 age!=20 |
| \>  | 大于（数值）            | age\>20                                             |
| \>= | 大于等于（数值）          | age\>=20                                            |
| \<  | 小于（数值）            | age\<20                                             |
| \<= | 小于等于（数值）          | age\<=20                                            |
   
数组下标支持以"\&\&"连接的多组"key:value"条件，表示提取的JSON串需要同时满足所有的"key:value"条件。例如：student\[age\>20\&\&gender=女\]，表示提取条件为年龄大于20岁且性别为女。
数组的搜索条件中支持嵌套数组，在此情况下子嵌套条件中的对象必须全部满足条件，才能使得子条件成立。
![](https://support.huaweicloud.com/usermanual-apiarts/public_sys-resources/note_3.0-zh-cn.png)
- 若value值为空对象，则需要使用$null，即key==$null。
- 若value值是null串（"null"），则使用null，即key==null。
- 若value值是空串（""），则可以不写，即key==。
 
以下面的响应体（JSON格式）为例：
```
{
  "status": "success",
  "result": [
    {
      "name": "啤酒",
      "数量": "20",
      "地址": "A3库房10号货架",
      "obj": {
        "a": 1,
        "b": "test",
        "c": "测试"
      },
      "array": [
        {
          "id": 1,
          "name": "aaa"
        },
        {
          "id": 2,
          "name": "bbb"
        }
      ]
    },
    {
      "name": "啤酒",
      "数量": "10",
      "地址": "A3库房10号货架",
      "obj": {
        "a": 1,
        "b": "test",
        "c": "测试"
      },
      "array": [
        {
          "id": 1,
          "name": "aaa"
        },
        {
          "id": 2,
          "name": "bbb"
        }
      ]
    },
    {
      "name": "白酒",
      "数量": "20",
      "地址": "A3库房10号货架",
      "obj": {
        "a": 1,
        "b": "test",
        "c": "测试"
      },
      "array": [
        {
          "id": 1,
          "name": "aaa"
        },
        {
          "id": 2,
          "name": "bbb"
        }
      ]
    },
    {
      "name": "白酒",
      "数量": "30",
      "地址": "A3库房10号货架",
      "obj": {
        "a": 1,
        "b": "test",
        "c": "测试"
      },
      "array": [
        {
          "id": 3,
          "name": "aaa"
        },
        {
          "id": 4,
          "name": "bbb"
        }
      ]
    },
    {
      "name": null,
      "数量": "10",
      "地址": "A3库房10号货架",
      "obj": {
        "a": 2,
        "b": "test",
        "c": "测试"
      },
      "array": [
        {
          "id": 5,
          "name": "aaa"
        },
        {
          "id": 6,
          "name": "bbb"
        }
      ]
    },
    {
      "name": "",
      "数量": "10",
      "地址": "A3库房10号货架",
      "obj": {
        "a": 2,
        "b": "test",
        "c": "测试"
      },
      "array": [
        {
          "id": 5,
          "name": "aaa"
        },
        {
          "id": 6,
          "name": "bbb"
        }
      ]
    }
  ],
  "condition": [
    {
      "name": "啤酒",
      "数量": "120",
      "地址": "A1库房15号货架"
    }
  ],
  "reason": null
}
```
从响应体中获取数据与对应的表达式如下表所示：
| 提取条件                                   | 表达式                                      |
|:---|:---|
| 获取result数组中name是白酒的数据                  | result\[name==白酒\]                       |
| 获取result数组中name不是啤酒且数量大于20的数据          | result\[name!=啤酒\&\&数量\>20\]             |
| 获取result数组中name是空对象且array数组中id小于等于2的数据 | result\[name==$null\&\&array\[id\<=2\]\] |
| 获取result数组中name是null串且obj对象的属性a等于2的数据  | result\[name==null\&\&obj.a==2\]         |
| 获取result数组中name是空串（""）的数据              | result\[name==\]                         |
   
若需要检查（JSON格式）name是白酒、且数量大于20的数据是不是"\[{"name": "白酒","数量": "30","地址": "A3库房10号货架","obj": {"a": 1,"b": "test","c": "测试"},"array": \[{"id": 3,"name": "aaa"},{"id": 4,"name": "bbb"}\]}\]"，则检查点各字段的配置可参考下表：
| 字段  | 值                                                                                                                                                  |
|:---|:---|
| 来源  | 响应体（JSON）                                                                                                                                          |
| 属性  | result\[name!=啤酒\&\&数量\>20\]                                                                                                                       |
| 比较符 | 等于(字符串)                                                                                                                                            |
| 目标值 | \[{"name": "白酒","数量": "30","地址": "A3库房10号货架","obj": {"a": 1,"b": "test","c": "测试"},"array": \[{"id": 3,"name": "aaa"},{"id": 4,"name": "bbb"}\]}\] |
   
 #### 示例：根据JsonPath从响应体中获取数据
JsonPath详情可参见[官网](https://github.com/json-path/JsonPath)。
以下面的响应体（JSON格式）为例：
```
{
    "store": {
        "book": [
            {
                "category": "reference",
                "author": "Nigel Rees",
                "title": "Sayings of the Century",
                "price": 8.95
            },
            {
                "category": "fiction",
                "author": "Evelyn Waugh",
                "title": "Sword of Honour",
                "price": 12.99
            },
            {
                "category": "fiction",
                "author": "Herman Melville",
                "title": "Moby Dick",
                "isbn": "0-553-21311-3",
                "price": 8.99
            },
            {
                "category": "fiction",
                "author": "J. R. R. Tolkien",
                "title": "The Lord of the Rings",
                "isbn": "0-395-19395-8",
                "price": 22.99
            }
        ],
        "bicycle": {
            "color": "red",
            "price": 19.95
        }
    },
    "expensive": 10
}
```
JsonPath表达式可以使用点符号或者括号符号，例如：
- $.store.book\[0\].title
- $\['store'\]\['book'\]\[0\]\['title'\]
JsonPath表达式与其对应的含义如下表所示：
| JsonPath表达式                                | 含义描述                         |
|:---|:---|
| $.store.book\[\*\].author                  | 所有书籍的作者                      |
| $..author                                  | 所有作者                         |
| $.store.\*                                 | 所有的东西，包括书籍和自行车               |
| $.store..price                             | 所有东西的价格                      |
| $..book\[2\]                               | 第三本书                         |
| $..book\[-2\]                              | 倒数第二本书                       |
| $..book\[0,1\]                             | 前两本书                         |
| $..book\[:2\]                              | 从索引 0（包括）到索引 2（不包括）的所有书籍     |
| $..book\[1:2\]                             | 从索引 1（包括）到索引 2（不包括）的所有书籍     |
| $..book\[-2:\]                             | 最后两本书                        |
| $..book\[2:\]                              | 从末尾开始的两本书                    |
| $..book\[?(@.isbn)\]                       | 所有有isbn的书                    |
| $.store.book\[?(@.price \< 10)\]           | 商店里所有价格小于10的书                |
| $..book\[?(@.price \<= $\['expensive'\])\] | 商店里所有不"贵"的书                  |
| $..book\[?(@.author =\~ /.\*REES/i)\]      | 所有作者匹配正则表达式.\*REES（忽略大小写）的书籍 |
| $..\*                                      | 所有内容                         |
   
![](https://support.huaweicloud.com/usermanual-apiarts/public_sys-resources/note_3.0-zh-cn.png)
若使用length函数或者size函数，则多次调用时不要使用深度扫描（即".."符号），例如"$..book.length()"返回书的数量，此时需要确定路径，改为"$.store.book.length()"。
