JUnit5学习之一：基本操做

时间  2021-02-19
标签 java git 程序员 github web spring 数据库 apache 编程 api 栏目 Java 繁體版
原文   原文链接

欢迎访问个人GitHub

https://github.com/zq2599/blog_demosjava

内容：全部原创文章分类汇总及配套源码，涉及Java、Docker、Kubernetes、DevOPS等；git

关于《JUnit5学习》系列

《JUnit5学习》系列旨在经过实战提高SpringBoot环境下的单元测试技能，一共八篇文章，连接以下：程序员

  1. 基本操做
  2. Assumptions类
  3. Assertions类
  4. 按条件执行
  5. 标签(Tag)和自定义注解
  6. 参数化测试(Parameterized Tests)基础
  7. 参数化测试(Parameterized Tests)进阶
  8. 综合进阶（终篇）

本篇概览

本文是《JUnit5学习》系列的第一篇，经过实战学习在SpringBoot框架下JUnit5的基本功能，全篇章节以下：github

  1. JUnit5简介
  2. SpringBoot对JUnit5的依赖
  3. 经常使用注解简介
  4. 5版本已废弃的注解介绍
  5. 进入实战环节，先介绍版本和环境信息
  6. 建立《JUnit5学习》系列源码的父工程
  7. 建立子工程，编码体验经常使用注解

关于JUnit5

  1. JUnit是经常使用的java单元测试框架，<font color="blue">5</font>是当前最新版本，其总体架构以下(图片来自网络)：

在这里插入图片描述

  1. 从上图可见，整个JUnit5能够划分红三层：顶层框架(Framework)、中间的引擎（Engine），底层的平台（Platform）；
  2. 官方定义JUnit5由三部分组成：Platform、Jupiter、Vintage，功能以下；
  3. Platform：位于架构的最底层，是JVM上执行单元测试的基础平台，还对接了各类IDE（例如IDEA、eclipse），而且还与引擎层对接，定义了引擎层对接的API；
  4. Jupiter：位于引擎层，支持5版本的编程模型、扩展模型；
  5. Vintage：位于引擎层，用于执行低版本的测试用例；
  • 可见整个Junit Platform是开放的，经过引擎API各类测试框架均可以接入；

SpringBoot对JUnit5的依赖

  1. 这里使用SpringBoot版本为<font color="blue">2.3.4.RELEASE</font>，在项目的pom.xml中依赖JUnit5的方法以下：
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
  1. 以下图红框，可见JUnit5的jar都被<font color="blue">spring-boot-starter-test</font>间接依赖进来了：

在这里插入图片描述

曾经的RunWith注解

  1. 在使用JUnit4的时候，我们常常这么写单元测试类：
@RunWith(SpringRunner.class)
@SpringBootTest
public class XXXTest {
  1. 对于上面的RunWith注解，JUnit5官方文档的说法以下图红框所示，已经被<font color="blue">ExtendWith</font>取代：

在这里插入图片描述

  1. 我们再来看看SpringBootTest注解，以下图，可见已经包含了<font color="blue">ExtendWith</font>：

在这里插入图片描述

  1. 综上所述，SpringBoot+JUnit5时，RunWith注解已经不须要了，正常状况下仅SpringBootTest注解便可，若是对扩展性有更多需求，能够添加ExtendWith注解，以下图：

在这里插入图片描述

经常使用的JUnit5注解(SpringBoot环境)

注意，接下来提到的<font color="red">测试方法</font>，是指当前class中全部被@Test、@RepeatedTest、@ParameterizedTest、@TestFactory修饰的方法；web

