纯java手写打造方法级白盒测试框架

最新推荐文章于 2024-08-03 15:03:03 发布
最新推荐文章于 2024-08-03 15:03:03 发布
阅读量561 收藏 5
点赞数
文章标签： java 反射 软件测试
原文链接：https://my.oschina.net/u/3011043/blog/4542554
版权

纯java手写打造方法级白盒测试框架

​ 我们在做服务端测试时，经常使用的自动化测试框架或平台大多通过restful风格使用http协议接入系统，例如常见的Jmeter、LoadRunner、Postman等，还有不常用或付费的工具如TestRail、katalon、soapUI等，很少见到切入到方法层实现更细颗粒度的工具。对此，本文将封装一款切入到方法层并实现可视化操作的白盒测试框架，突破http应用层壁垒，协助测试人员实现方法级别的测试。

一、使用技术评估

1、开发语言

​ 本框架使用java作为开发语言，大版本为jdk1.8，涉及到的关键技术有java反射、字节码编程、自定义注解、Stream流(jdk8)等。

2、目标方法标识

​ 如果测试人员想测试某个或某组方法，可行方式是在代码方法上打上标识，方便项目运行期自动收集这些方法，本框架使用java自定义注解实现对目标方法的标识。

3、可视化展示

​ 本框架使用模板引擎thymeleaf+springboot提供测试人员操作界面的可视化展示。

二、设计思路简述

1、定义捕捉标记，便于收集目标方法

​ 为了方便测试人员在目标方法上标注，需要新建一个自定义注解@White，主要包含两个信息：一是目标方法的测试备注，二是方法的执行环境配置（判断目标方法是否使用spring容器环境运行）。

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface White {
    /**
     * 方法标注名
     *
     * @return
     */
    String value() default "";

    /**
     * 方法是否来自或使用Spring容器对象（默认不使用）
     *
     * @return
     */
    boolean fromIOC() default false;
}
2、定义接口，方法捕捉器与方法执行器

​ 我们需要定义一个方法捕捉器，用于在项目运行期收集捕捉标注为@White的方法，再定义一个方法执行器，用于测试时执行相关方法。

​ 捕捉器接口，重载了一个含有泛型参数的方法，方便传入的不同的捕获源，如包名、包名组或ioc容器对象。

public interface Catcher<T> {

    /**
     * 执行捕捉操作
     */
    void doCatch() throws Exception;

    /**
     * 执行捕捉操作(传参数)
     */
    void doCatch(T t) throws Exception;
}

​ 执行器接口，重载了一个含参方法，ActElement用于传入目标方法的测试参数，同时扩展了一个执行次数，用于执行压力测试。

public interface Actuator {

    /**
     * 执行目标方法
     *
     * @return
     * @throws Exception
     */
    void doWhiteMethod() throws Exception;


    /**
     * 执行目标方法
     *
     * @param element
     * @throws Exception
     */
    void doWhiteMethod(ActElement element) throws Exception;
}

@Data
@NoArgsConstructor  //无参构造
@AllArgsConstructor //有参构造
public class ActElement {

    /**
     * 执行次数
     */
    private int actNums;

    /**
     * 测试参数
     */
    private String params;

}

​ 抽象处理器AbstractProcessor，实现捕获器和执行器（利用适配器模式，继承该方法后可不必实现所有接口方法，保持代码清爽简洁）

public abstract class AbstractProcessor implements Actuator, Catcher {


    @Override
    public void doWhiteMethod() throws Exception {

    }

    @Override
    public void doWhiteMethod(ActElement element) throws Exception {

    }

    @Override
    public void doCatch() throws Exception {

    }

    @Override
    public void doCatch(Object o) throws Exception {

    }
}
3、封装方法工厂

​ 首先定义WhiteMethod类，作为白盒测试的方法主体，它继承了AbstractProcessor类，并提供了Actuator方法执行器接口的实现。

@Data
@NoArgsConstructor  //无参构造
@AllArgsConstructor //有参构造
public class WhiteMethod extends AbstractProcessor {
    /**
     * 类名
     */
    private String className;
    /**
     * 注解注释
     */
    private String notes;
    /**
     * 反射class
     */
    private Class<?> clazz;
    /**
     * 反射方法
     */
    private Method method;

    /**
     * 方法是否来自或使用Spring容器对象
     */
    private boolean fromIOC;

    /**
     * spring容器中的bean对象
     */
    private Object bean;

    @Override
    public void doWhiteMethod(ActElement element) throws Exception {
        excuteMethod(element.getActNums(), element.getParams());
    }

    /**
     * 反射执行方法
     *
     * @param params 输入参数
     */
    public void excuteMethod(String params) throws Exception {
        System.out.println("======= Test Staring ======>>  [class/bean:" + className + ", method:" + method.getName() + "]");
        //如果测试人员未输入测试参数，使用默认值生成参数组
        Object[] args = (params == null || "".equals(params)) ? AutoSourceUtil.getSampleParams(method) : AutoSourceUtil.getRealParams(method, params);
        //是否使用容器对象执行方法
        if (fromIOC) {
            AutoSourceUtil.doMethod(clazz, method, args, bean);
        } else {
            AutoSourceUtil.doMethod(clazz, method, args, null);
        }
    }

