单元测试不再怕！一文学会SpringBoot单元测试

@SpringBootTest

SpringBoot应用程序专用的测试注解，SpringBoot程序的入口是Bootstrap类，所以SpringBoot专门提供了一个@SpringBootTest注解测试Bootstrap类。该注解也可以


    引用Bootstrap类的配置

，因为所有配置都会通过Bootstrap类去加载。

在 Spring Boot 中，@SpringBootTest 注解主要用于测试基于


    自动配置

的 ApplicationContext，它允许我们设置测试上下文中的 Servlet 环境。

@SpringBootTest注解中的webEnvironment可以有四个选项：


    MOCK

：加载 WebApplicationContext 并提供一个 Mock 的 Servlet 环境，此时内置的 Servlet 容器并没有正式启动。


    RANDOM_PORT

：加载 EmbeddedWebApplicationContext 并提供一个真实的 Servlet 环境，然后使用一个随机端口启动内置容器。


    DEFINED_PORT

：这个配置也是通过加载 EmbeddedWebApplicationContext 提供一个真实的 Servlet 环境，但使用的是默认端口，如果没有配置端口就使用 8080。


    NONE

：加载 ApplicationContext 但并不提供任何真实的 Servlet 环境。

在多数场景下，一个真实的 Servlet 环境对于测试而言过于重量级，通过


    MOCK

环境则可以缓解这种环境约束所带来的困扰

@RunWith注解与SpringRunner

JUnit框架提供的用于


    设置测试运行器

的基础注解。

我们可以通过 @RunWith(SpringRunner.class) 让测试运行于


    Spring

测试环境。


    SpringRunner 继承 SpringJUnit4ClassRunner

其实他们是一样的，就是运行在spring环境，它允许 JUnit 和 Spring TestContext 整合运行，而 Spring TestContext 则提供了用于测试 Spring 应用程序的各项通用的支持功能。

@Test

JUnit 中使用的基础测试注解，用来表明需要执行的测试用例

@DataJpaTest

专门用于测试


    关系型数据库

的测试注解

@DataJpaTest 注解会


    自动注入

各种


    Repository 类

，即是


    持久化bean

，并初始化一个


    内存数据库

和及访问该数据库的数据源。

在测试场景下，一般我们可以使用

H2

作为内存数据库，并通过 MySQL 实现数据持久化

@MockBean

用于实现Mock机制的测试注解

自动用 Mockito 模拟替换应用程序上下文中相同类型的 bean。

@WebMvcTest

在 Web 容器环境中嵌入 MockMvc 的注解


    @SpringBootTest 注解不能和 @WebMvcTest 注解同时使用。

该注解将初始化测试 Controller 所必需的 Spring MVC 基础设施


    controllers

参数设置为


    XxxController.class

，告诉 Spring Boot 将为此测试创建的应用程序上下文限制为


    给定

的控制器 bean 和


    该bean

相关的一些 Spring Web MVC 所需的一些框架 bean。

MockMvc类提供的基础方法分为以下6 种


    Perform

：执行一个 RequestBuilder 请求，会自动执行 SpringMVC 流程并映射到相应的 Controller 进行处理。


    get/post/put/delete

：声明发送一个 HTTP 请求的方式，根据 URI 模板和 URI 变量值得到一个 HTTP 请求，支持 GET、POST、PUT、DELETE 等 HTTP 方法。


    param

：添加请求参数，发送 JSON 数据时将不能使用这种方式，而应该采用 @ResponseBody 注解。


    andExpect

：添加 ResultMatcher 验证规则，通过对返回的数据进行判断来验证 Controller 执行结果是否正确。


    andDo

：添加 ResultHandler 结果处理器，比如调试时打印结果到控制台。


    andReturn

：最后返回相应的 MvcResult，然后执行自定义验证或做异步处理。

@AutoConfigureMockMvc

@AutoConfigureMockMvc与@SpringBootTest


    组合

