2.5单元测试示例

单元测试常见问题

• 数据源不独立，常因为新增加的测试用例，影响到以前的测试用例

• 期待结果写在测试代码中，耦合度高

• 每次增加测试用例，都需要更改测试代码，测试代码不可复用

本小节中，我们将介绍一种优雅的测试用例方式

• 我们会使用一个json文件囊括测试用例所需的所有入参，依赖，期待结果，期待异常。从而没次增加测试用例，只需要向json文件中添加数据即可，无需改动代码

• 每一个方法拥有独立的数据源

实体类

com.moluo.example.util.TestCase

package com.inspur.securityhubapi.util;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

/**
 * 测试用例类
 * <p>
 * 使用此类，json结构体需要满足如下格式
 * <pre>
 * {
 *   "方法名": [
 *     {
 *       "description": "",
 *       "args": {
 *         JsonObject对象
 *       },
 *       "relyMethodReturnMocks": {
 *         JsonArray对象
 *       },
 *       "exceptSuccessResults": {
 *         JsonArray对象
 *       },
 *       "exceptFailureResults": {
 *         JsonArray对象
 *       }
 *     }
 *   ]
 * }
 * </pre>
 *
 * @author moluo
 * @since 2020/5/22
 */
public class TestCase {

    private String description;
    private JSONObject args;
    private JSONObject relyMethodReturnMocks;
    private JSONObject exceptSuccessResults;
    private JSONObject exceptFailureResults;

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public <T> T getArg(String key, Class<T> clazz) {
        return args.getObject(key, clazz);
    }

    public void setArgs(JSONObject args) {
        this.args = args;
    }

    public void addArg(String key, JSONObject jsonObject) {
        args.put(key, jsonObject);
    }

    public <T> T getRelyMethodReturnMock(String key, int index, Class<T> clazz) {
        return relyMethodReturnMocks.getJSONArray(key).getObject(index, clazz);
    }

    public void setRelyMethodReturnMocks(JSONObject relyMethodReturnMocks) {
        this.relyMethodReturnMocks = relyMethodReturnMocks;
    }

    public void addRelyMethodReturnMock(String key, JSONArray values) {
        relyMethodReturnMocks.put(key, values);
    }

    public <T> T getExceptSuccessResult(String key, int index, Class<T> clazz) {
        return exceptSuccessResults.getJSONArray(key).getObject(index, clazz);
    }

    public void setExceptSuccessResults(JSONObject exceptSuccessResults) {
        this.exceptSuccessResults = exceptSuccessResults;
    }

    public void addExceptSuccessResult(String key, JSONArray values) {
        exceptSuccessResults.put(key, values);
    }

    public Boolean hasExceptSuccessResults() {
        return !exceptSuccessResults.isEmpty();
    }

    public <T> T getExceptFailureResult(String key, int index, Class<T> clazz) {
        return exceptFailureResults.getJSONArray(key).getObject(index, clazz);
    }

    public void setExceptFailureResults(JSONObject exceptFailureResults) {
        this.exceptFailureResults = exceptFailureResults;
    }

    public void addExceptFailureResult(String key, JSONArray values) {
        exceptFailureResults.put(key, values);
    }

    public Boolean hasExceptFailureResults() {
        return !exceptFailureResults.isEmpty();
    }

}

需要的工具类

com.moluo.example.util.JsonUtils

package com.inspur.securityhubapi.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.parser.Feature;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Type;
import java.nio.charset.StandardCharsets;
import java.util.List;

/**
 * JSON文件读取工具类
 *
 * @author moluo
 * @since 2019/8/2
 */
public class JsonUtils {

    /**
     * 读取指定路径的文件并转化为指定对象列表
     *
     * @param path  文件路径
     * @param clazz 列表item对象类型
     * @param <T>   泛型
     * @return 指定类型对象列表
     */
    public static <T> List<T> readObjects(String path, Class<T> clazz) {
        String s = readObject(path, String.class);
        return JSONArray.parseArray(s, clazz);
    }

