数据工厂-生成接口通用用例

分手后的思念是犯贱 2023-10-15 16:12 98阅读 0赞

### ![cfee5884c6f0407fa5e0c5b24c901fcf.png][] ###

### 一、背景介绍 ###

> 有哪些用例是可以通用且固定的？

*  针对之前提到的**接口用例设计思路**，拆分为**三个切入点**：

![5f252da5fc654b318e0302afb5455b8f.png][]

*  举个例子：

{
        "field": "value"
    }

*  针对这个字符串类型的入参我们可以设计：
    
     *  当前数据类型入参（例如：空串，空格字符，特殊字符，字符个数上下限等。）
     *  非当前数据类型入参（例如：整型、浮点类型、布尔类型等。）
     *  特殊值（0、null值等。）

### 二、前置准备 ###

> 运行数据工厂的前提条件。

*  `java` 开发及运行环境。
 *  `maven` 构建工具。
 *  使用到的依赖：

<dependencies>
            
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.76</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi</artifactId>
                <version>4.1.2</version>
            </dependency>
            <dependency>
                <groupId>org.apache.poi</groupId>
                <artifactId>poi-ooxml</artifactId>
                <version>4.1.2</version>
            </dependency>
        </dependencies>

### 三、设计思路 ###

> 工具类之间是如何交互的。

*  **包层级目录**：

*  **脚本执行的主流程**：

### ![6cbdda004e7b4376b03c8c9ebffc1e31.png][] ###

### 四、代码具体实现 ###

*  **Launcher**（启动类）：

package com.example.myproject.boot;
    
    import com.alibaba.fastjson.JSONObject;
    import com.example.myproject.core.DataFactory;
    
    /**
     * 执行入口。
     *
     * @author Jan
     * @date 2023/08
     */
    public class Launcher {
        public static void main(String[] args) throws Exception {
            // 这里支持传入自定义的用例拓展字段 -> new JSONObject() 。
            DataFactory.runAndCreateTestCases(null);
        }
    }

*  **DataFactory**（核心类）：

package com.example.myproject.core;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.JSONPath;
    import com.example.myproject.pojo.WriteBackData;
    import com.example.myproject.util.*;
    
    import java.lang.reflect.Array;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.*;
    
    /**
     * 数据工厂。
     *
     * @author Jan
     * @date 2023/08
     */
    public class DataFactory {
    
        private DataFactory() {
    
        }
    
        /**
         * 回写数据的集合。
         */
        private static final List<WriteBackData> WRITE_BACK_DATA = new ArrayList<>();
    
        /**
         * 运行和创建测试用例。
         *
         * @param ext ext 额外的拓展参数。
         * @throws Exception 异常。
         */
        public static void runAndCreateTestCases(JSONObject ext) throws Exception {
            // 获取请求示例。
            String jsonStr = FileUtils.readSampleRequest();
            // 解析json的字段数据类型及jsonPath。
            Set<String> jsonPaths = JsonPathParser.getJsonPaths(jsonStr);
            for (String jsonPath : jsonPaths) {
                // 字段数据类型。
                String filedDataType = JSONPath.read(jsonStr, jsonPath).getClass().getSimpleName();
    
                // 跳过复合类型。
                if ("JSONObject".equals(filedDataType)) {
                    continue;
                }
    
                // 字段名。
                String[] split = jsonPath.split("\\.");
                String filedName = split[split.length - 1];
    
                // 通过反射生成对应数据类型的测试用例。
                List<Object> caseValues = DataFactory.getObjectArrayFromReflectType(CaseUtils.class, filedDataType);
                Map<String, String> caseNameAndRequestValueMap = new HashMap<>();
    
                for (Object value : caseValues) {
                    String caseName = CaseUtils.createSpecifyCaseNameByCaseValue(filedName, value);
                    // 修改字段值。
                    JSONObject jsonObject = JsonUtils.checkAndSetJsonPathValue(jsonStr, jsonPath, value);
                    caseNameAndRequestValueMap.put(caseName, jsonObject.toJSONString());
                }
    
                for (Map.Entry<String, String> entry : caseNameAndRequestValueMap.entrySet()) {
                    String caseName = entry.getKey();
                    String requestValue = "";
                    if (null != ext) {
                        // 额外参数。
                        ext.put("title", caseName);
                        ext.put("case", JSON.parseObject(entry.getValue()));
                        requestValue = ext.toJSONString();
                    } else {
                        requestValue = entry.getValue();
                    }
                    WRITE_BACK_DATA.add(new WriteBackData(caseName, requestValue));
                }
            }
            System.out.println("组装完成的用例数为 = " + WRITE_BACK_DATA.size());
            //开始回写
            ExcelUtils.initFileAndWriteDataToExcel(WRITE_BACK_DATA);
        }
    
        /**
         * 通过反射获取用例集合。
         *
         * @param clazz clazz
         * @param type  类型
         * @return {@link List}<{@link Object}>
         * @throws NoSuchMethodException     没有这样方法异常。
         * @throws InvocationTargetException 调用目标异常。
         * @throws InstantiationException    实例化异常。
         * @throws IllegalAccessException    非法访问异常。
         */
        private static List<Object> getObjectArrayFromReflectType(Class<? extends CaseUtils> clazz, String type) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
            Object obj = clazz.getConstructor().newInstance();
            String methodName = "get" + type + "TypeCases";
            Method method = clazz.getDeclaredMethod(methodName);
            Object invoke = method.invoke(obj);
            int length = Array.getLength(invoke);
            List<Object> caseValues = new ArrayList<>();
            for (int i = 0; i < length; i++) {
                caseValues.add(Array.get(invoke, i));
            }
            return caseValues;
        }
    }