嵌入MockMvc的注解，在使用 @SpringBootTest 注解的场景下，如果我们想使用 MockMvc 对象，那么可以引入 @AutoConfigureMockMvc 注解。

通过将 @SpringBootTest 注解与 @AutoConfigureMockMvc 注解相结合，@AutoConfigureMockMvc 注解将通过 @SpringBootTest 加载的 Spring 上下文环境中


    自动配置

MockMvc 这个类。

注解名称	注解描述
@SpringBootTest	Spring Boot 应用程序专用的测试注解
@RunWith	JUnit 框架提供的用于设置测试运行器的基础注解
@Test	JUnit 中使用的基础测试注解，用来表明需要执行的测试用例
@DataJpaTest	专门用于测试关系型数据库的测试注解
@MockBea	用于实现 Mock 机制的测试注解
@WebMvcTest	在 Web 容器环境中嵌入 MockMvc 的注解
@AutoConfigureMockMvc	与@SpringBootTest组合嵌入MockMvc的注解

TestEntityManager

它的效果相当于


    不使用真正

的 XxxRepository（即是持久化bean）完成数据的持久化，从而提供了一种数据与环境之间的隔离机制。

TestRestTemplate

Spring Boot 提供的 TestRestTemplate 发起请求的方式与 RestTemplate


    完全一致

，只不过它专门用在


    测试环境

中。

如果我们想在测试环境中使用 @SpringBootTest，则可以直接使用 TestRestTemplate 来测试远程访问过程

@SpringBootTest 注解通过使用 SpringBootTest.WebEnvironment.


    RANDOM_PORT

指定了


    随机端口

的 Web 运行环境。然后，我们基于 TestRestTemplate 发起了 HTTP 请求并验证了结果。

Mock 机制

Mock 的意思是模拟，它可以用来对系统、组件或类进行隔离。

在测试过程中，我们通常关注测试对象本身的功能和行为，而对测试对象涉及的一些依赖，仅仅关注它们与测试对象之间的交互（比如是否调用、何时调用、调用的参数、调用的次数和顺序，以及返回的结果或发生的异常等），并不关注这些被依赖对象如何执行这次调用的具体细节。因此，Mock 机制就是使用


    Mock 对象替代真实的依赖对象

，并模拟真实场景来开展测试工作

@SpringBootTest 注解中的 SpringBootTest.WebEnvironment.


    MOCK

选项，该选项用于加载WebApplicationContext 并提供一个 Mock 的 Servlet 环境，内置的 Servlet 容器


    并没有真实启动

。

初始化数据

DELETE FROM user;
INSERT INTO user (id, name, age, email)
VALUES (1, 'Jone', 18, 'test1@baomidou.com'),
       (2, 'Jack', 20, 'test2@baomidou.com'),
       (3, 'Tom', 28, 'test3@baomidou.com'),
       (4, 'Sandy', 21, 'test4@baomidou.com'),
       (5, 'Billie', 24, 'test5@baomidou.com');
pom依赖
<!--我们需要一个web应用-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--简化-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>
<!-- springboot测试模块-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!-- 我们希望在测试环境时候能把数据库环境隔离，用内存数据库-->
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>
<!--我们希望开发环境时候使用 mysql数据库-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!-- 持久化框架-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- junit测试组件-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
</dependency>
注意：在src/main/resources/下放置mysql的配置，而在src/test/resources/下放置h2的配置，springboot自动帮助我们在不同的环境运行不同的配置文件
 * @Description: 实体类
 * GenerationType:
 * TABLE：使用一个特定的数据库表格来保存主键。
 * SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
 * IDENTITY：主键由数据库自动生成（主要是自动增长型）
 * AUTO：主键由程序控制选择上面的一个策略。
 * @Author: jianweil
 * @date: 2021/11/22 17:29
