总结学习过程--Java接口自动化初级框架迭代器Iterator解决接口测试效率问题

Posted 2021-09-05 makeGun

最近出现一个问题，接口入参字段过多（接口传入200多个字段），导致人工测试执行出现没有耐心一个一个测试字段，从而引发几个字段非空校验出了问题。

解决方案目的：引入迭代器，解决当接口字段参数过多的时候，接口字段参数测试容易被忽略的情况。

解决方案适应的接口入参格式：有如图所示的复杂度和层级的接口格式都可以直接使用，不限制参数个数。head测试环境一般是写死不校验，主要校验逻辑都是在body里面。

解决方案思路：
1.判断第一个层级是否是body。
2.选择增强for循环遍历还是选择for循环遍历，还是选择迭代器遍历。
3.第二层为list的下层只考虑了map，没考虑第三层为list和键值对的情况，主要是目前没碰到这样的接口设计。

彩蛋：
修改的值可以采用枚举的方式传入到执行的方法里面去，工作中是这样，分享的这个没写。

手动接口测试效率大幅度提升，每个接口测试传空如果需要1分钟，200个参数，测试一次为空的场景，需要1*200分钟，再测试字段为特殊字符，字段长度，字段格式，字段。。。。引用这个，实际只需要几分钟全部跑完所有场景。而且每次上线之前都可以全量回归。太香了

package test;


import org.testng.annotations.Test;
import java.text.SimpleDateFormat;
import java.util.*;

public class iteratorTestDemo {



    /**
     * 续要测试的已经组装好的报文参数
     * */
    public Map<String, Object> test_0001(){
       System.out.println("1");
       return new HashMap<>();
   }

   /**
    * 需要执行的测试方法---执行这个就行
    * */
    @Test
    public iteratorTestDemo() throws Exception {
        TestT(test_0001(),"修改后的value值"); //二审
    }

//    String value_T ="修改后的value值";       //需要测修改的值，字段为空，字段为特殊字符，字段长度，字段类型等等。

