✨这里是第七人格的博客✨小七，欢迎您的到来~✨

🍅系列专栏:【架构思想】🍅

✈️本篇内容: 写给想入门单元测试的你✈️

🍱本篇收录完整代码地址：gitee.com/diqirenge/s…🍱

一、为什么要进行单元测试

首先我们来看一下标准的软件开发流程是什么样的

从图中我们可以看到，单元测试作为开发流程中的重要一环，其实是保证代码健壮性的重要一环，但是因为各种各样的原因，在日常开发中，我们往往不重视这一步，不写或者写的不太规范。那为什么要进行单元测试呢？小七觉得有以下几点：

• 
  
• 便于后期重构。单元测试可以为代码的重构提供保障，只要重构代码之后单元测试全部运行通过，那么在很大程度上表示这次重构没有引入新的BUG，当然这是建立在完整、有效的单元测试覆盖率的基础上。
  
• 优化设计。编写单元测试将使用户从调用者的角度观察、思考，特别是使用TDD驱动开发的开发方式，会让使用者把程序设计成易于调用和可测试，并且解除软件中的耦合。
  
• 文档记录。单元测试就是一种无价的文档，它是展示函数或类如何使用的最佳文档，这份文档是可编译、可运行的、并且它保持最新，永远与代码同步。
  
• 具有回归性。自动化的单元测试避免了代码出现回归，编写完成之后，可以随时随地地快速运行测试，而不是将代码部署到设备之后，然后再手动地覆盖各种执行路径，这样的行为效率低下，浪费时间。
  

不少同学，写单元测试，就是直接调用的接口方法，就跟跑swagger和postMan一样，这样只是对当前方法有无错误做了一个验证，无法构成单元测试网络。

比如下面这种代码

@Test
public void Test1(){

    xxxService.doSomeThing();

}

接下来小七就和大家探讨一下如何写好一个简单的单元测试。

小七觉得写好一个单元测试应该要注意以下几点：

1、单元测试是主要是关注测试方法的逻辑，而不仅仅是结果。

2、需要测试的方法，不应该依赖于其他的方法，也就是说每一个单元各自独立。

3、无论执行多少次，其结果是一定的不变的，也就是单元测试需要有幂等性。

4、单元测试也应该迭代维护。

二、单元测试需要引用的jar包

针对springboot项目，咱们只需要引用他的starter即可

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>2.1.0.RELEASE</version>
</dependency>

下面贴出这个start包含的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starters</artifactId>
<version>2.1.0.RELEASE</version>
</parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<version>2.1.0.RELEASE</version>
<name>Spring Boot Test Starter</name>
<description>Starter for testing Spring Boot applications with libraries including

      JUnit, Hamcrest and Mockito</description>
<url>https://projects.spring.io/spring-boot/#/spring-boot-parent/spring-boot-starters/spring-boot-starter-test</url>
<organization>
<name>Pivotal Software, Inc.</name>
<url>https://spring.io</url>
</organization>
<licenses>
<license>
<name>Apache License, Version 2.0</name>
<url>http://www.apache.org/licenses/LICENSE-2.0</url>
</license>
</licenses>
<developers>
<developer>
<name>Pivotal</name>
<email>info@pivotal.io</email>
<organization>Pivotal Software, Inc.</organization>
<organizationUrl>http://www.spring.io</organizationUrl>
</developer>
</developers>
<scm>
<connection>scm:git:git://github.com/spring-projects/spring-boot.git/spring-boot-starters/spring-boot-starter-test</connection>
<developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-boot.git/spring-boot-starters/spring-boot-starter-test</developerConnection>
<url>http://github.com/spring-projects/spring-boot/spring-boot-starters/spring-boot-starter-test</url>
</scm>
<issueManagement>
<system>Github</system>
<url>https://github.com/spring-projects/spring-boot/issues</url>
</issueManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.1.0.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-test</artifactId>
<version>2.1.0.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-test-autoconfigure</artifactId>
<version>2.1.0.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
<version>2.4.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
<version>3.11.1</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-core</artifactId>
<version>2.23.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-core</artifactId>
<version>1.3</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-library</artifactId>
<version>1.3</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.skyscreamer</groupId>
<artifactId>jsonassert</artifactId>
<version>1.5.0</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.1.2.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.2.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.xmlunit</groupId>
<artifactId>xmlunit-core</artifactId>
<version>2.6.2</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>

三、单元测试解析与技巧

1、单元测试类注解解析

下面是出现频率极高的注解：

/*

 * 这个注解的作用是，在执行单元测试的时候，不是直接去执行里面的单元测试的方法

 * 因为那些方法执行之前，是需要做一些准备工作的，它是需要先初始化一个spring容器的

 * 所以得找这个SpringRunner这个类，来先准备好spring容器，再执行各个测试方法

 */