*  **WriteBackData**（封装回写信息）：

package com.example.myproject.pojo;
    
    /**
     * 回写对象。
     *
     * @author Jan
     * @date 2023/08
     */
    public class WriteBackData {
        /**
         * 用例名称。
         */
        private String caseName;
    
        /**
         * 操作步骤。（即用例报文）
         */
        private String step;
    
        public WriteBackData(String caseName, String step) {
            this.caseName = caseName;
            this.step = step;
        }
    
        public String getCaseName() {
            return caseName;
        }
    
        public void setCaseName(String caseName) {
            this.caseName = caseName;
        }
    
        public String getStep() {
            return step;
        }
    
        public void setStep(String step) {
            this.step = step;
        }
    }

*  **CaseUtils**（静态存放用例设计）：

package com.example.myproject.util;
    
    import java.util.Arrays;
    import java.util.Collections;
    
    /**
     * 测试用例。
     *
     * @author Jan
     * @date 2023/08
     */
    public class CaseUtils {
    
        private static final String STRING = "string";
        private static final String INTERFACE = "[接口名]";
    
        /**
         * 字符串类型用例。
         * 空串、空格字符、特殊字符、整型、精度类型、null值。
         *
         * @return {@link Object[]}
         */
        public static Object[] getStringTypeCases() {
            return new Object[]{"", " ", "@", -1, -1.1, "null"};
        }
    
        /**
         * 整数类型用例。
         * 字符串类型、特殊值0、负数值、整型较大值、整型边界值、精度类型、null值。
         *
         * @return {@link Object[]}
         */
        public static Object[] getIntegerTypeCases() {
            return new Object[]{STRING, 0, -1, 2147483647, 2147483648L, -1.1, "null"};
        }
    
        /**
         * 长整型用例。
         * 字符串类型、特殊值0、负数值、精度类型、null值、长整型边界值。
         *
         * @return {@link Object[]}
         */
        public static Object[] getLongTypeCases() {
            return new Object[]{STRING, 0, -1, -1.1, "null", 9223372036854775807L};
        }
    
        /**
         * 浮点类型用例。
         * 字符串类型、负精度值、负整数值、null值、三位小数。
         *
         * @return {@link Object[]}
         */
        public static Object[] getBigDecimalTypeCases() {
            return new Object[]{STRING, -1.1, -1, 0, "null", 999.999D};
        }
    
        /**
         * 布尔类型用例。
         * 字符串类型、负精度值、负整数值、特殊值0、null值、真布尔、假布尔。
         *
         * @return {@link Object[]}
         */
        public static Object[] getBooleanTypeCases() {
            return new Object[]{STRING, -1, -1.1, 0, "null", true, false};
        }
    
        /**
         * 集合类型用例。
         * 字符串类型、负精度值、null值、负整数值、空集合、混合类型。
         *
         * @return {@link Object[]}
         */
        public static Object[] getJSONArrayTypeCases() {
            return new Object[]{
                    Collections.singletonList(STRING),
                    Collections.singletonList(-1.1),
                    Collections.singletonList(null),
                    Collections.singletonList(-1),
                    Collections.emptyList(),
                    Arrays.asList(STRING, -1, -1.1)
            };
        }
    
        /**
         * 创建指定用例名。
         *
         * @param baseName 基本名称。
         * @param value    值。
         * @return {@link String}
         */
        public static String createSpecifyCaseNameByCaseValue(String baseName, Object value) {
            String caseName = "";
            if ("".equals(value)) {
                caseName = INTERFACE + baseName + "-传空 ".trim();
            } else if (" ".equals(value)) {
                caseName = INTERFACE + baseName + "-传空格 ".trim();
            } else if ("@".equals(value)) {
                caseName = INTERFACE + baseName + "-传特殊符号\"@\" ".trim();
            } else if ("null".equals(value)) {
                caseName = INTERFACE + baseName + "-特殊值null ".trim();
            } else if (STRING.equals(value)) {
                caseName = INTERFACE + baseName + "-传字符类型\"string\" ".trim();
            } else if ("[string]".equals(value)) {
                caseName = INTERFACE + baseName + "-传字符串值类型集合 ".trim();
            } else if ("[-1.1]".equals(value)) {
                caseName = INTERFACE + baseName + "-传精度值类型集合 ".trim();
            } else if ("[null]".equals(value)) {
                caseName = INTERFACE + baseName + "-传null值集合 ".trim();
            } else if ("[-1]".equals(value)) {
                caseName = INTERFACE + baseName + "-传整型值类型集合 ".trim();
            } else if ("[]".equals(value)) {
                caseName = INTERFACE + baseName + "-传空集合 ".trim();
            } else if ("[string, -1, -1.1]".equals(value)) {
                caseName = INTERFACE + baseName + "-传混合数据类型集合 ".trim();
            } else {
                caseName = INTERFACE + baseName + "-传" + value + " ".trim();
            }
            return caseName;
        }
    
    }