    /**
     * 读取指定路径的文件并转化为指定对象
     * <p>
     * 该方法对{@link JsonUtils#readJsonFromClassPath(String, Type)}进行简单封装，捕获其抛出的异常
     *
     * @param path 文件路径
     * @param type 类型对象
     * @param <T>  泛型
     * @return 指定类型的对象
     */
    public static <T> T readObject(String path, Type type) {
        try {
            return readJsonFromClassPath(path, type);
        } catch (IOException e) {
            System.err.println("cannot find file " + path);
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 转换jsonArray为int数组
     *
     * @param jsonArray JSONArray对象
     * @return int数组
     */
    public static int[] jsonArrayToIntArray(JSONArray jsonArray) {
        int[] results = new int[jsonArray.size()];
        for (int i = 0; i < jsonArray.size(); i++) {
            results[i] = jsonArray.getIntValue(i);
        }
        return results;
    }

    /**
     * 读取指定路径的文件并转化为指定对象
     *
     * @param path 文件路径
     * @param type 类型对象
     * @param <T>  泛型
     * @return 指定类型的对象
     * @throws IOException IO异常
     */
    private static <T> T readJsonFromClassPath(String path, Type type) throws IOException {
        File file = new File("src/test/resources/" + path);
        FileInputStream fileInputStream = null;
        try {
            fileInputStream = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        if (fileInputStream == null) {
            return null;
        }
        return JSON.parseObject(fileInputStream, StandardCharsets.UTF_8, type,
                // 自动关闭流
                Feature.AutoCloseSource,
                // 允许注释
                Feature.AllowComment,
                // 允许单引号
                Feature.AllowSingleQuotes,
                // 使用 Big decimal
                Feature.UseBigDecimal);
    }
}

com.moluo.example.util.TestCaseUtils

package com.inspur.securityhubapi.util;

import com.alibaba.fastjson.JSONObject;

import java.util.ArrayList;
import java.util.List;

/**
 * 测试用例工具类
 * {@link TestCase}
 *
 * @author moluo
 * @since 2020/5/22
 */
public class TestCaseUtils {

    private String testMethodName;
    private String testCaseJsonPath;

    public TestCaseUtils(String testMethodName, String testCaseJsonPath) {
        this.testMethodName = testMethodName;
        this.testCaseJsonPath = testCaseJsonPath;
    }

    public List<TestCase> getTestCases() {
        List<TestCase> result = new ArrayList<>();
        JSONObject testJsonObject = JsonUtils.readObject(testCaseJsonPath, JSONObject.class);
        List<JSONObject> testMethodJsons = testJsonObject.getJSONArray(testMethodName).toJavaList(JSONObject.class);
        for (JSONObject json : testMethodJsons) {
            TestCase testCase = JSONObject.toJavaObject(json, TestCase.class);
            result.add(testCase);
        }
        return result;
    }

}

示例json文件

resources/mock/json/mq/CsfMessageListenerTest.json

{
  "createSecurityGroup": [
    {
      "description": "监听安全组创建事件-安全组已存在，跳过创建",
      "args": {
        "messageBody": {
          "index": 1,
          "requestId": "335f7af8-a900-4294-962f-06270481de53",
          "return": {
            "eventMessage": {},
            "result": "{\"security_groups_man\":\"6226056e-a8fa-4132-8e19-ac2bb6d97f58\"}",
            "status": "SKIPPED",
            "error": ""
          },
          "serviceId": "iot-yf-TNemt3uqQf"
        }
      },
      "relyMethodReturnMocks": {
        "productInsts": [
          {
            "id": "4028121b724a842701724fbb78000fc2",
            "name": "云堡垒机-安全组测试",
            "description": ""
          }
        ]
      },
      "exceptSuccessResults": {
        "exceptMethodCallCounts": [
          {
            "bssMessageSender.senderCreateFailMessage": 0
          }
        ]
      },
      "exceptFailureResults": {
      }
    },
    {
      "description": "监听安全组创建事件-安全组创建失败",
      "args": {
        "messageBody": {
          "index": 1,
          "requestId": "361050e7-314f-402d-9951-17f533bf28d4",
          "return": {
            "eventMessage": {},
            "result": "{\"msg\":\"[]1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: 1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: Expected HTTP response code [201 202] when accessing [POST http://172.16.1.20:9696/v2.0/security-groups], but got 409 instead{\\\"NeutronError\\\": {\\\"message\\\": \\\"Quota exceeded for resources: ['security_group'].\\\", \\\"type\\\": \\\"OverQuota\\\", \\\"detail\\\": \\\"\\\"}}\"}",
            "status": "FAILED",
            "error": "{\"msg\":\"[]1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: 1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: Expected HTTP response code [201 202] when accessing [POST http://172.16.1.20:9696/v2.0/security-groups], but got 409 instead{\\\"NeutronError\\\": {\\\"message\\\": \\\"Quota exceeded for resources: ['security_group'].\\\", \\\"type\\\": \\\"OverQuota\\\", \\\"detail\\\": \\\"\\\"}}\"}"
          },
          "serviceId": "iot-yf-TNemt3uqQf"
        }
      },
      "relyMethodReturnMocks": {
        "productInsts": [
          {
            "id": "4028121b724a842701724fbb78000fc2",
            "name": "云堡垒机-安全组测试",
            "description": ""
          }
        ]
      },
      "exceptSuccessResults": {
        "exceptMethodCallCounts": [
          {
            "bssMessageSender.senderCreateFailMessage": 1
          }
        ]
      },
      "exceptFailureResults": {
      }
    },
    {
      "description": "监听安全组创建事件-发生IO异常",
      "args": {
        "messageBody": {
          "index": 1,
          "requestId": "361050e7-314f-402d-9951-17f533bf28d4",
          "return": {
            "eventMessage": {},
            "result": "{\"msg\":\"[]1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: 1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: Expected HTTP response code [201 202] when accessing [POST http://172.16.1.20:9696/v2.0/security-groups], but got 409 instead{\\\"NeutronError\\\": {\\\"message\\\": \\\"Quota exceeded for resources: ['security_group'].\\\", \\\"type\\\": \\\"OverQuota\\\", \\\"detail\\\": \\\"\\\"}}\"}",
            "status": "FAILED",
            "error": "{\"msg\":\"[]1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: 1 error(s) occurred:* openstack_networking_secgroup_v2.secgroup_eth1: Expected HTTP response code [201 202] when accessing [POST http://172.16.1.20:9696/v2.0/security-groups], but got 409 instead{\\\"NeutronError\\\": {\\\"message\\\": \\\"Quota exceeded for resources: ['security_group'].\\\", \\\"type\\\": \\\"OverQuota\\\", \\\"detail\\\": \\\"\\\"}}\"}"
          },
          "serviceId": "iot-yf-TNemt3uqQf"
        }
      },
      "relyMethodReturnMocks": {
        "productInsts": [
          {
            "id": "4028121b724a842701724fbb78000fc2",
            "name": "云堡垒机-安全组测试",
            "description": ""
          }
        ],
        "exceptions": [
          {
            "name": "java.io.IOException",
            "message": ""
          }
        ]
      },
      "exceptSuccessResults": {
      },
      "exceptFailureResults": {
        "exceptions": [
          {
            "name": "java.io.IOException",
            "message": ""
          }
        ]
      }
    }
  ]
}

示例

package com.inspur.securityhubapi.mq;


import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.test.util.ReflectionTestUtils;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
import java.util.Map;

import static org.junit.Assert.fail;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
...

public class CsfMessageListenerTest extends BaseTest {

    @InjectMocks
    private CsfMessageListener csfMessageListener;

    ...

    @Mock
    private BssMessageSender bssMessageSender;

    private List<JSONObject> responseMessage;

    private List<ProductInst> productInstList;

    private List<ProductInstOperation> productInstOperationList;

    private List<ProductInstProp> productInstPropList;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
        ...
        String productInstPropProp = "/mock/json/product_inst_prop.json";
        productInstPropList = JsonUtils.readObjects(productInstPropProp, ProductInstProp.class);

        ReflectionTestUtils.setField(csfMessageListener, "sendMockMessageOn", true);
    }
    @Test
    public void createSecurityGroup() throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        String path = "/mock/json/mq/CsfMessageListenerTest.json";
        TestCaseUtils testCaseUtils = new TestCaseUtils("createSecurityGroup", path);
        List<TestCase> testCases = testCaseUtils.getTestCases();

        for (TestCase testCase : testCases) {
            // 获取测试用例描述
            String description = testCase.getDescription();
            System.out.println("测试用例：" + description);

            // 获取测试用例入参
            JSONObject messageBody = testCase.getArg("messageBody", JSONObject.class);
            Message message = new Message(messageBody.toJSONString().getBytes(), new MessageProperties());

            // 获取测试用例对其他依赖方法的返回体
            when(objectMapper.readValue(any(byte[].class), any(Class.class))).thenReturn(messageBody);
            ProductInst productInst = testCase.getRelyMethodReturnMock("productInsts", 0, ProductInst.class);
            when(productInstService.getProductInstByServiceId(anyString())).thenReturn(productInst);
            when(productInstService.updateProductInstByServiceId(anyString(), any(ProductInst.class))).thenReturn(productInst);
            doNothing().when(productInstService).deleteProductInst(anyString());
            when(productInstOperationService.saveProductInstOperation(anyString(), anyString(), anyBoolean(), anyString(), anyString())).thenReturn(null);
            when(websocketService.sendWebsocketInfo(any(ProductInst.class), anyString(), anyString())).thenReturn(Boolean.TRUE);
            doNothing().when(bssMessageSender).senderCreateFailMessage(any(ProductInst.class));

            if (testCase.hasExceptSuccessResults()) {
                // 获取期待结果
                Map<String, Integer> exceptMethodCallCounts = testCase.getExceptSuccessResult("exceptMethodCallCounts", 0, Map.class);
                // 执行待测试的方法逻辑
                csfMessageListener.createSecurityGroup(message, null);
                // 断言
                verify(bssMessageSender, times(exceptMethodCallCounts.get("bssMessageSender.senderCreateFailMessage"))).senderCreateFailMessage(any(ProductInst.class));
                System.out.println();
            }

            if (testCase.hasExceptFailureResults()) {
                // 获取测试用例对依赖方法的返回体
                JSONObject exceptionJson = testCase.getRelyMethodReturnMock("exceptions", 0, JSONObject.class);
                Exception exceptionMock = (Exception) Class.forName(exceptionJson.getString("name"))
                        .getConstructor(String.class).newInstance(exceptionJson.getString("message"));
                when(objectMapper.readValue(any(byte[].class), any(Class.class))).thenThrow(exceptionMock);
                try {
                    // 执行待测试的方法逻辑
                    csfMessageListener.createSecurityGroup(message, null);
                    fail();
                } catch (Exception e) {
                    // 获取期待的异常
                    JSONObject expectedException = testCase.getExceptFailureResult("exceptions", 0, JSONObject.class);
                    Assert.assertEquals(expectedException.getString("name"), e.getClass().getName());
                }
            }
        }
    }
...
}