接口测试平台：Http请求的简单执行(旧版已废弃)

柔情只为你懂 2023-05-30 15:55 182阅读 0赞

本文是上文《接口测试平台：接口内容的设计》的具体执行部分。
涉及jar包如下：

  • mybatis-spring-boot-starter 1.3.0
  • lombok 1.16.16
  • okhttp 3.10.0
  • json-path 2.4.0

大概逻辑如下：

  1. 前端选择执行

    • 可以在列表页进行多选，执行
      在这里插入图片描述
    • 单接口的调试执行
      在这里插入图片描述

  2. 后端在数据库逐读取所有case的具体信息，逐条执行case。

  3. 将结果进行储存和反馈给前端。
  4. 前端对数据进行处理，如果是列表的批量执行，只会刷新case的最后执行状态，如果是单条case的调试执行，会渲染最新的result(接口返回结果)

具体实现思路如下：

1.前端选择执行

在这里插入图片描述
前端在点击执行时，会进行一次请求，像后端传一个id的list(id即为case在数据库中的存储id)

2.后端在数据库逐读取所有case的具体信息，逐条执行case。

  • service层

    @Override
    public ResponseVo excuteRequest(Integer[] ids) { 

    1. ResponseVo responseVo = new ResponseVo();
    3. // 获取当前需执行的所有case
    4. List<TestCase> caseList = apiTestCaseMapper.selectTestCaseListByIds(ids);
    5. // 遍历caseList，进行http请求
    6. for (TestCase testCase:caseList){ 
    7.     // 保存响应结果
    8.     String result = "";
    9.     Response response = ApiTestUtils.doRequest(testCase, GLOBAL_COLLECTION_ID);
    10.     try { 
    11.         result = response.body().string();
    12.     } catch (IOException e) { 
    13.         e.printStackTrace();
    14.     }
    16.     // 保存变量， 调试执行时可以忽略此方法
    17.     ApiTestUtils.saveVariable(result, testCase, GLOBAL_COLLECTION_ID);
    19.     // 判断是否通过了所有校验条件
    20.     if (ApiTestUtils.verifyResult(result, testCase, GLOBAL_COLLECTION_ID)){ 
    21.         testCase.setStatus(Boolean.TRUE);
    22.     } else { 
    23.         testCase.setStatus(Boolean.FALSE);
    24.     }
    25.     testCase.setResult(result);
    27.  // 更新数据库保存的信息
    28.     setJsonValue(testCase);
    29.     apiTestCaseMapper.updateCase(testCase);
    31.     // 将执行后的结果返回给前端
    32.     responseVo.setIsSuccess(Boolean.TRUE);
    33.     responseVo.setResult(testCase);
    35. }
    37. return responseVo;

    }

  • mapper.xml

  • ApiTestUtils
    这里有一个collectionId(集合id)，用于后面的集合执行，此处全部默认为0即可。

    @Slf4j
    public class ApiTestUtils { 

  1.     /** * @param testCase 传入完整的case数据 * @param collectionId 集合id，如果传入0则表示为接口调试执行 * @return Response返回结果 */
  2.     public static Response doRequest(TestCase testCase, Integer collectionId){ 
  4.         String url = "http://" + getVariable(testCase.getApiUrl(), collectionId);
  6.         if (null != testCase.getApiPort()){ 
  7.             url += ":" + String.valueOf(testCase.getApiPort());
  8.         }
  9.         if (!testCase.getApiPath().isEmpty()){ 
  10.             url += getVariable(testCase.getApiPath(),collectionId);
  11.         }
  13.         // 请求方式: POST/GET
  14.         String apiMethod = testCase.getApiMethod();
  16.         // 请求类型：1.json 2.url form
  17.         int bodyType = testCase.getBodyType();
  18.         String body = "";
  20.         // 连接超时、写入超时、读取超时，均设置为30s，这里不做展开讨论，有兴趣的同学可以搜一下okhttp的用法
  21.         OkHttpClient client = new OkHttpClient.Builder()
  22.                 .connectTimeout(Config.connectTimeout, TimeUnit.SECONDS)
  23.                 .writeTimeout(Config.writeTimeout,TimeUnit.SECONDS)
  24.                 .readTimeout(Config.readTimeout, TimeUnit.SECONDS)
  25.                 .build();
  27.         Request.Builder builder = new Request.Builder();
  29.         // 设置header
  30.         List<RequestHeaders> headersList = JSON.parseArray(testCase.getHeaderValue(), RequestHeaders.class);
  31.         for (RequestHeaders headers:headersList){ 
  32.             builder.header(headers.getHeaderKey(), getVariable(headers.getHeaderValue(), collectionId));
  34.         }
  36.         // 设置body、mediaType
  37.         String mediaTypeValue = "";
  38.         if (bodyType == 1){ 
  39.             mediaTypeValue = "application/json;charset=UTF-8";
  40.             body = testCase.getJsonValue();
  41.         } else if (bodyType == 2){ 
  42.             mediaTypeValue = "application/x-www-form-urlencoded;charset=utf-8";
  43.             //TODO urlfrom的body处理
  44.         }
  46.         // 如果前端没有传body，讲body设置为空string
  47.         if (body == null){ 
  48.             body = "";
  49.         } else { 
  50.             body = getVariable(body, collectionId);
  51.         }
  53.         Request request = null;
  54.         if (apiMethod.equals("POST")){ 
  55.             RequestBody requestBody =RequestBody.create(MediaType.parse(mediaTypeValue), body);
  56.             request = builder.url(url).post(requestBody).build();
  57.         } else if(apiMethod.equals("GET")){ 
  58.             request = builder.url(url).get().build();
  59.         }
  61.         Response response = null;
  62.         try { 
  63.             response = client.newCall(request).execute();
  64.         } catch (IOException e) { 
  65.             e.printStackTrace();
  66.         }
  68.         return response;
  70.     }
  72.     /** * * @param string 变量名 * @param collectionId 集合id，：为0时只读全局变量，非0时读了全局变量再读集合内变量 * @return 变量值 */
  73.     private static String getVariable(String string,Integer collectionId){ 
  75.         HashMap<String,String> variableMap = ApiTestConfig.globalVariableMap;
  78.         // 如果为集合执行，会再次获取集合内变量
  79.         if (collectionId != 0){ 
  80.             variableMap.putAll(ApiTestConfig.collectionVariableMap);
  81.         }
  83.         // 查询string中是否有${KEY}格式的数据，如果有则将其替换为VALUE
  84.         if (!string.isEmpty()){ 
  85.             String reg = "\\$\\{.*?}";
  86.             Pattern p = Pattern.compile(reg);
  87.             Matcher m = p.matcher(string);
  88.             // 遍历替换所有的变量
  89.             while (m.find()){ 
  90.                 String key = m.group().replace("${","").replace("}","");
  91.                 if (variableMap.containsKey(key)){ 
  92.                     string = string.replace(m.group(),variableMap.get(key));
  93.                 }
  94.             }
  95.             return string;
  96.         } else { 
  97.             return "";
  98.         }
  100.     }
  102.     /** 保存变量 */
  103.     public static void saveVariable(String result, TestCase testCase, Integer collectionId) { 
  104.         // 调试执行时可以忽略此方法
  106.     }
  108.     /** * 遍历ExpectedList，只要有校验不通过的条件测抛FALSE */
  109.     public static Boolean verifyResult(String responseResult, TestCase testCase, Integer collectionId){ 
  111.         List<Expected> ExpectedList = JSON.parseArray(testCase.getExpectedListValue(), Expected.class);
  112.         if (ExpectedList.size() == 0){ 
  113.             if (collectionId != 0){ 
  114.                 Assert.assertTrue(Boolean.TRUE);
  115.             }
  116.             return Boolean.TRUE;
  117.         }
  118.         Boolean bool = Boolean.FALSE;
  120.         for (Expected exp:ExpectedList){ 
  121.             // 提取方式：1.jsonPath 2.正则表达式
  122.             int extractMethod = exp.getExtractMethod();
  123.             String extractRule = exp.getExtractRule();
  124.             // 校验方式：1.equasl 2.contains
  125.             int compareType = exp.getCompareType();
  126.             String expectedValue = exp.getExpectedValue();
  128.             // 实际获取结果
  129.             String actualRes = "";
  130.             if (extractMethod == 1){ 
  131.                 try { 
  132.                     // 这里取到的值如果是bool时，强转会抛错，所以需要用object接一下，再转String
  133.                     Object o = JsonPath.read(responseResult, extractRule);
  134.                     actualRes = String.valueOf(o);
  135.                 } catch (Exception e){ 
  136.                     if (collectionId != 0){ 
  137.                         Reporter.log("接口返回结果为：" + responseResult);
  138.                         Assert.fail("预期值取值失败");
  139.                     }
  141.                     return Boolean.FALSE;
  142.                 }
  143.             } else if (extractMethod == 2){ 
  144.                 try { 
  145.                     Pattern p = Pattern.compile(extractRule);
  146.                     Matcher m = p.matcher(responseResult);
  147.                     if (m.find()){ 
  148.                         actualRes = m.group();
  149.                     }
  150.                 } catch (Exception e){ 
  151.                     if (collectionId != 0){ 
  152.                         Assert.fail("预期值取值异常");
  153.                     }
  154.                     return Boolean.FALSE;
  155.                 }
  157.             }
  159.             // 对比预期结果
  160.             if (compareType == 1){ 
  161.                 if (collectionId != 0){ 
  162.                     Assert.assertEquals(actualRes, expectedValue);
  163.                 }
  164.                 if (actualRes.equals(expectedValue)){ 
  165.                     bool = Boolean.TRUE;
  166.                 }
  167.             } else if (compareType == 2){ 
  168.                 if (actualRes.contains(expectedValue)){ 
  169.                     bool = Boolean.TRUE;
  170.                 } else { 
  171.                     if (collectionId != 0){ 
  172.                         Assert.fail("预期值:" + expectedValue + "不存在与期望值" + actualRes + "中");
  173.                     }
  174.                 }
  175.             }
  177.         }
  179.         return bool;
  180.     }
  181. }
3.将结果进行储存和反馈给前端。

service层这四行代码，进行了处理

  1. // 自己封装的方法，给header，formValue,variableList,expectedList等字段赋值
  2.  setJsonValue(testCase);
  3.  // 更新数据库保存的信息
  4.  apiTestCaseMapper.updateCase(testCase);
  6.  // 将执行后的结果返回给前端
  7.  responseVo.setIsSuccess(Boolean.TRUE);
  8.  responseVo.setResult(testCase);

这里只返回了最后一条case的信息

4.前端对数据进行处理

在列表进行批量执行时，拿到后端返回的isSuccess=true时，则执行刷新列表，获取最新的每个接口的执行状态。
在进行单接口调试时，从result中的testCase信息获取接口响应结果及校验结果，重新渲染页面。

上述过程，将前端传数据然后读sql的过程转变为xml驱动testng进行执行，可以替换成一个接口测试框架。
下篇文章会讲解在多接口测试中，如何控制接口与接口间的数据依赖。有疑问的小伙伴欢迎在文章下方留言，我会根据问题不断优化文章内容！

发表评论

表情：
评论列表 （有 0 条评论，182人围观）

还没有评论，来说两句吧...

相关阅读