  1. ExtendWith：这是用来取代旧版本中的RunWith注解，不过在SpringBoot环境若是没有特别要求无需额外配置，由于SpringBootTest中已经有了；
  2. Test：被该注解修饰的就是测试方法；
  3. BeforeAll：被该注解修饰的必须是静态方法，会在全部测试方法以前执行，会被子类继承，取代低版本的BeforeClass；
  4. AfterAll：被该注解修饰的必须是静态方法，会在全部测试方法执行以后才被执行，会被子类继承，取代低版本的AfterClass；
  5. BeforeEach：被该注解修饰的方法会在每一个测试方法执行前被执行一次，会被子类继承，取代低版本的Before；
  6. AfterEach：被该注解修饰的方法会在每一个测试方法执行后被执行一次，会被子类继承，取代低版本的Before；
  7. DisplayName：测试方法的展示名称，在测试框架中展现，支持emoji；
  8. Timeout：超时时长，被修饰的方法若是超时则会致使测试不经过；
  9. Disabled：不执行的测试方法；

5版本已废弃的注解

如下的注解都是在5以前的版本使用的，如今已经被废弃：spring

被废弃的注解 新的继任者
Before BeforeEach
After AfterEach
BeforeClass BeforeAll
AfterClass AfterAll
Category Tag
RunWith ExtendWith
Rule ExtendWith
ClassRule RegisterExtension

版本和环境信息

整个系列的编码和执行在如下环境进行，供您参考：数据库

  1. 硬件配置：处理器i5-8400，内存32G，硬盘128G SSD + 500G HDD
  2. 操做系统：Windows10家庭中文版
  3. IDEA：2020.2.2 (Ultimate Edition)
  4. JDK：1.8.0_181
  5. SpringBoot：2.3.4.RELEASE
  6. JUnit Jupiter：5.6.2

接下来开始实战，我们先建好SpringBoot项目；apache

关于lombok

为了简化代码，项目中使用了lombok，请您在IDEA中安装lombok插件；编程

源码下载

  1. 若是您不想编码，能够在GitHub下载全部源码，地址和连接信息以下表所示(https://github.com/zq2599/blo...：
名称 连接 备注
项目主页 https://github.com/zq2599/blo... 该项目在GitHub上的主页
git仓库地址(https) https://github.com/zq2599/blo... 该项目源码的仓库地址，https协议
git仓库地址(ssh) git@github.com:zq2599/blog_demos.git 该项目源码的仓库地址，ssh协议
  1. 这个git项目中有多个文件夹，本章的应用在<font color="blue">junitpractice</font>文件夹下，以下图红框所示：

在这里插入图片描述

  1. <font color="blue">junitpractice</font>是父子结构的工程，本篇的代码在<font color="red">junit5experience</font>子工程中，以下图：

在这里插入图片描述

建立Maven父工程

  1. 为了便于管理整个系列的源码，在此创建名为<font color="blue">junitpractice</font>的maven工程，后续全部实战的源码都做为junitpractice的子工程；
  2. junitpractice的pom.xml以下，可见是以SpringBoot的<font color="blue">2.3.4.RELEASE</font>版本做为其父工程：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <modules>
        <module>simplebean</module>
        <!--
        <module>testenvironment</module>
        -->
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.bolingcavalry</groupId>
    <artifactId>junitpractice</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.16.16</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

本篇的源码工程

接下来我们准备一个简单的SpringBoot工程用于作单元测试，该工程有service和controller层，包含一些简单的接口和类；api

  1. 建立名为<font color="blue">junit5experience</font>的子工程，pom.xml以下，注意单元测试要依赖<font color="blue">spring-boot-starter-test</font>：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.bolingcavalry</groupId>
        <artifactId>junitpractice</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>
    <groupId>com.bolingcavalry</groupId>
    <artifactId>junit5experience</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>junit5experience</name>
    <description>Demo project for simplebean in Spring Boot junit5</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
  1. 写一些最简单的业务代码，首先是service层的接口HelloService.java：
package com.bolingcavalry.junit5experience.service;

public interface HelloService {
    String hello(String name);
    int increase(int value);
    /**
     * 该方法会等待1秒后返回true，这是在模拟一个耗时的远程调用
     * @return
     */
    boolean remoteRequest();
}
  1. 上述接口对应的实现类以下，hello和increase方法分别返回String型和int型，remoteRequest故意sleep了1秒钟，用来测试Timeout注解的效果：
package com.bolingcavalry.junit5experience.service.impl;

import com.bolingcavalry.junit5experience.service.HelloService;
import org.springframework.stereotype.Service;

@Service()
public class HelloServiceImpl implements HelloService {
    @Override
    public String hello(String name) {
        return "Hello " + name;
    }

    @Override
    public int increase(int value) {
        return value + 1;
    }

    @Override
    public boolean remoteRequest() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException interruptedException) {
            interruptedException.printStackTrace();
        }

        return true;
    }
}
  1. 添加一个简单的controller：