@Entity
@AllArgsConstructor
@NoArgsConstructor
@Data
//@Proxy(lazy = false)
public class User {
    //配置了h2GenerationType.AUTO程序帮助我们使用了GenerationType.SEQUENCE
    //@GeneratedValue(strategy = GenerationType.AUTO)
    //序列化
    //@GeneratedValue(strategy = GenerationType.SEQUENCE)
    // https://www.cnblogs.com/hongchengshise/p/10612301.html
    //数据库自增
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column
    private String name;
    @Column
    private Integer age;
    @Column
    private String email;
测试持久层-dao
方法1. @DataJpaTest
测试持久化类我们一般使用@DataJpaTest+@RunWith(SpringRunner.class)注解
@DataJpaTest 注解会自动注入各种 Repository 类，并初始化一个内存数据库和及访问该数据库的数据源。
在测试场景下，用@DataJpaTest 注解的测试使用嵌入式内存数据库。我们可以使用 H2 作为内存数据库
它与@RunWith（SpringRunner.class）结合使用。 该注解会禁用完全自动配置，并且仅应用与 JPA 测试相关的配置。
由于H2启动初始化5条记录到内存数据库，所以user1插入的id为6
@RunWith(SpringRunner.class)
@DataJpaTest
public class TestDao {
     * 效果相当于不使用真正的 UserRepository 完成数据的持久化，从而提供了一种数据与环境之间的隔离机制。
    @Autowired
    private TestEntityManager entityManager;
    @Autowired
    private UserRepository userRepository;
     * @throws Exception
    @Test
    public void testGetById() throws Exception {
        String expected = "new6@qq.com";
        User user1 = new User();
        user1.setName("new6");
        user1.setAge(6);
        user1.setEmail(expected);
        //User user3 = this.userRepository.save(user1);
        //User的id自增策略 IDENTITY策略：用初始化好数据的h2数据库保存 id=6
        //User的id自增策略 SEQUENCE策略：使用新的空的h2数据库保存 id=1
        //与上面效果一样
        this.entityManager.persist(user1);
        User user2 = new User();
        user2.setName("new7");
        user2.setAge(7);
        user2.setEmail("new7@qq.com");
        //User user4 = this.userRepository.save(user2);
        this.entityManager.persist(user2);
        User user6 = this.userRepository.getById(6L);
        User user7 = this.userRepository.getById(7L);
        Assert.assertNotNull(user6);
        Assert.assertEquals(expected, user6.getEmail());
        Assert.assertEquals("new7@qq.com", user7.getEmail());
测试业务层-Service
方法1. 使用Mock机制模拟数据
Mock 机制就是使用 Mock 对象替代真实的依赖对象，并模拟真实场景来开展测试工作。
@SpringBootTest 注解中的 SpringBootTest.WebEnvironment.MOCK 选项，该选项用于加载WebApplicationContext 并提供一个 Mock 的 Servlet 环境，内置的 Servlet 容器并没有真实启动。
首先，我们通过 @MockBean 注解注入了 userRepository，即是告诉程序我准备虚拟这个类
然后，基于第三方 Mock 框架 Mockito 提供的 when/thenReturn 机制完成了对 userRepository 中 getById() 方法的 Mock。即是告诉程序我虚拟这个类的这个方法了，你不要去真实数据库查了，用我这个返回
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
public class TestServiceMock {
     * @MockBean使数据隔离
    @MockBean
    private UserRepository userRepository;
    @Resource
    private UserService userService;
    @Test
    public void testGetById() throws Exception {
        Long id = 22L;
        //用Mock构建测试方法userService.findById(22L)需要的userRepository.getById(id)的数据，
        Mockito.when(userRepository.getById(id)).thenReturn(new User(22L, "MockBean", 22, "MockBean@qq.com"));
        User user = userService.findById(22L);
        Assert.assertNotNull(user);
        Assert.assertEquals("MockBean", user.getName());
方法2. 直接测试数据库
如果你希望在测试用例中直接注入真实的userRepository，这时就可以使用@SpringBootTest 注解中的 SpringBootTest.WebEnvironment.RANDOM_PORT 选项
SpringBootTest.WebEnvironment.RANDOM_PORT：以一个随机的端口启动整个 Spring Boot 工程，并从数据库中(H2)真实获取目标数据进行验证。
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class TestServiceNoMock {
     * 注入真正数据库
    @Resource
    private UserService userService;
     * 报错没有seesion是jpa框架导致，解决有：
     * 1. 加事务注解  @Transactional
     * 2. 实体类加@Proxy(lazy = false)
     * 3. 配置文件加spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true
     * @throws Exception
    @Test
    @Transactional
    public void testGetById() throws Exception {
        Long id = 1L;
        User user = userService.findById(id);
        Assert.assertNotNull(user);
        Assert.assertEquals("Jone", user.getName());
测试控制层-Controller
方法1.@SpringBootTest+TestRestTemplate+ @MockBean
@SpringBootTest 注解通过使用 SpringBootTest.WebEnvironment.RANDOM_PORT 指定了随机端口的 Web 运行环境。
如果我们想在测试环境中使用 @SpringBootTest，则可以直接使用 TestRestTemplate 来测试远程访问过程
Spring Boot 提供的 TestRestTemplate 与 RestTemplate 非常类似，只不过它专门用在测试环境中。
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class TestController {
    @Autowired
    private TestRestTemplate testRestTemplate;
    @MockBean
    private UserService userService;
    @Test
    public void testGetById() throws Exception {
        Long userId = 1L;
        given(this.userService.findById(userId))
                .willReturn(new User(1L, "MockBean", 44, "MockBean@qq.com"));
        //postForObject是post请求
        ResponseEntity<User> responseEntity = testRestTemplate.exchange("/user/" + userId, HttpMethod.GET, null, User.class);
        Assert.assertEquals("MockBean@qq.com", responseEntity.getBody().getEmail());
方法2.@SpringBootTest+@AutoConfigureMockMvc+ @MockBean
在使用 @SpringBootTest 注解的场景下，如果我们想使用 MockMvc 对象，那么可以引入 @AutoConfigureMockMvc 注解。
通过将 @SpringBootTest 注解与 @AutoConfigureMockMvc 注解相结合，@AutoConfigureMockMvc 注解将通过 @SpringBootTest 加载的 Spring 上下文环境中自动配置 MockMvc 这个类。
@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class TestSpringBootTestController {
    @Autowired
    private MockMvc mvc;
     * 模拟的
    @MockBean
    private UserService userService;
    @Test
    public void testGetById() throws Exception {
        Long userId = 55L;
        //模拟实现
        given(this.userService.findById(userId))
                .willReturn(new User(55L, "MockBean", 55, "MockBean@qq.com"));
        this.mvc.perform(org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get("/user/" + userId).accept(MediaType.APPLICATION_JSON)).andExpect(status().isOk());
方法3.@WebMvcTest+@MockBean
@SpringBootTest 注解不能和 @WebMvcTest 注解同时使用
@WebMvcTest(UserController.class) 该注解将初始化测试 UserController 所必需的 Spring MVC 基础设施，即是相关bean，不是全部的bean都加载，如不写则Spring Boot 将在应用程序上下文中包含所有控制器。
@RunWith(SpringRunner.class)
@WebMvcTest(UserController.class)
public class TestWebMvcTestController {
    @Autowired
    private MockMvc mvc;
     * 模拟的
    @MockBean
    private UserService userService;
    @Test
    public void testGetById() throws Exception {
        Long userId = 55L;
        //模拟实现
        given(this.userService.findById(userId))
                .willReturn(new User(55L, "MockBean", 55, "TestWebMvcTestController@qq.com"));
        this.mvc.perform(get("/user/" + userId).accept(MediaType.APPLICATION_JSON)).andExpect(status().isOk());