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

小伙子vae
6,408 阅读9分钟

源码下载

本章源码下载

注解相关

@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 这个类。
注解名称注解描述
@SpringBootTestSpring Boot 应用程序专用的测试注解
@RunWithJUnit 框架提供的用于设置测试运行器的基础注解
@TestJUnit 中使用的基础测试注解，用来表明需要执行的测试用例
@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 容器并没有真实启动。

测试实战

前提

  1. 初始化数据
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');
  1. 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自动帮助我们在不同的环境运行不同的配置文件

image.png

  1. 实体类
/**
 * @Description: 实体类
 * GenerationType:
 * TABLE：使用一个特定的数据库表格来保存主键。
 * SEQUENCE：根据底层数据库的序列来生成主键，条件是数据库支持序列。
 * IDENTITY：主键由数据库自动生成（主要是自动增长型）
 * AUTO：主键由程序控制选择上面的一个策略。
 * @Author: jianweil
 * @date: 2021/11/22 17:29
 */
@Entity
@AllArgsConstructor
@NoArgsConstructor
@Data
//@Proxy(lazy = false)
public class User {
    @Id
    //配置了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

  1. 测试持久化类我们一般使用@DataJpaTest+@RunWith(SpringRunner.class)注解
  2. @DataJpaTest 注解会自动注入各种 Repository 类，并初始化一个内存数据库和及访问该数据库的数据源。
  3. 在测试场景下，用@DataJpaTest 注解的测试使用嵌入式内存数据库。我们可以使用 H2 作为内存数据库
  4. 它与@RunWith（SpringRunner.class）结合使用。 该注解会禁用完全自动配置，并且仅应用与 JPA 测试相关的配置。
  5. 由于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机制模拟数据

  1. Mock 机制就是使用 Mock 对象替代真实的依赖对象，并模拟真实场景来开展测试工作。
  2. @SpringBootTest 注解中的 SpringBootTest.WebEnvironment.MOCK 选项，该选项用于加载WebApplicationContext 并提供一个 Mock 的 Servlet 环境，内置的 Servlet 容器并没有真实启动。
  3. 首先，我们通过 @MockBean 注解注入了 userRepository，即是告诉程序我准备虚拟这个类
  4. 然后，基于第三方 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

  1. @SpringBootTest 注解通过使用 SpringBootTest.WebEnvironment.RANDOM_PORT 指定了随机端口的 Web 运行环境。
  2. 如果我们想在测试环境中使用 @SpringBootTest，则可以直接使用 TestRestTemplate 来测试远程访问过程
  3. 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

  1. 在使用 @SpringBootTest 注解的场景下，如果我们想使用 MockMvc 对象，那么可以引入 @AutoConfigureMockMvc 注解。
  2. 通过将 @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

  1. @SpringBootTest 注解不能和 @WebMvcTest 注解同时使用
  2. @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());
    }
}
avatar
文章
阅读
粉丝
相关推荐
一、IDEA 2022 中Maven创建SpringBoot项目流程
982阅读
 · 
1点赞
SpringBoot整合Redis--让你的项目`快`起来吧！Redis实战（三）｜Java 开发实战
4.9k阅读
 · 
90点赞
MongoDB：我知道你很爱我
689阅读
 · 
15点赞
SpringBoot整合Mybatis详细流程
5.8k阅读
 · 
20点赞
Oracle存储过程、函数、包的使用
2.3k阅读
 · 
6点赞
使用IDEA搭建maven web 项目详解
787阅读
 · 
1点赞
Spring Boot单元测试入门实战
12k阅读
 · 
7点赞
springboot第7集：控制反转(IoC)与依赖注入(DI)
317阅读
 · 
2点赞
java---redis基础操作
2.1k阅读
 · 
62点赞

友情链接：