package com.bolingcavalry.junit5experience.controller;

import com.bolingcavalry.junit5experience.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @Autowired
    private HelloService helloService;

    @RequestMapping(value = "/{name}", method = RequestMethod.GET)
    public String hello(@PathVariable String name){
        return helloService.hello(name);
    }
}
  1. 启动类：
package com.bolingcavalry.junit5experience;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Junit5ExperienceApplication {

    public static void main(String[] args) {
        SpringApplication.run(Junit5ExperienceApplication.class, args);
    }
}
  • 以上就是一个典型的web工程，接下来一块儿为该工程编写单元测试用例；

编写测试代码

  1. 在下图红框位置新增单元测试类：

在这里插入图片描述

  1. 测试类的内容以下，涵盖了刚才提到的经常使用注解，请注意每一个方法的注释说明：
package com.bolingcavalry.junit5experience.service.impl;

import com.bolingcavalry.junit5experience.service.HelloService;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.TimeUnit;
import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest
@Slf4j
class HelloServiceImplTest {

    private static final String NAME = "Tom";

    @Autowired
    HelloService helloService;

    /**
     * 在全部测试方法执行前被执行
     */
    @BeforeAll
    static void beforeAll() {
        log.info("execute beforeAll");
    }

    /**
     * 在全部测试方法执行后被执行
     */
    @AfterAll
    static void afterAll() {
        log.info("execute afterAll");
    }

    /**
     * 每一个测试方法执行前都会执行一次
     */
    @BeforeEach
    void beforeEach() {
        log.info("execute beforeEach");
    }

    /**
     * 每一个测试方法执行后都会执行一次
     */
    @AfterEach
    void afterEach() {
        log.info("execute afterEach");
    }

    @Test
    @DisplayName("测试service层的hello方法")
    void hello() {
        log.info("execute hello");
        assertThat(helloService.hello(NAME)).isEqualTo("Hello " + NAME);
    }

    /**
     * DisplayName中带有emoji，在测试框架中可以展现
     */
    @Test
    @DisplayName("测试service层的increase方法\uD83D\uDE31")
    void increase() {
        log.info("execute increase");
        assertThat(helloService.increase(1)).isEqualByComparingTo(2);
    }

    /**
     * 不会被执行的测试方法
     */
    @Test
    @Disabled
    void neverExecute() {
        log.info("execute neverExecute");
    }

    /**
     * 调用一个耗时1秒的方法，用Timeout设置超时时间是500毫秒，
     * 所以该用例会测试失败
     */
    @Test
    @Timeout(unit = TimeUnit.MILLISECONDS, value = 500)
    @Disabled
    void remoteRequest() {
        assertThat(helloService.remoteRequest()).isEqualTo(true);
    }
}
  1. 接下来执行测试用例试试，点击下图红框中的按钮：

在这里插入图片描述

  1. 以下图，在弹出的菜单中，点击红框位置：

在这里插入图片描述

  1. 执行结果以下，可见Displayname注解的值做为测试结果的方法名展现，超时的方法会被断定为测试不经过，Disable注解修饰的方法则被标记为跳过不执行：

在这里插入图片描述

  1. 在父工程junitpractice的pom.xml文件所在目录，执行<font color="blue">mvn test</font>命令，能够看到maven执行单元测试的效果：

在这里插入图片描述

  • 至此，我们对SpringBoot环境下的JUnit5有了最基本的了解，接下来的章节会展开更多知识点和细节，对单元测试作更深刻的学习。

你不孤单，欣宸原创一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 数据库+中间件系列
  6. DevOps系列

欢迎关注公众号：程序员欣宸

微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界...
https://github.com/zq2599/blog_demos
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程