@RunWith(SpringRunner.class) 
/*

 * 这个注解的作用是，去寻找一个标注了@SpringBootApplication注解的一个类，也就是启动类

 * 然后会执行这个启动类的main方法，就可以创建spring容器，给后面的单元测试提供完整的这个环境

 */
@SpringBootTest
/*

 * 这个注解的作用是，可以让每个方法都是放在一个事务里面

 * 让单元测试方法执行的这些增删改的操作，都是一次性的

 */
@Transactional 
/*

 * 这个注解的作用是，如果产生异常那么会回滚，保证数据库数据的纯净

 * 默认就是true

 */
@Rollback(true)

2、常用断言

Junit所有的断言都包含在 Assert 类中。

3、有返回值方法的测试

@Test
public void haveReturn() {
// 1、初始化数据
// 2、模拟行为
// 3、调用方法
// 4、断言

}

4、无返回值方法的测试

@Test
public void noReturn() {
// 1、初始化数据
// 2、模拟行为
// 3、调用方法
// 4、验证执行次数

}

四、单元测试小例

以常见的SpringMVC3层架构为例，咱们分别展示3层架构如何做简单的单元测试。业务场景为用户user的增删改查。

（1）dao层的单元测试

dao层一般是持久化层，也就是与数据库打交道的一层，单元测试尽量不要依赖外部，但是直到最后一层的时候，DAO层的时候，还是要依靠开发环境里的基础设施，来进行单元测试。

@RunWith(SpringRunner.class)
@SpringBootTest
@Transactional
@Rollback
public class UserMapperTest {

/**

     * 持久层，不需要使用模拟对象

     */
@Autowired
private UserMapper userMapper;

/**

     * 测试用例：查询所有用户信息

     */
@Test
public void testListUsers() {
// 初始化数据

        initUser(20);
// 调用方法

        List<User> resultUsers = userMapper.listUsers();
// 断言不为空

        assertNotNull(resultUsers);
// 断言size大于0

        Assert.assertThat(resultUsers.size(), is(greaterThanOrEqualTo(0)));

    }

/**

     * 测试用例：根据ID查询一个用户

     */
@Test
public void testGetUserById() {
// 初始化数据
User user = initUser(20);
Long userId = user.getId();
// 调用方法
User resultUser = userMapper.getUserById(userId);
// 断言对象相等

        assertEquals(user.toString(), resultUser.toString());

    }

/**

     * 测试用例：新增用户

     */
@Test
public void testSaveUser() {

        initUser(20);

    }

/**

     * 测试用例：修改用户

     */
@Test
public void testUpdateUser() {
// 初始化数据
Integer oldAge = 20;
Integer newAge = 21;
User user = initUser(oldAge);

        user.setAge(newAge);
// 调用方法
Boolean updateResult = userMapper.updateUser(user);
// 断言是否为真

        assertTrue(updateResult);
// 调用方法
User updatedUser = userMapper.getUserById(user.getId());
// 断言是否相等

        assertEquals(newAge, updatedUser.getAge());

    }

/**

     * 测试用例：删除用户

     */
@Test
public void testRemoveUser() {
// 初始化数据
User user = initUser(20);
// 调用方法
Boolean removeResult = userMapper.removeUser(user.getId());
// 断言是否为真

        assertTrue(removeResult);

    }

private User initUser(int i) {
// 初始化数据
User user = new User();

        user.setName("测试用户");

        user.setAge(i);
// 调用方法

        userMapper.saveUser(user);
// 断言id不为空

        assertNotNull(user.getId());
return user;

    }

}

（2）service层的单元测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceImplTest {

@Autowired
private UserService userService;

/**

    * 这个注解表名，该对象是个mock对象，他将替换掉你@Autowired标记的对象

    */
@MockBean
private UserMapper userMapper;

/**

    * 测试用例：查询所有用户信息

    */
@Test
public void testListUsers() {
// 初始化数据

      List<User> users = new ArrayList<>();

User user = initUser(1L);


      users.add(user);
// mock行为

      when(userMapper.listUsers()).thenReturn(users);
// 调用方法

      List<User> resultUsers = userService.listUsers();
// 断言是否相等

      assertEquals(users, resultUsers);

   }

/**

    * 测试用例：根据ID查询一个用户

    */
@Test
public void testGetUserById() {
// 初始化数据
Long userId = 1L;

User user = initUser(userId);
// mock行为

      when(userMapper.getUserById(userId)).thenReturn(user);
// 调用方法
User resultUser = userService.getUserById(userId);
// 断言是否相等

      assertEquals(user, resultUser);


   }

/**

    * 测试用例：新增用户

    */
@Test
public void testSaveUser() {
// 初始化数据
User user = initUser(1L);
// 默认的行为（这一行可以不写）

      doNothing().when(userMapper).saveUser(any());
// 调用方法

      userService.saveUser(user);
// 验证执行次数

      verify(userMapper, times(1)).saveUser(user);


   }

/**

    * 测试用例：修改用户

    */
@Test
public void testUpdateUser() {
// 初始化数据
User user = initUser(1L);
// 模拟行为

      when(userMapper.updateUser(user)).thenReturn(true);
// 调用方法
Boolean updateResult = userService.updateUser(user);
// 断言是否为真

      assertTrue(updateResult); 

   }

/**

    * 测试用例：删除用户

    */
@Test
public void testRemoveUser() {
Long userId = 1L;
// 模拟行为

      when(userMapper.removeUser(userId)).thenReturn(true);
// 调用方法
Boolean removeResult = userService.removeUser(userId);
// 断言是否为真

      assertTrue(removeResult);

   }

private User initUser(Long userId) {
User user = new User();

      user.setName("测试用户");

      user.setAge(20);

      user.setId(userId);
return user;

   }


}