*  **ExcelUtils**（excel 操作）：

package com.example.myproject.util;
    
    import com.example.myproject.pojo.WriteBackData;
    import org.apache.poi.xssf.usermodel.XSSFCell;
    import org.apache.poi.xssf.usermodel.XSSFRow;
    import org.apache.poi.xssf.usermodel.XSSFSheet;
    import org.apache.poi.xssf.usermodel.XSSFWorkbook;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStream;
    import java.util.List;
    
    /**
     * Excel 操作。
     *
     * @author Jan
     * @date 2023/08
     */
    public class ExcelUtils {
    
        private ExcelUtils() {
    
        }
    
        /**
         * 写出路径。
         */
        private static final String OUT_PATH = "src/main/resources";
    
        /**
         * 工作表名。
         */
        private static final String SHEET_NAME = "testCase";
    
        /**
         * 用例写入resource目录。
         *
         * @param writeBackDataList 回写数据列表。
         */
        public static void initFileAndWriteDataToExcel(List<WriteBackData> writeBackDataList) {
            File filePath = new File(OUT_PATH);
            FileUtils.initTestCaseFile(filePath);
            String testCaseFilePath = filePath + File.separator + FileUtils.getFileName();
            ExcelUtils.writeExcel(writeBackDataList, testCaseFilePath);
            System.out.println("            ===> 用例写入完成");
        }
    
        /**
         * 写入。
         *
         * @param dataList 数据列表。
         * @param filePath 文件路径。
         */
        private static void writeExcel(List<WriteBackData> dataList, String filePath) {
            try (
                    XSSFWorkbook workbook = new XSSFWorkbook();
                    OutputStream out = new FileOutputStream(filePath)
            ) {
                XSSFSheet sheet = workbook.createSheet(SHEET_NAME);
                // 第一行表头。
                XSSFRow firstRow = sheet.createRow(0);
                XSSFCell[] cells = new XSSFCell[3];
                String[] titles = new String[]{
                        "用例名称",
                        "用例编号",
                        "操作步骤(生成用例后,记得将\"null\"替换为null,9223372036854775807替换为9223372036854775808)"
                };
                // 循环设置表头信息。
                for (int i = 0; i < 3; i++) {
                    cells[0] = firstRow.createCell(i);
                    cells[0].setCellValue(titles[i]);
                }
                // 遍历数据集合,将数据写入 Excel 中。
                for (int i = 0; i < dataList.size(); i++) {
                    XSSFRow row = sheet.createRow(i + 1);
                    WriteBackData writeBackData = dataList.get(i);
                    //第一列 用例名
                    XSSFCell cell = row.createCell(0);
                    cell.setCellValue(writeBackData.getCaseName());
                    //第二列 用例编号
                    cell = row.createCell(1);
                    cell.setCellValue(i + 1);
                    //第三列 操作步骤
                    cell = row.createCell(2);
                    cell.setCellValue(writeBackData.getStep());
                }
                workbook.write(out);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

*  **FileUtils**（用例文件操作）：

package com.example.myproject.util;
    
    import java.io.*;
    import java.nio.charset.StandardCharsets;
    import java.nio.file.Files;
    import java.nio.file.NoSuchFileException;
    import java.nio.file.Path;
    
    /**
     * 文件操作。
     *
     * @author Jan
     * @date 2023/08
     */
    public class FileUtils {
    
        private FileUtils() {
    
        }
    
        /**
         * 生成的用例文件名。
         */
        private static final String FILE_NAME = "TestCase.xls";
    
        /**
         * 读取文件流。
         *
         * @param inputStream 输入流。
         * @return {@link String}
         */
        public static String readFileStream(InputStream inputStream) {
            StringBuilder sb = new StringBuilder();
            try (BufferedReader reader = new BufferedReader(
                    new InputStreamReader(inputStream, StandardCharsets.UTF_8))
            ) {
                String line;
                while (null != (line = reader.readLine())) {
                    sb.append(line);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return sb.toString();
        }
    
        /**
         * 读取请求示例。
         *
         * @return {@link String}
         */
        public static String readSampleRequest() {
            InputStream is = FileUtils.class.getClassLoader().getResourceAsStream("request.json");
            return FileUtils.readFileStream(is);
        }
    
        /**
         * 用例文件名称。
         *
         * @return {@link String}
         */
        public static String getFileName() {
            return FILE_NAME;
        }
    
        /**
         * 初始化测试用例文件。
         *
         * @param filePath 文件路径。
         */
        public static void initTestCaseFile(File filePath) {
            Path testFilePath = filePath.toPath().resolve(getFileName());
            try {
                boolean deleted = Files.deleteIfExists(testFilePath);
                System.out.println(deleted ? "初始化开始 ===> 旧用例删除成功" : "用例初始化开始 ===> 旧用例删除失败");
            } catch (NoSuchFileException e) {
                System.err.println("文件未找到：" + filePath);
            } catch (IOException e) {
                System.err.println("删除文件失败：" + e.getMessage());
            }
    
            try {
                Files.createFile(testFilePath);
                System.out.println("用例初始化结束 ===> 新用例创建成功");
            } catch (IOException e) {
                System.err.println("新用例创建失败：" + e.getMessage());
            }
        }
    }

*  **JsonPathParser**（递归解析得到叶子节点的 jsonPath）：

package com.example.myproject.util;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.parser.ParserConfig;
    
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    
    /**
     * 解析 json 得到具体字段的 jsonPath。
     *
     * @author Jan
     * @date 2023/08
     */
    public class JsonPathParser {
    
        static {
            // 设置全局白名单，解析 pb3 中的 @type 类型。
            ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        }
    
        private JsonPathParser() {
        }
    
        /**
         * 得到json路径。
         *
         * @param jsonStr json str
         * @return {@link Set}<{@link String}>
         */
        public static Set<String> getJsonPaths(String jsonStr) {
            // 解析JSON字符串为JSON对象。
            JSONObject jsonObj = JSON.parseObject(jsonStr);
    
            // 存储JSONPath路径的集合。
            Set<String> jsonPaths = new HashSet<>();
    
            // 递归遍历JSON对象的所有字段，并提取出JSONPath路径。
            parseJsonObj(jsonObj, "$", jsonPaths);
    
            return jsonPaths;
    
        }
    
        /**
         * 解析 json 对象。
         *
         * @param jsonObj    json obj。
         * @param parentPath 父路径。
         * @param jsonPaths  json路径。
         */
        private static void parseJsonObj(JSONObject jsonObj, String parentPath, Set<String> jsonPaths) {
    
            for (Map.Entry<String, Object> entry : jsonObj.entrySet()) {
                String key = entry.getKey();
                // 跳过PBv3的类型标识。
                if (key.contains("@type")) {
                    continue;
                }
                Object value = jsonObj.get(key);
                String currPath = parentPath + "." + key;
    
                // 将当前字段的JSONPath路径添加到集合中。
                jsonPaths.add(currPath);
    
                if (value instanceof JSONObject) {
                    // 递归处理嵌套的JSON对象。
                    parseJsonObj((JSONObject) value, currPath, jsonPaths);
                } else if (value instanceof JSONArray) {
                    // 递归处理嵌套的JSON数组。
                    parseJsonArray((JSONArray) value, currPath, jsonPaths);
                }
            }
        }
    
        /**
         * 解析 json 数组。
         *
         * @param jsonArray  json数组。
         * @param parentPath 父路径。
         * @param jsonPaths  json路径。
         */
        private static void parseJsonArray(JSONArray jsonArray, String parentPath, Set<String> jsonPaths) {
            for (int i = 0; i < jsonArray.size(); i++) {
                // 只取集合中第一个元素的字段。
                if (0 < i) {
                    continue;
                }
    
                Object value = jsonArray.get(i);
                String currPath = parentPath + "[" + i + "]";
    
                if (value instanceof JSONObject) {
                    // 递归处理嵌套的JSON对象。
                    parseJsonObj((JSONObject) value, currPath, jsonPaths);
                } else if (value instanceof JSONArray) {
                    // 递归处理嵌套的JSON数组。
                    parseJsonArray((JSONArray) value, currPath, jsonPaths);
                }
            }
        }
    }

*  **JsonUtils**（设置用例值）：

package com.example.myproject.util;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    import com.alibaba.fastjson.JSONPath;
    
    
    /**
     * 替换字段值。
     *
     * @author Jan
     * @date 2023/08
     */
    public class JsonUtils {
    
        private JsonUtils() {
    
        }
    
        /**
         * 检查并设置json路径值。
         *
         * @param json          json。
         * @param jsonPath      json路径。
         * @param testCaseValue 测试用例价值。
         * @return {@link JSONObject}
         */
        public static JSONObject checkAndSetJsonPathValue(String json, String jsonPath, Object testCaseValue) {
            JSONObject jsonObject = null;
            try {
                jsonObject = JSON.parseObject(json);
                // 还原直接替换值 testCaseValue。
                JSONPath.set(jsonObject, jsonPath, testCaseValue);
    
            } catch (Exception e) {
                System.err.println("error case:" + jsonPath);
            }
            return jsonObject;
        }
    }

### 五、执行效果 ###

> 测试一下。

*  **被测 json 串**：

{
        "String":"str",
        "Int":1,
        "Float":0.1,
        "Long":622337203685477500,
        "Bool":true,
        "test":{
            "Array":[
    
            ]
        }
    }

*  **运行测试**：

![ef8c72baed6acbcfdbeb68328c3111d3.gif][]

*  **生成的最终用例**：

![format_png][]

### 六、其他说明 ###

*  支持 protobuf v3 转换的 json （@type 类型）。
 *  脚本用例生成的优点：
    
     *  高效率，减少冗余操作。
     *  避免编写出因人为失误导致的错误用例。
     *  方便后期用例迭代。
 *  综上所述，在 `json` 字段较多的情况下，提效尤为明显。
 *  源码地址：[gitee.com/Jan7/datafa…][gitee.com_Jan7_datafa]

**最后：**下方这份完整的软件测试视频教程已经整理上传完成，需要的朋友们可以自行领取**【保100%免费】**

![8b0171187dce405e878f274a8cdd9ec0.png][]

#### **软件测试面试文档** ####

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

![a3e4226c935c4242804cbdf26b571bc6.png][]

![58df6cd288094ad8874e814f2477620b.gif][]

[cfee5884c6f0407fa5e0c5b24c901fcf.png]: https://img-blog.csdnimg.cn/cfee5884c6f0407fa5e0c5b24c901fcf.png
[5f252da5fc654b318e0302afb5455b8f.png]: https://img-blog.csdnimg.cn/5f252da5fc654b318e0302afb5455b8f.png
[6cbdda004e7b4376b03c8c9ebffc1e31.png]: https://img-blog.csdnimg.cn/6cbdda004e7b4376b03c8c9ebffc1e31.png
[ef8c72baed6acbcfdbeb68328c3111d3.gif]: https://img-blog.csdnimg.cn/img_convert/ef8c72baed6acbcfdbeb68328c3111d3.gif
[format_png]: https://img-blog.csdnimg.cn/img_convert/ea2f54980b8d7e07620cd17c5983a07d.webp?x-oss-process=image/format,png
[gitee.com_Jan7_datafa]: https://link.juejin.cn?target=https%3A%2F%2Fgitee.com%2FJan7%2Fdatafactory
[8b0171187dce405e878f274a8cdd9ec0.png]: https://img-blog.csdnimg.cn/8b0171187dce405e878f274a8cdd9ec0.png
[a3e4226c935c4242804cbdf26b571bc6.png]: https://img-blog.csdnimg.cn/a3e4226c935c4242804cbdf26b571bc6.png
[58df6cd288094ad8874e814f2477620b.gif]: https://img-blog.csdnimg.cn/58df6cd288094ad8874e814f2477620b.gif