接口自动化框架设计之时间类型参数动态生成

如题，在接口测试过程中，某些接口提交参数可能是不同格式的当前时间、或者未来时间，如下图

这个接口参数需要提交当前格林威治时间

该接口参数需要提交当前标准时间、n 天后的标准时间

接口自动化框架的设计中，为了保证接口用例能重复运行，需要动态生成提交的时间类型参数，具体设计如下：

第一步：设计一个日期时间工具类 CalendarUtil，用于生成各种需要提交的时间格式：

public class CalendarUtil {

    /**
     * 获取指定格式的当前标准时间
     * 
     * @param format
     * @return
     */
    public static String getCurrentGeneralTime(String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date date = new Date();
        return sdf.format(date);
    }

    /**
     * 获取n天前或n天后指定格式的标准时间
     * 
     * @param format
     * @return
     */
    public static String getGeneralTimeAfter(int date,String format) {
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DATE, date);
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.format(c.getTime());
    }

    /**
     * 获取当前格林威治时间
     * 
     * @return
     */
    public static String getCurrentGreenTime() {
        Calendar c = new GregorianCalendar();
        c.add(Calendar.HOUR_OF_DAY, -8);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.000'Z'");
        return df.format(c.getTime());
    }


    /**
     * 获取date天前或date天后的起始格林时间
     * 
     * @param date
     * @return
     */
    public static String getGreenTimeAfterDate(int date) {
        Calendar c = new GregorianCalendar();
        c.add(Calendar.DATE, date-1);
        c.set(Calendar.HOUR_OF_DAY, 16);
        c.set(Calendar.MINUTE, 00);
        c.set(Calendar.SECOND, 00);
        c.set(Calendar.MILLISECOND, 000);
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.000'Z'");
        return df.format(c.getTime());
    }

    /**
     * 获取当前时间戳
     * 
     * @return
     */
    public static Long getCurrentTimeStamp() {
        Date date = new Date();
        return date.getTime();
    }


    /**
     * 获取date天前或date天后的时间戳
     * 
     * @param date
     * @return
     */
    public static Long getTimeStampAfterDate(int date) {
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DATE, date);
        c.add(Calendar.HOUR_OF_DAY, 00);
        c.add(Calendar.MINUTE, 00);
        c.add(Calendar.SECOND, 00);
        c.add(Calendar.MILLISECOND, 000);
        return c.getTime().getTime();
    }
}

第二步：获取用例数据后检测提交参数中是否包含对应的关键字，然后用生成的方法进行替换提交值，如下：

/**
     * 替换请求参数中的${xxx}
     * 
     * @param requestParams
     * @return
     */
    public String replaceRequestParams(String requestParams) {

        // 请求参数不为空且包含替换标识
        if (StringUtils.isNotEmpty(requestParams) && requestParams.contains("${")) {
            String regex = "\\$\\{(.*?)}";
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(requestParams);
            while (matcher.find()) {
                String finder = matcher.group(1);
                String result = finder.trim();
                if (result.equals("currentGreenTime")) {
                    // 替换成当前格林时间
                    requestParams = requestParams.replaceAll("\\$\\{" + finder + "}",
                            CalendarUtil.getCurrentGreenTime());
                } else if (result.contains("greenTimeAfterDate(")) {
                    // 替换成n天前或者n天后的格林威治时间
                    int date = Integer.parseInt(result.substring(result.indexOf("(") + 1, result.indexOf("")).trim());
                    finder = finder.replaceAll("\\(", "\\\\(").replaceAll("\\)", "\\\\)");
                    requestParams = requestParams.replaceAll("\\$\\{" + finder + "}",
                            CalendarUtil.getGreenTimeAfterDate(date));
                } else if (result.contains("currentTimeStamp")) {
                    // 替换成当前时间戳
                    requestParams = requestParams.replaceAll("\\$\\{" + finder + "}",
                            CalendarUtil.getCurrentTimeStamp().toString());
                } else if (result.contains("timeStampAfterDate(")) {
                    // 替换成n天前或n天后的时间戳
                    int date = Integer.parseInt(result.substring(result.indexOf("(") + 1, result.indexOf("")).trim());
                    finder = finder.replaceAll("\\(", "\\\\(").replaceAll("\\)", "\\\\)");
                    requestParams = requestParams.replaceAll("\\$\\{" + finder + "}",
                            CalendarUtil.getTimeStampAfterDate(date).toString());
                } else if (result.contains("currentGeneralTime")) {
                    // 替换生成的指定格式的当前标准时间
                    String regex2 = "currentGeneralTime,(.*?)";
                    Pattern p = Pattern.compile(regex2);
                    Matcher m = p.matcher(result);
                    while (m.find()) {
                        String format = m.group(1);
                        requestParams = requestParams.replaceAll("\\$\\{" + finder + "}",
                                CalendarUtil.getCurrentGeneralTime(format));
                    }
                } else if (result.contains("generalTimeAfter")) {
                    // 替换生成n天前或n天后指定格式的标准时间
                    int date = Integer.parseInt(result.substring(result.indexOf("(")+1, result.indexOf(")")));
                    finder = finder.replaceAll("\\(", "\\\\(").replaceAll("\\)", "\\\\)");
                    String format2 = result.substring(result.indexOf(",")+1);
                    requestParams = requestParams.replaceAll("\\$\\{" + finder + "}",
                            CalendarUtil.getCurrentGeneralTime(format2));
                } else {
                    Object replacement;
                    // 判断map里有没有存储对应的变量
                    if (map.containsKey(result)) {
                        replacement = map.get(result);
                        // 如果有存变量，但值是空，当空字符串处理
                        if (null == replacement) {
                            replacement = "";
                        }
                    } else {
                        // 跳过用例执行，抛出skipException
                        throw new SkipException(result + "不存在，替换失败");
                    }
                    requestParams = requestParams.replaceAll("\\${" + finder + "}", replacement.toString());
                }
            }
        }
        return requestParams;
    }

接口用例设计中，动态参数用 ${关键字}形式

这样就完成了接口框架最重要的一部分：参数动态生成替换的设计