    /**
     *     注意：a.封装成公共方法，后面任意接口都可以直接调用，当做入参传入即可
     *          b.需要提前组装好的入参报文，并且初始化有正确的值
     * @param paramMap value_T
     * @throws Exception
     */
    public void TestT(Map<String, Object> paramMap,String value_T) throws Exception {     //组装map,提供遍历之后的map,每次修改一个入参

        //第一层
//        for (Map.Entry entry_1 : paramMap.entrySet()) { //遍历map里面的键值对   for-each增强for循环
        Iterator heaBodyMap_iterator = paramMap.entrySet().iterator();
        while (heaBodyMap_iterator.hasNext()) {
            Map.Entry heaBodyMap_entry = (Map.Entry) heaBodyMap_iterator.next();
            Object heaBodyMap_key = heaBodyMap_entry.getKey(); //获取到key,
            Object heaBodyMap_value = heaBodyMap_entry.getValue();//获取到value
            Object heaBodyMap_value2 = heaBodyMap_value;   //先保存初始化的value值，然后后面再赋值回去

            //第二层
            if (heaBodyMap_key == "head") {
                System.out.println("请求头部写死，不需要测试");
            }
            if (heaBodyMap_key == "body") {   //多层map--body
                if (heaBodyMap_value instanceof Map) {
                    Map<String, Object> heaBodyMap_value_map = (Map<String, Object>) heaBodyMap_value;  //强制转换成map
                    //不可用用for循环
                    Iterator bodyLevel_iterator = heaBodyMap_value_map.entrySet().iterator();
                    while (bodyLevel_iterator.hasNext()) {
                        Map.Entry bodyLevel_entry = (Map.Entry) bodyLevel_iterator.next();

                        Object bodyLevel_key = bodyLevel_entry.getKey(); //获取到key
                        Object bodyLevel_value = bodyLevel_entry.getValue();//获取到value
                        Object bodyLevel_value2 = bodyLevel_value;   //先保存初始化的value值，然后后面再赋值回去
                        heaBodyMap_value_map.put((String) bodyLevel_key, value_T);

                        //组装报文发起请求-断言结果放这里，然后断言之后再把报文初始化

                        //恢复最初的map
                        heaBodyMap_value_map.put((String) bodyLevel_key, bodyLevel_value2); //再恢复初始化的第二层map
                        paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//再恢复初始化的第一层map
//                        System.out.println("+++++++++++第一层恢复之后的paramMap:::::::  " + paramMap);

                        //第三层--是map
                        if (bodyLevel_value instanceof Map) {  //如果第二层是map,遍历map
                            Map<String, Object> bodyLevel_value_map = (Map<String, Object>) bodyLevel_value;
                            //循环第三层
                            Iterator threeLevelForMap_iterator = bodyLevel_value_map.entrySet().iterator();
                            while (threeLevelForMap_iterator.hasNext()) {
                                Map.Entry threeLevelForMap_entry = (Map.Entry) threeLevelForMap_iterator.next();
                                Object threeLevelForMap_key = threeLevelForMap_entry.getKey(); //获取到key,
                                Object threeLevelForMap_value = threeLevelForMap_entry.getValue();//获取到value
                                Object threeLevelForMap_value2 = threeLevelForMap_value;   //先保存初始化的value值，然后后面再赋值回去

                                //组装报文发起请求-断言结果放这里，然后断言之后再把报文初始化

                                //复原原始map
                                bodyLevel_value_map.put((String) threeLevelForMap_key, threeLevelForMap_value2);
                                paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//把重新组装第一层的map，将第二层的map修改完之后放入
//                                System.out.println("+++++++++++第一层恢复之后的paramMap:::::::  " + paramMap);

                                if (threeLevelForMap_value instanceof Map){     //第三层的value是map，第四层也是map
                                    Map<String, Object> threeLevelForMap_map = (Map<String, Object>) threeLevelForMap_value;
                                    //循环第四层--map
                                    Iterator fourLevelForMap_1_iterator = threeLevelForMap_map.entrySet().iterator();
                                    while (fourLevelForMap_1_iterator.hasNext()) {
                                        Map.Entry fourLevelForMap_1_entry = (Map.Entry) fourLevelForMap_1_iterator.next();//便利每一个键值对
                                        Object fourLevelForMap_1_key = fourLevelForMap_1_entry.getKey();
                                        Object fourLevelForMap_1_value = fourLevelForMap_1_entry.getValue();
                                        Object fourLevelForMap_1_value2 = fourLevelForMap_1_value;

                                        threeLevelForMap_map.put((String) fourLevelForMap_1_key,value_T);
                                        paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//把重新组装第一层的map，将第二层的map修改完之后放入

                                        //组装报文发起请求-断言结果放这里，然后断言之后再把报文初始化


                                        //复原原始map
                                        threeLevelForMap_map.put((String) fourLevelForMap_1_key,fourLevelForMap_1_value2);
                                        paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//把重新组装第一层的map，将第二层的map修改完之后放入
//                                        System.out.println("+++++++++++第一层恢复之后的paramMap:::::::  " + paramMap);

                                    }
                                }
                                if (threeLevelForMap_value instanceof List){     //第三层的value是map，第四层是list
                                    List<Map<String,Object>> threeLevelForMap_list = (List)threeLevelForMap_value; //
                                    //迭代
                                    Iterator<Map<String,Object>> fourLevelForMap_2_iterator = threeLevelForMap_list.iterator();
                                    while (fourLevelForMap_2_iterator.hasNext()){
                                        Map<String,Object> fiveLevelForMap_2_map = fourLevelForMap_2_iterator.next();//把便利的list，转化成map
                                        Iterator fiveLevelForMap_2_iterator = fiveLevelForMap_2_map.entrySet().iterator();//便利list里面的每一个键值对
                                        while (fiveLevelForMap_2_iterator.hasNext()){
                                            Map.Entry fiveLevelForMap_2_entry = (Map.Entry) fiveLevelForMap_2_iterator.next();//获取键值对
                                            Object fiveLevelForMap_2_key = fiveLevelForMap_2_entry.getKey();
                                            Object fiveLevelForMap_2_value = fiveLevelForMap_2_entry.getValue();
                                            Object fiveLevelForMap_2_value2 = fiveLevelForMap_2_value;

                                            fiveLevelForMap_2_map.put((String) fiveLevelForMap_2_key,value_T);
                                            paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//把重新组装第一层的map，将第二层的map修改完之后放入

                                            //组装报文发起请求-断言结果放这里，然后断言之后再把报文初始化

                                            //复原原始map
                                            fiveLevelForMap_2_map.put((String) fiveLevelForMap_2_key,fiveLevelForMap_2_value2);
                                            paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//
//                                        System.out.println("+++++++++++第一层恢复之后的paramMap:::::::  " + paramMap);
                                        }
                                    }
                                }
                            }
                        }
                        //第三层--是list
                        if (bodyLevel_value instanceof List) {
                            List<Map<String, Object>> bodyLevel_value_list = (List) bodyLevel_value;//如果第三层是list,遍历list

                            //迭代
                            Iterator<Map<String, Object>> threeLevelForList_iterator = bodyLevel_value_list.iterator();
                            while (threeLevelForList_iterator.hasNext()) {
                                Map<String, Object> threeLevelForList_map = threeLevelForList_iterator.next();//把遍历的list内部，如果还有一层，就转换成map

                                //第四层--是map---
                                //迭代
                                Iterator fourLevelForMap_iterator = threeLevelForList_map.entrySet().iterator();
                                while (fourLevelForMap_iterator.hasNext()) {
                                    Map.Entry fourLevelForMap_entry = (Map.Entry) fourLevelForMap_iterator.next();

                                    Object fourLevelForMap_key = fourLevelForMap_entry.getKey(); //获取到key,
                                    Object fourLevelForMap_value = fourLevelForMap_entry.getValue();//获取到value
                                    Object fourLevelForMap_value2 = fourLevelForMap_value;   //先保存初始化的value值，然后后面再赋值回去

                                    threeLevelForList_map.put((String) fourLevelForMap_key, value_T);
                                    paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//再恢复初始化的第一层map

                                    //组装报文发起请求-断言结果放这里，然后断言之后再把报文初始化

                                    //复原原始map
                                    threeLevelForList_map.put((String) fourLevelForMap_key, fourLevelForMap_value2);//再恢复初始化的第四层map-----没有再更新第三层的list列表。因为list里面是引用的map，引用的引用的引用的，重要的事情说三遍
                                    paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//再恢复初始化的第一层map
//                                    System.out.println("+++++++++++第一层恢复之后的paramMap:::::::  " + paramMap);


                                    //第五层
                                    if (fourLevelForMap_value instanceof Map) {
                                        //第五层map---
                                        Map<String, Object> fiveLevelForMap_map = (Map) fourLevelForMap_value;//把第四层的map-value赋值给第五层map
                                        //迭代
                                        Iterator fiveLevelForMap_iterator = fiveLevelForMap_map.entrySet().iterator();
                                        while (fiveLevelForMap_iterator.hasNext()) {
                                            Map.Entry fiveLevelForMap_entry = (Map.Entry) fiveLevelForMap_iterator.next();
                                            Object fiveLevelForMap_key = fiveLevelForMap_entry.getKey(); //获取到key,  fiveLevelForMap_key
                                            Object fiveLevelForMap_value = fiveLevelForMap_entry.getValue();//获取到value
                                            Object fiveLevelForMap_value2 = fiveLevelForMap_value;   //先保存初始化的value值，然后后面再赋值回去

                                            fiveLevelForMap_map.put((String) fiveLevelForMap_key, value_T);
                                            paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//再恢复初始化的第一层map

                                            //组装报文发起请求-断言结果放这里，然后断言之后再把报文初始化

                                            //复原原始map
                                            fiveLevelForMap_map.put((String) fiveLevelForMap_key, fiveLevelForMap_value2);
                                            paramMap.put((String) heaBodyMap_key, heaBodyMap_value_map);//再恢复初始化的第一层map
//                                            System.out.println("+++++++++++第一层恢复之后的paramMap:::::::  " + paramMap);


                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

        }
    }
}