    /**
     * 反射执行方法（多次）
     *
     * @param params 输入参数
     * @param times  执行次数
     */
    public void excuteMethod(int times, String params) throws Exception {
        while (times > 0) {
            excuteMethod(params);
            times--;
        }
    }
}

​ 我们通过一个核心类MethodsFactory，来封装白盒测试的方法工厂，内部维护了一个map格式的方法池。MethodsFactory继承自AbstractProcessor，实现了捕捉器接口的doCatch(Object object)方法，object扩展了三种入参，分别是包路径、包路径数组、ioc容器，根据不同入参类型通过initFactory()方法来实现工厂的初始化。

    /**
     * 白盒测试的方法池
     */
    public static final Map<String, WhiteMethod> whiteMethods = new ConcurrentHashMap<>();

		/**
     * 实现白盒测试方法捕捉器
     *
     * @param object 捕获入口，包路径或IOC容器
     * @throws Exception
     */
    @Override
    public void doCatch(Object object) throws Exception {
        if (object instanceof String) {
            initFactory((String) object);
        } else if (object instanceof String[]) {
            initFactory((String[]) object);
        } else if (object instanceof ApplicationContext) {
            initFactory((ApplicationContext) object);
        }
    }

 		/**
     * 通过包名初始化工厂
     *
     * @param packageNames 扫描的包名组
     * @throws Exception
     */
    public void initFactory(String[] packageNames) throws Exception {
        initFactory(packageNames, null);
    }

    /**
     * 通过包名初始化工厂（二）
     *
     * @param packageName 扫描的包名
     * @throws Exception
     */
    public void initFactory(String packageName) throws Exception {
        String[] packageNames = new String[]{packageName};
        initFactory(packageNames, null);

    }

    /**
     * 通过容器初始化工厂
     *
     * @param context IOC容器
     * @throws Exception
     */
    public void initFactory(ApplicationContext context) throws Exception {
        initFactory(null, context);
    }

 		/**
     * 初始化工厂
     *
     * @param packageNames 扫描的包名
     * @param context      IOC容器
     * @throws Exception
     */
    public void initFactory(String[] packageNames, ApplicationContext context) throws Exception {
        //初始化普通方法入池
        if (packageNames != null) {
            Arrays.asList(packageNames).stream().forEach(name -> initWhiteMethods(name));
        }
        //初始化容器相关方法入池
        if (context != null) {
            initWhiteMethods(context);
        }
    }