（3）controller层的单元测试

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class UserControllerTest {

private MockMvc mockMvc;

@InjectMocks
private UserController userController;

@MockBean
private UserService userService;

/**

    * 前置方法，一般执行初始化代码

    */
@Before
public void setup() {


      MockitoAnnotations.initMocks(this);

this.mockMvc = MockMvcBuilders.standaloneSetup(userController).build();

   }

/**

    * 测试用例：查询所有用户信息

    */
@Test
public void testListUsers() {
try {

         List<User> users = new ArrayList<User>();

User user = new User();

         user.setId(1L);

         user.setName("测试用户");  

         user.setAge(20);


         users.add(user);


         when(userService.listUsers()).thenReturn(users);


         mockMvc.perform(get("/user/"))

               .andExpect(content().json(JSONArray.toJSONString(users))); 

      } catch (Exception e) {

         e.printStackTrace(); 

      }

   }

/**

    * 测试用例：根据ID查询一个用户

    */
@Test
public void testGetUserById() {
try {
Long userId = 1L;

User user = new User();

         user.setId(userId);

         user.setName("测试用户");  

         user.setAge(20);


         when(userService.getUserById(userId)).thenReturn(user);


         mockMvc.perform(get("/user/{id}", userId))  

               .andExpect(content().json(JSONObject.toJSONString(user)));

      } catch (Exception e) {

         e.printStackTrace(); 

      }

   }

/**

    * 测试用例：新增用户

    */
@Test
public void testSaveUser() {
Long userId = 1L;

User user = new User();

      user.setName("测试用户");  

      user.setAge(20);


      when(userService.saveUser(user)).thenReturn(userId);

try {

         mockMvc.perform(post("/user/").contentType("application/json").content(JSONObject.toJSONString(user)))

               .andExpect(content().string("success"));

      } catch (Exception e) {

         e.printStackTrace(); 

      }

   }

/**

    * 测试用例：修改用户

    */
@Test
public void testUpdateUser() {
Long userId = 1L;

User user = new User();

      user.setId(userId); 

      user.setName("测试用户");  

      user.setAge(20);


      when(userService.updateUser(user)).thenReturn(true);

try {

         mockMvc.perform(put("/user/{id}", userId).contentType("application/json").content(JSONObject.toJSONString(user)))  

               .andExpect(content().string("success"));     

      } catch (Exception e) {

         e.printStackTrace(); 

      }

   }

/**

    * 测试用例：删除用户

    */
@Test
public void testRemoveUser() {
Long userId = 1L;


      when(userService.removeUser(userId)).thenReturn(true);  

try {

         mockMvc.perform(delete("/user/{id}", userId))   

               .andExpect(content().string("success"));     

      } catch (Exception e) {

         e.printStackTrace(); 

      }

   }


}

五、其他

1、小七认为不需要对私有方法进行单元测试。

2、dubbo的接口，在初始化的时候会被dubbo的类代理，和单测的mock是两个类，会导致mock失效，目前还没有找到好的解决方案。

3、单元测试覆盖率报告

（1）添加依赖

<dependency>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.2</version>
</dependency>

（2）添加插件

<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.2</version>
<executions>
<execution>
<id>pre-test</id>
<goals>
<goal>prepare-agent</goal>
</goals>
</execution>
<execution>
<id>post-test</id>
<phase>test</phase>
<goals>
<goal>report</goal>
</goals>
</execution>
</executions>
</plugin>

（3）执行mvn test命令

报告生成位置

4、异常测试

本次分享主要是针对正向流程，异常情况未做处理。感兴趣的同学可以查看附录相关文档自己学习。

六、附录

1、user建表语句：

CREATE TABLE `user` (

  `id` INT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT '主键',

  `name` VARCHAR(32) NOT NULL UNIQUE COMMENT '用户名',

  `age` INT(3) NOT NULL COMMENT '年龄'

) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='user示例表';

2、文章小例源码地址：gitee.com/diqirenge/s…

3、mockito官网：site.mockito.org/

4、mockito中文文档：github.com/hehonghui/m…