​ 初始化工厂，这里重载了initWhiteMethods()方法，区分使用包名还是容器去扫描捕捉对应的目标方法。其中，通过包名的方式扫描，使用工具类PackageUtil的getAllTargets(String packageName)方法，获取所有packageName下类名集合并遍历，收集类中匹配White注解的方法，而通过ioc容器的方式扫描，则是通过spring-beans包的ListableBeanFactory接口（继承自BeanFactory接口，即spring容器的bean工厂）的getBeanDefinitionNames()方法获取所有的bean集合，再执行遍历收集。


    /**
     * 通过包名路径初始化方法池
     *
     * @param packageName
     */
    public void initWhiteMethods(String packageName) {
        List<String> list = PackageUtil.getAllTargets(packageName);
        if (list.size() == 0) {
            return;
        }
        list.stream().forEach(className -> {
            try {
                Class<?> clazz = Class.forName(className);
                Method[] methods = clazz.getDeclaredMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(White.class)) {
                        White white = method.getAnnotation(White.class);
                        if (!white.fromIOC()) {//只收集非容器关联的方法
                            whiteMethods.put("package_key_" + className + "_" + method.getName(), new WhiteMethod(className, white.value(), clazz, method, white.fromIOC(), null));
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }

    /**
     * 通过spring容器初始化方法池
     *
     * @param applicationContext
     */
    public void initWhiteMethods(ApplicationContext applicationContext) {
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        Arrays.asList(beanDefinitionNames).stream().forEach(beanDefinitionName -> {
            try {
                Class<?> clazz = applicationContext.getType(beanDefinitionName);
                Method[] methods = clazz.getDeclaredMethods();
                for (Method method : methods) {
                    if (method.isAnnotationPresent(White.class)) {
                        White white = method.getAnnotation(White.class);
                        if (white.fromIOC()) {
                            whiteMethods.put("spring_key_" + beanDefinitionName + "_" + method.getName(), new WhiteMethod(beanDefinitionName, method.getAnnotation(White.class).value(), clazz, method, white.fromIOC(), applicationContext.getBean(beanDefinitionName)));
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
4、方法执行

​ 我们通过java反射执行目标测试的方法，invoke(Object obj, Object… args)，必要元素为方法所属对象（obj）、参数（args）。

（1）新建方法所属对象

​ 一般使用class对象的newInstance()方法新建对象，但是当方法来自或使用Spring容器时，改为使用BeanFactory接口的getBean(String var1)方法获取bean对象，如果强行使用newInstance()新建对象，有可能导致获取对象某些属性时出现空指针异常。

（2）模拟/获取拼接方法参数

​ 如果要进行测试的方法是有参的，但是测试人员没有输入参数，或者执行批量压力测试不方便输入动态参数时，我们可以通过参数的类型对参数数组进行赋初始化值，如果测试人员有输入参数（以String方式，逗号分隔），则进行动态解析成对应的args参数数组。AutoSourceUtil封装了具体拼接与执行方式，其中参数有可能是基本类型，这时候要使用枚举类BaseJavaType做一下特殊处理。

public class AutoSourceUtil {

    /**
     * 返回反射对应的样例初始化值
     *
     * @param clazz 反射对象
     * @return
     * @throws Exception
     */
    public static Object getSampleValue(Class clazz) throws Exception {

        if (clazz == BaseJavaType.BYTE.getVal())
            return 0;
        if (clazz == BaseJavaType.CHAR.getVal())
            return 0;
        if (clazz == BaseJavaType.SHORT.getVal())
            return 0;
        if (clazz == BaseJavaType.INT.getVal())
            return 0;
        if (clazz == BaseJavaType.LONG.getVal())
            return 0;
        if (clazz == BaseJavaType.DOUBLE.getVal())
            return 0;
        if (clazz == BaseJavaType.FLOAT.getVal())
            return 0;
        if (clazz == BaseJavaType.BOOLEAN.getVal())
            return false;
        else return clazz.newInstance();
    }

    /**
     * 返回样例测试对应的基本类型值或对象
     *
     * @param clazz 反射对象
     * @param param 测试方法字符串
     * @return
     */
    public static Object getRealValue(Class clazz, String param) {

        if (clazz == BaseJavaType.BYTE.getVal())
            return Byte.parseByte(param);
        if (clazz == BaseJavaType.CHAR.getVal())
            return param.charAt(0);
        if (clazz == BaseJavaType.SHORT.getVal())
            return Short.parseShort(param);
        if (clazz == BaseJavaType.INT.getVal())
            return Integer.parseInt(param);
        if (clazz == BaseJavaType.LONG.getVal())
            return Long.parseLong(param);
        if (clazz == BaseJavaType.DOUBLE.getVal())
            return Double.parseDouble(param);
        if (clazz == BaseJavaType.FLOAT.getVal())
            return Float.parseFloat(param);
        if (clazz == BaseJavaType.BOOLEAN.getVal())
            return Boolean.parseBoolean(param);
        else return clazz.cast(param);
    }

    /**
     * 反射调用方法
     *
     * @param clazz  反射class对象
     * @param method 反射方法
     * @param args   需要执行的方法参数
     * @param object 方法对象,设置为null时会使用clazz.newInstance()新建对象
     * @return
     * @throws Exception
     */
    public static Object doMethod(Class<?> clazz, Method method, Object[] args, Object object) throws Exception {
        if (method.getParameterTypes().length == 0) {
            //无参方法，args置为空
            args = null;
        }
        return (object == null) ? method.invoke(clazz.newInstance(), args) : method.invoke(object, args);
    }


    /**
     * 对无测试参数的有参方法，构造对应格式的初始入参数组，各参数使用空白默认值
     *
     * @param method 反射的方法
     * @return
     * @throws Exception
     */
    public static Object[] getSampleParams(Method method) throws Exception {
        //获得一个方法参数数组
        Class[] paramTypes = method.getParameterTypes();
        //拼接动态参数
        Object[] args = new Object[paramTypes.length];
        for (int i = 0, j = paramTypes.length; i < j; i++) {
            args[i] = getSampleValue(paramTypes[i]);
        }
        return args;
    }

    /**
     * 根据测试人员输入的参数拼接成对应格式的可执行参数组
     *
     * @param method 反射的方法
     * @param params 手动输入的参数
     * @return
     * @throws Exception
     */
    public static Object[] getRealParams(Method method, String params) throws Exception {

        String[] stringParams = params.split(",");
        Class[] paramTypes = method.getParameterTypes();

        if (paramTypes.length != stringParams.length) {
            throw new WhiteException("测试参数输入有误！");
        }

        //拼接动态参数
        Object[] args = new Object[paramTypes.length];
        for (int i = 0, j = paramTypes.length; i < j; i++) {
            //基本类型参数处理,
            args[i] = getRealValue(paramTypes[i], stringParams[i]);
        }
        return args;
    }

}

public enum BaseJavaType {

    BYTE("byte", byte.class),
    CHAR("char", char.class),
    SHORT("short", short.class),
    INT("int", int.class),
    LONG("long", long.class),
    DOUBLE("double", double.class),
    FLOAT("float", float.class),
    BOOLEAN("boolean", boolean.class);

    BaseJavaType(String name, Class clazz) {
        this.name = name;
        this.clazz = clazz;
    }

    public Class getVal() {
        return clazz;
    }

    //基本变量类型
    private String name;

    //基本变量类型对应的Class
    private Class clazz;

}

三、使用介绍

​ 使用时继承MethodsFactory类即可使用方法捕捉器和执行器。

1、原生jvm虚拟机环境使用

​ 我们在需要测试的类Demo上的各个方法上加上@White注解。

package com.whiteBox;

import com.whiteBox.core.anno.White;

public class Demo {

    private int result;

    @White("无参方法")
    public int getResult() {
        System.out.println("getResult() has be done");
        return result;
    }

    public void setResult(int result) {
        this.result = result;
    }

    @White("有参(一个参数)")
    public void one(String one) {
        System.out.println("method_one：" + one);
    }

    @White("有参(两个参数)")
    public void two(String two, String twos) {
        System.out.println("method_two:" + two + twos);
    }

    @White("有参(不同类型参数)")
    public void three(String two, int hello) {
        System.out.println(two + "method_three:" + hello);
    }
}

​ DemoTest继承MethodsFactory，调用捕捉器扫描"com.whiteBox"包名下的所有标注了@White的方法，再调用MethodsFactory实现的执行器doWhiteMethod()，它可以将所有扫描收到到的方法执行一遍，如果是有参数方法，会根据类型创建初始参数。

public class DemoTest extends MethodsFactory {

    public static void main(String[] args) throws Exception {
        DemoTest demoTest = new DemoTest();

        //捕捉器捕捉相应包内标记的方法
        demoTest.doCatch("com.whiteBox");

        //执行白盒测试
        demoTest.doWhiteMethod();
    }
}

​ 控制台响应结果如下：可以看到，被@White标注的方法被成功执行。

======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:two]
method_two:
======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:one]
method_one：
======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:three]
method_three:0
======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:getResult]
getResult() has be done
2、spring容器环境中使用
（1）spring样例环境搭建

​ 我们使用springboot+thymeleaf搭建一个简单的用户增删改查demo，maven构建项目，pom添加依赖：

 <!-- thymeleaf引擎依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.webjars.bower</groupId>
            <artifactId>jquery</artifactId>
            <version>2.0.3</version>
        </dependency>
        <dependency>
            <groupId>org.webjars.bower</groupId>
            <artifactId>bootstrap</artifactId>
            <version>3.0.3</version>
        </dependency>
	<!--lombok组件使用-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>

​ 后端按照经典MVC模式设计，其中dao层和service层各方法加上了@White注解，代表该方法将被白盒测试框架收集。

@Data
@NoArgsConstructor  //无参构造
@AllArgsConstructor //有参构造
public class User {
    private int userId;
    private String userName;
    private String sex;
    private String desc;
}

@Component
public class UserDao {
    private static List<User> locallist = new ArrayList<>();

    private static AtomicInteger atomicInteger = new AtomicInteger(1);

    static {
        User u = new User(0, "元始天尊", "男", "最开始的人");
        locallist.add(u);
    }

    @White(value = "dao层-查询用户", fromIOC = true)
    public User getUser(int id) {
        List<User> users = locallist.stream().filter(u -> u.getUserId() == id).collect(Collectors.toList());
        return users.get(0);
    }

    @White(value = "dao层-用户列表", fromIOC = true)
    public List<User> list() {
        return locallist;
    }

    @White(value = "dao层-新增用户", fromIOC = true)
    public void add(User user) {
        user.setUserId(atomicInteger.getAndIncrement());
        locallist.add(user);
    }

    @White(value = "dao层-修改用户", fromIOC = true)
    public void edit(User user) {
        locallist.removeIf(u -> u.getUserId() == user.getUserId());
        locallist.add(user);
    }

    @White(value = "dao层-删除用户", fromIOC = true)
    public void delete(int id) {
        locallist.removeIf(u -> u.getUserId() == id);
    }
}

@Service
public class UserService {
    @Autowired
    private UserDao userDao;

    @White(value = "service层-查询用户", fromIOC = true)
    public User getUser(int id) {
        return userDao.getUser(id);
    }

    @White(value = "service层-用户列表", fromIOC = true)
    public List<User> list() {
        return userDao.list();
    }

    @White(value = "service层-新增用户", fromIOC = true)
    public void add(User user) {
        userDao.add(user);
    }

    @White(value = "service层-修改用户", fromIOC = true)
    public void edit(User user) {
        userDao.edit(user);
    }

    @White(value = "service层-删除用户", fromIOC = true)
    public void delete(int id) {
        userDao.delete(id);
    }
}

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    @RequestMapping("/")
    public String index() {
        return "redirect:/list";
    }

    @RequestMapping("/list")
    public String list(Model model) {
        model.addAttribute("users", userService.list());
        return "user/list";
    }

    @RequestMapping("/toAdd")
    public String toAdd(Model model) {
        User user = new User();
        model.addAttribute("user", user);
        return "user/userAdd";
    }

    @RequestMapping("/add")
    public String add(User user) {
        userService.add(user);
        return "redirect:/list";
    }

    @RequestMapping("/toEdit")
    public String toEdit(Model model, int id) {
        model.addAttribute("user", userService.getUser(id));
        return "user/userEdit";
    }

    @RequestMapping(value = "/edit")
    public String edit(User user) {
        userService.edit(user);
        return "redirect:/list";
    }

    @RequestMapping("/delete")
    public String delete(int id) {
        userService.delete(id);
        return "redirect:/list";
    }
}

​ 使用thymeleaf模板引擎编写表单页面，用户列表：list.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>用户列表</title>
    <link rel="stylesheet" th:href="@{/css/bootstrap.css}"/>
</head>
<body class="container">
<br/>
<h3>用户列表</h3>
<br/><br/>
<div class="with:80%">
    <table class="table table-hover">
        <thead>
        <tr>
            <th>编号</th>
            <th>用户名</th>
            <th>性别</th>
            <th>描述</th>
            <th>修改</th>
            <th>删除</th>
        </tr>
        </thead>
        <tbody>
        <tr th:each="user : ${users}">
            <th scope="row" th:text="${user.userId}">1</th>
            <td th:text="${user.userName}">neo</td>
            <td th:text="${user.sex}">1</td>
            <td th:text="${user.desc}">6</td>
            <td><a th:href="@{/toEdit(id=${user.userId})}">编辑</a></td>
            <td><a th:href="@{/delete(id=${user.userId})}">删除</a></td>
        </tr>
        </tbody>
    </table>
</div>
<div class="form-group">
    <div class="col-sm-2 control-label">
        <a href="/toAdd" th:href="@{/toAdd}" class="btn btn-info">新增</a>
    </div>
</div>
</body>

​ 新增页面userAdd.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>添加用户</title>
    <link rel="stylesheet" th:href="@{/css/bootstrap.css}"/>
</head>
<body class="container">
<br/>
<h1>增加用户</h1>
<br/><br/>
<div class="with:80%">
    <form class="form-horizontal" th:action="@{/add}" th:object="${user}"  method="post">
        <input type="hidden" name="userId" th:value="*{userId}" />
        <div class="form-group">
            <label for="userName" class="col-sm-2 control-label">userName</label>
            <div class="col-sm-10">
                <input type="text" class="form-control" name="userName" id="userName" placeholder="userName"/>
            </div>
        </div>
        <div class="form-group">
            <label for="sex" class="col-sm-2 control-label">age</label>
            <div class="col-sm-10">
                <input type="text" class="form-control" name="sex"  id="sex"  placeholder="sex"/>
            </div>
        </div>
        <div class="form-group">
            <label for="desc" class="col-sm-2 control-label">desc</label>
            <div class="col-sm-10">
                <input type="text" class="form-control" name="desc"  id="desc"  placeholder="desc"/>
            </div>
        </div>

        <div class="form-group">
            <div class="col-sm-offset-2 col-sm-10">
                <input type="submit" value="提交" class="btn btn-info" />
                &nbsp; &nbsp; &nbsp;
                <a href="/toAdd" th:href="@{/list}" class="btn btn-info">返回</a>
            </div>

        </div>
    </form>
</div>
</body>
</html>

​ 编辑页面userEdit.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>修改用户</title>
    <link rel="stylesheet" th:href="@{/css/bootstrap.css}"/>
</head>
<body class="container">
<br/>
<h1>修改用户</h1>
<br/><br/>
<div class="with:80%">
    <form class="form-horizontal" th:action="@{/edit}" th:object="${user}" method="post">
        <input type="hidden" name="userId" th:value="*{userId}"/>
        <div class="form-group">
            <label for="userName" class="col-sm-2 control-label">userName</label>
            <div class="col-sm-10">
                <input type="text" class="form-control" name="userName" id="userName" th:value="*{userName}"
                       placeholder="userName"/>
            </div>
        </div>
        <div class="form-group">
            <label for="sex" class="col-sm-2 control-label">age</label>
            <div class="col-sm-10">
                <input type="text" class="form-control" name="sex" id="sex" th:value="*{sex}" placeholder="sex"/>
            </div>
        </div>
        <div class="form-group">
            <label for="desc" class="col-sm-2 control-label">desc</label>
            <div class="col-sm-10">
                <input type="text" class="form-control" name="desc" id="desc" th:value="*{desc}" placeholder="desc"/>
            </div>
        </div>

        <div class="form-group">
            <div class="col-sm-offset-2 col-sm-10">
                <input type="submit" value="提交" class="btn btn-info"/>
                &nbsp; &nbsp; &nbsp;
                <a href="/toAdd" th:href="@{/list}" class="btn btn-info">返回</a>
            </div>

        </div>
    </form>
</div>
</body>
</html>

​ 本地启动容器，访问http://localhost:8080/list，即可进行简单的user增删改查，此处不赘述。

在这里插入图片描述

（2）容器下执行捕捉器收集白盒测试方法

​ 我们可以在spring容器启动后使用方法捕捉器收集目标方法，在管理平台界面进行单个方法的分析与测试。这里定义一个WhiteHandler，继承MethodsFactory，实现ApplicatonContextAware接口，在setApplicationContext()方法中获取BeanFactory的实例applicationContext，同时对包"com.whiteBox"和spring容器进行扫描收集。

@Component
public class WhiteHandler extends MethodsFactory implements ApplicationContextAware {

    /**
     * 重写setApplicationContext方法，获取IOC容器：ApplicationContext实例
     *
     * @param applicationContext
     * @throws BeansException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        try {
            //捕捉该包下的标注方法
            doCatch("com.whiteBox");
            //捕捉spring容器环境下相关标注方法
            doCatch(applicationContext);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
（3）容器下使用方法执行器进行测试

​ 为方便图形化测试，新建一个WhiteController，提供白盒方法的查询和执行处理。前面提到WhiteMethod继承了AbstractProcessor并实现了doWhiteMethod方法，可以通过它对单个方法进行测试执行。

@Controller
@RequestMapping("white")
public class WhiteController {

    /**
     * 获取工厂里的方法池，并以List形式输出
     * @return
     */
    private List<WhiteMethod> getMethods(){
        return MethodsFactory.whiteMethods.values().stream()
                .collect(Collectors.toList());
    }

    /**
     * 方法列表，列出所有标注的方法
     *
     * @param model
     * @return
     */
    @RequestMapping("/list")
    public String list(Model model) {
        model.addAttribute("methods", getMethods());
        return "white/whiteList";
    }

    /**
     * 跳转至方法详情
     *
     * @param model
     * @param index
     * @return
     */
    @RequestMapping("/toExecute")
    public String toExecute(Model model, int index) {
        WhiteMethod whiteMethod = getMethods().get(index);
        model.addAttribute("index", index);
        model.addAttribute("whiteMethod", whiteMethod);
        return "white/doExecute";
    }

    /**
     * 执行测试方法
     *
     * @param index
     * @param times
     * @param params
     * @return
     * @throws Exception
     */
    @RequestMapping("/execute")
    public String execute(int index, int times, String params) throws Exception {
        WhiteMethod whiteMethod = getMethods().get(index);
        ActElement element = new ActElement(times, params);
        whiteMethod.doWhiteMethod(element);
        return "redirect:/white/list";
    }

}

​ 前端页面whiteList.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>白盒测试方法列表</title>
    <link rel="stylesheet" th:href="@{/css/bootstrap.css}"/>
</head>
<body class="container">
<br/>
<h3>方法列表</h3>
<br/><br/>
<div class="with:80%">
    <table class="table table-hover">
        <thead>
        <tr>
            <th>序号</th>
            <th>类名/Bean名</th>
            <th>方法名</th>
            <th>标注</th>
            <th>容器</th>
            <th>操作</th>
        </tr>
        </thead>
        <tbody>
        <tr th:each="whiteMethod : ${methods}">
            <th scope="row" width="60px" th:text="${methods.indexOf(whiteMethod)+1}">1</th>
            <td th:text="${whiteMethod.className}"></td>
            <td th:text="${whiteMethod.method}"></td>
            <td width="200px" th:text="${whiteMethod.notes}">1</td>
            <td width="50px" th:text="${whiteMethod.fromIOC}">1</td>
            <td width="60px"><a th:href="@{/white/toExecute(index=${methods.indexOf(whiteMethod)})}">执行</a></td>
        </tr>
        </tbody>
    </table>
</div>

</body>
</html>

​ 方法执行页面doExecute.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8"/>
    <title>白盒测试方法列表</title>
    <link rel="stylesheet" th:href="@{/css/bootstrap.css}"/>
</head>
<body class="container">
<br/>
<h3>方法列表</h3>
<br/><br/>
<div class="with:80%">
    <table class="table table-hover">
        <thead>
        <tr>
            <th>序号</th>
            <th>类名/Bean名</th>
            <th>方法名</th>
            <th>标注</th>
            <th>容器</th>
            <th>操作</th>
        </tr>
        </thead>
        <tbody>
        <tr th:each="whiteMethod : ${methods}">
            <th scope="row" width="60px" th:text="${methods.indexOf(whiteMethod)+1}">1</th>
            <td th:text="${whiteMethod.className}"></td>
            <td th:text="${whiteMethod.method}"></td>
            <td width="200px" th:text="${whiteMethod.notes}">1</td>
            <td width="50px" th:text="${whiteMethod.fromIOC}">1</td>
            <td width="60px"><a th:href="@{/white/toExecute(index=${methods.indexOf(whiteMethod)})}">执行</a></td>
        </tr>
        </tbody>
    </table>
</div>

</body>
</html>

​ 启动容器后，访问http://localhost:8080/white/list，即可看到所有被标注的方法详情，其中容器，true代表使用spring容器环境的对象执行方法。

在这里插入图片描述

a.测试普通方法:

​ 点击第7条，输入测试参数：“你好,2020”，次数5。

在这里插入图片描述
​ 点击提交，控制台打印的测试日志如下，可以看到该方法执行了5次：

======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:three]
你好method_three:2020
======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:three]
你好method_three:2020
======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:three]
你好method_three:2020
======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:three]
你好method_three:2020
======= Test Staring ======>>  [class/bean:com.whiteBox.Demo, method:three]
你好method_three:2020
b.测试容器方法

​ 在容器方法的注解上fromIOC属性要为true，我们点击列表第5条，测试service层的add方法，输入次数为2，点击提交。
在这里插入图片描述

​ 控制台日志，可以看到userService的新增方法执行了2次

======= Test Staring ======>>  [class/bean:userService, method:add]
======= Test Staring ======>>  [class/bean:userService, method:add]

​ 再访问用户列表http://localhost:8080/list，即可看到新增了id为1和2两个用户，测试service层新增方法成功。

在这里插入图片描述

​ 下面我们测试下dao层的删除方法，回到http://localhost:8080/white/list方法列表，点击第12条执行，输入测试参数：2，次数：1，点击提交，这时删除将id为2的用户。

在这里插入图片描述

​ 控制台日志，可以看到userDao的删除方法执行了1次

======= Test Staring ======>>  [class/bean:userDao, method:delete]

​ 重新查看用户列表，发现id为2的用户已经被删除，测试dao层方法成功执行。
在这里插入图片描述

四、总结与思考

​ 本框架尝试通过自定义注解标识目标方法并项目运行期自动收集相关方法，封装测试参数和测试次数入口，达到辅助测试人员进行白盒或压力测试的目标。代码尽可能的兼容到了复杂运行环境和测试需求，但是难免有一些不足的地方，例如执行海量次数压力请求设置成异步、进一步集成序列化组件实现跨语言支持等。最后给大家留下一个思考，如果业务代码的Service层方法添加基于 @Transactional 的声明式事务管理，通过本框架是否能实现对事务的支持呢？

代码下载地址：https://github.com/kaccnGit/whiteframework

暑天闲绕
关注
白盒测试源代码
07-10
白盒测试源代码
白盒测试框架java_白盒测试的学习之路----（四）搭建测试框架TestNG测试
weixin_30464195的博客
02-28 398
TestNG是一个开源自动化测试框架; TestNG是类似于JUnit，但它不是一个JUnit扩展。它的灵感来源于JUnit。它的目的是优于JUnit的，尤其是当测试集成的类。 TestNG消除了大部分的旧框架的限制，使开发人员能够编写更加灵活和强大的测试。 因为它在很大程度上借鉴了Java注解(JDK5.0引入的)来定义的测试，它也可以告诉你如何使用这个新功能在真实的Java语言生产环境中。一般...
七款优秀的Java测试框架，你最适合哪一个？
最新发布
okcross0的博客
08-03 776
Java是当今最流行的编程语言之一，常年位居最受欢迎前三。一个优秀的员，在研发时离不开对测试框架的了解，从而开发出更安全和更高效的代码。使用这些测试框架的其中一个最重要的原因是减少出错的可能性，提高开发效率，并降低研发成本。在本文中，我们将介绍用于 Java测试的最常见的测试框架。
后台服务项目的白盒测试之旅
网易数帆社区博客
09-22 248
本文来自阿网易云社区作者：孙婷婷白盒测试起因17年下半年我开始介入部门新项目的服务v2版本的功能测试。刚接手项目时，感到十分头疼，首先它不像我刚接触测试时做的to C端项目，主要是页面展示操作，黑盒测试足够；其次它不像我刚来网易介入的图像项目，主要通过接口判断图片属性，撸撸产品需求也能通过黑盒测试覆盖功能。相比之下新项目的项目特点则是：A.    是一个服务端项目，主要是接口测试；B.    接口...
结合Java代码覆盖率框架jacoco，进行白盒测试
m0_73982882的博客
12-03 666
盒子内部的实现，也就是内部的代码逻辑的测试。可以依据代码内部逻辑，进行设计测试用例，对代码内部所有的路径、判断、条件进行测试（主要基于服务端的Controller层、service层、RPC层等进行正常、异常逻辑处理的测试）；所以白盒测试是一种基于代码逻辑的测试，主要是根据内部的代码实现，来设计测试用例，得出预期的测试数据。代码逻辑覆盖的越高（覆盖率越高），也就是测试的越全面。那么如何知道自己所测的逻辑被覆盖到了，有两种方式，第一种梳理代码逻辑，通过查看服务端代码日志的调用链路，结合代码自己人为去梳理；
java白盒测试
huyifei2016的博客
04-26 5432
白盒的测试方法 白盒的测试其它方法 Java动态检查工具介绍 Java mock框架介绍 Java静态检查工具介绍​​​​​​​ 白盒测试方法 对代码静态检查（编码规范，潜在缺陷(包括安全性，性能)，代码复杂度） 代码的动态覆盖率检查 白盒测试方法 •1.语句覆盖 •2.判定覆盖 •3.条件覆盖 •4.判定&条件覆盖 •5.多重条件覆...
白盒测试哪种测试效果好_纯java手写打造方法级白盒测试框架
weixin_39866774的博客
12-31 119
我们在做服务端测试时，经常使用的自动化测试框架或平台大多通过restful风格使用http协议接入系统，例如常见的Jmeter、LoadRunner、Postman等，还有不常用或付费的工具如TestRail、katalon、soapUI等，很少见到切入到方法层实现更细颗粒度的工具。对此，本文将封装一款切入到方法层并实现可视化操作的白盒测试框架，突破http应用层壁垒，协助测试人员实现方...
Java白盒测试
Gem丶超超的博客
04-12 2347
Java白盒测试 spring单元测试 环境正常单元测试 spring单元测试公共源码类 step1：工程依赖配置 <dependency> <groupId>javax.servlet</groupId> <artifactId>javax.servlet-api</artifactId> <version>4.0.1</version> <scope>provided</
基于JAVA SSM框架的酒店客房管理系统设计
【完整】
02-21 8101
酒店客房管理系统 摘 要 随着信息需求的增长，传统的信息交流方式早已不能满足企业对传递和处理大量信息的需要，因而亟需把网络技术渗透到日常生活中。在当代快速发展的社会里，无处不见酒店，酒店客房管理系统的开发势在必行。随着计算机的普及和计算机科学技术的飞速发展，人们开始越来越多地利用计算机解决实际问题。酒店面对大量的预定，入住以及人员管理和历史记录的查询等问题，采用原始方式处理既浪费时间、又浪费人力和物力，并且数据的准确性低，所以酒店管理系统的出现起到了很重要的作用。因此，总结前人的经验，开发交互性好...
【软件测试】进阶篇
weixin_45964036的博客
06-25 293
也叫UI测试，直接和用户交互的，界面设计的好坏决定了用户使用软件的直观感受。保证界面和UI设计稿的一致性，正确性。测试界面的每一个功能的正确性。（从上到下，从左到右）界面的布局排版（字体大小，图片布局排版，清晰程度…）要合理界面的控件（滚动条，按钮，Checkbox，文本框）功能是否正常界面的自适应测试：要进行界面的不同分辨率的测试。（窗口由大变小时，字体是否重叠，图片是否模糊等）页面的状态（颜色、排版）和当下节日，时事相结合同一个web页面不同页面大小测试：页面从小到大变化过程中衔接顺滑，让用户可以接受；
27岁从业软件测试5年的我被无情的辞退了
Yanan990830的博客
11-02 702
外包测试的灾难 原来做欧美日韩外包业务的公司会因为国内互联网的发展逐渐式微， 他们需要转型做国内。 但是国内对外包业务也大多排斥， 而且外包业务在效率沟通管理上都有诸多弊端。 其自身也无法承载对测试工程师的培养和长期发展。 所以这几年会有大量的外包测试工程师转型。 这方面需要有新的优秀的外包服务公司。能做到有自己的测试服务， 测试技术和高级的测试研究工程师才行
java自动化测试框架
09-20
java自动化测试框架
自动化测试框架 selenium+testng+reportng+Java+maven
07-27
1、支持多并行测试 2、支持所有的云解决方案，如 BrowserStack，SauceLabs，Testingbot 3、数据驱动测试 4、一步级报告生成 5、自动屏幕快照的失败的测试步骤 6、集成的命令行支持 7、ExpectedConditionsExtended PageObjects Design 模式 8、自动重新运行失败的测试用例...
系统架构设计师【第5章】: 软件工程基础知识 (核心总结)
数据知道的博客
05-30 6551
按照常见的软件开发阶段划分，分别讨论需求、分析、设计、编码和测试等环节中的常见方法和技术
划分测试类型
qq_51263139的博客
08-16 1050
关于软件测试的划分
java 常用测试框架
隔壁☞老杨的博客
02-23 606
1. 常用单元化测试框架 junit4 , TestNG 可以通过注解 @Before @After @BeforeClass @AfterClass 分别作方法与类级的初始化与结束动作。  testNG示例： public class TestngAnnotation { // test case 1 @Test public void testCase1() {
java自动化开发_五大Java自动化测试框架
weixin_34266290的博客
02-17 4602
【51CTO.com快译】多年来，Java一直是服务器端应用开发的首选编程语言。随着时间的推移和自动化测试的兴起，业界出现了许多基于Java，并根据不同的业务逻辑而发展起来的开源框架。在此，我向大家介绍并比较五种用到了Java的自动化测试框架。由Kent Beck和Erich Gamma开发的JUnit是xUnit框架的一个实例。其设计的宗旨是让Java开发人员能够编写出各种脚本、并执行那些可重复...
5个非常流行且常用的Java自动化测试框架！
软件测试技术资源分享官
04-25 2875
目前有无数的 Java 测试框架可供 QA 测试人员使用。可以理解的是，您拥有的选择越多，从很多中选出最好的一个就越复杂。在本文中，我们将分享一些常用的 Java 测试框架，以提升您的职业生涯并提高您的技能组合。
白盒测试方法详解：分类与策略
白盒测试是一种深入到软件内部，依据程序的逻辑结构和内部工作原理进行的软件测试方法，旨在尽可能多地发现源代码中的错误。它主要分为静态分析和动态测试两个部分。 静态分析，如代码审查、桌面检查和代码走查，是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值