首页 > 其他分享> 文章详细

SpringBoot单元测试

2021-07-20 09:02:01 阅读：237 来源： 互联网

标签：DisplayName SpringBoot void 单元测试测试 Test JUnit 测试方法

07、单元测试

1、JUnit5 的变化

Spring Boot 2.2.0 版本开始引入 JUnit 5 作为单元测试默认库

作为最新版本的JUnit框架，JUnit5与之前版本的Junit框架有很大的不同。由三个不同子项目的几个不同模块组成。

JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

JUnit Platform: Junit Platform是在JVM上启动测试框架的基础，不仅支持Junit自制的测试引擎，其他测试引擎也都可以接入。

JUnit Jupiter: JUnit Jupiter提供了JUnit5的新的编程模型，是JUnit5新特性的核心。内部包含了一个测试引擎，用于在Junit Platform上运行。

JUnit Vintage: 由于JUint已经发展多年，为了照顾老的项目，JUnit Vintage提供了兼容JUnit4.x,Junit3.x的测试引擎。

注意：

SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖。如果需要兼容junit4需要自行引入（不能使用junit4的功能 @Test）

JUnit 5’s Vintage Engine Removed from spring-boot-starter-test,如果需要继续兼容junit4需要自行引入vintage

以前：

@SpringBootTest + @RunWith(SpringTest.class)

SpringBoot整合Junit以后。

编写测试方法：@Test标注（注意需要使用junit5版本的注解）
Junit类具有Spring的功能，@Autowired、比如 @Transactional 标注测试方法，测试完成后自动回滚

2、JUnit5常用注解

JUnit5的注解与JUnit4的注解有所变化

https://junit.org/junit5/docs/current/user-guide/#writing-tests-annotations

@Test :表示方法是测试方法。但是与JUnit4的@Test不同，他的职责非常单一不能声明任何属性，拓展的测试将会由Jupiter提供额外测试
@ParameterizedTest :表示方法是参数化测试，下方会有详细介绍

@RepeatedTest :表示方法可重复执行，下方会有详细介绍
@DisplayName :为测试类或者测试方法设置展示名称

@BeforeEach :表示在每个单元测试之前执行
@AfterEach :表示在每个单元测试之后执行

@BeforeAll :表示在所有单元测试之前执行
@AfterAll :表示在所有单元测试之后执行

@Tag :表示单元测试类别，类似于JUnit4中的@Categories
@Disabled :表示测试类或测试方法不执行，类似于JUnit4中的@Ignore

@Timeout :表示测试方法运行如果超过了指定时间将会返回错误
@ExtendWith :为测试类或测试方法提供扩展类引用

3、断言（assertions）

断言（assertions）是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言方法都是 org.junit.jupiter.api.Assertions 的静态方法。JUnit 5 内置的断言可以分成如下几个类别：

检查业务逻辑返回的数据是否合理。

所有的测试运行结束以后，会有一个详细的测试报告；

1、简单断言

用来对单个值进行简单的验证。如：

方法	说明
assertEquals	判断两个对象或两个原始类型是否相等
assertNotEquals	判断两个对象或两个原始类型是否不相等
assertSame	判断两个对象引用是否指向同一个对象
assertNotSame	判断两个对象引用是否指向不同的对象
assertTrue	判断给定的布尔值是否为 true
assertFalse	判断给定的布尔值是否为 false
assertNull	判断给定的对象引用是否为 null
assertNotNull	判断给定的对象引用是否不为 null

2、数组断言

通过 assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等

3、组合断言

assertAll 方法接受多个 org.junit.jupiter.api.Executable 函数式接口的实例作为要验证的断言，可以通过 lambda 表达式很容易的提供这些断言

@Test

@DisplayName("assert all")

public void all() {

 assertAll("Math",

    () -> assertEquals(2, 1 + 1),

    () -> assertTrue(1 > 0)

);

4、异常断言

在JUnit4时期，想要测试方法的异常情况时，需要用@Rule注解的ExpectedException变量还是比较麻烦的。而JUnit5提供了一种新的断言方式Assertions.assertThrows() ,配合函数式编程就可以进行使用。

@Test
@DisplayName("异常测试")
public void exceptionTest() {
    ArithmeticException exception = Assertions.assertThrows(
           //扔出断言异常
            ArithmeticException.class, () -> System.out.println(1 % 0));

}

5、超时断言

Junit5还提供了Assertions.assertTimeout() 为测试方法设置了超时时间

@Test
@DisplayName("超时测试")
public void timeoutTest() {
    //如果测试方法时间超过1s将会异常
    Assertions.assertTimeout(Duration.ofMillis(1000), () -> Thread.sleep(500));
}

6、快速失败

通过 fail 方法直接使得测试失败

@Test
@DisplayName("fail")
public void shouldFail() {
 fail("This should fail");
}

4、前置条件（assumptions）

JUnit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于不满足的断言会使得测试方法失败，而不满足的前置条件只会使得测试方法的执行终止。前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要。

@DisplayName("前置条件")
public class AssumptionsTest {
 private final String environment = "DEV";
 
 @Test
 @DisplayName("simple")
 public void simpleAssume() {
    assumeTrue(Objects.equals(this.environment, "DEV"));
    assumeFalse(() -> Objects.equals(this.environment, "PROD"));
 }
 
 @Test
 @DisplayName("assume then do")
 public void assumeThenDo() {
    assumingThat(
       Objects.equals(this.environment, "DEV"),
       () -> System.out.println("In DEV")
    );
 }
}

assumeTrue 和 assumFalse 确保给定的条件为 true 或 false，不满足条件会使得测试执行终止。assumingThat 的参数是表示条件的布尔值和对应的 Executable 接口的实现对象。只有条件满足时，Executable 对象才会被执行；当条件不满足时，测试执行并不会终止。

5、嵌套测试

JUnit 5 可以通过 Java 中的内部类和@Nested 注解实现嵌套测试，从而可以更好的把相关的测试方法组织在一起。在内部类中可以使用@BeforeEach 和@AfterEach 注解，而且嵌套的层次没有限制。

  1 @DisplayName("A stack")
  2 
  3 class TestingAStackDemo {
  4 
  5 
  6     Stack<Object> stack;
  7 
  8 
  9     @Test
 10 
 11     @DisplayName("is instantiated with new Stack()")
 12 
 13     void isInstantiatedWithNew() {
 14 
 15         new Stack<>();
 16 
 17     }
 18 
 19 
 20     @Nested
 21 
 22     @DisplayName("when new")
 23 
 24     class WhenNew {
 25 
 26 
 27         @BeforeEach
 28 
 29         void createNewStack() {
 30 
 31             stack = new Stack<>();
 32 
 33         }
 34 
 35 
 36         @Test
 37 
 38         @DisplayName("is empty")
 39 
 40         void isEmpty() {
 41 
 42             assertTrue(stack.isEmpty());
 43 
 44         }
 45 
 46 
 47         @Test
 48 
 49         @DisplayName("throws EmptyStackException when popped")
 50 
 51         void throwsExceptionWhenPopped() {
 52 
 53             assertThrows(EmptyStackException.class, stack::pop);
 54 
 55         }
 56 
 57 
 58         @Test
 59 
 60         @DisplayName("throws EmptyStackException when peeked")
 61 
 62         void throwsExceptionWhenPeeked() {
 63 
 64             assertThrows(EmptyStackException.class, stack::peek);
 65 
 66         }
 67 
 68 
 69         @Nested
 70 
 71         @DisplayName("after pushing an element")
 72 
 73         class AfterPushing {
 74 
 75 
 76             String anElement = "an element";
 77 
 78 
 79             @BeforeEach
 80 
 81             void pushAnElement() {
 82 
 83                 stack.push(anElement);
 84 
 85             }
 86 
 87 
 88             @Test
 89 
 90             @DisplayName("it is no longer empty")
 91 
 92             void isNotEmpty() {
 93 
 94                 assertFalse(stack.isEmpty());
 95 
 96             }
 97 
 98 
 99             @Test
100 
101             @DisplayName("returns the element when popped and is empty")
102 
103             void returnElementWhenPopped() {
104 
105                 assertEquals(anElement, stack.pop());
106 
107                 assertTrue(stack.isEmpty());
108 
109             }
110 
111 
112             @Test
113 
114             @DisplayName("returns the element when peeked but remains not empty")
115 
116             void returnElementWhenPeeked() {
117 
118                 assertEquals(anElement, stack.peek());
119 
120                 assertFalse(stack.isEmpty());
121 
122             }
123 
124         }
125 
126     }
127 
128 }

View Code

6、参数化测试

参数化测试是JUnit5很重要的一个新特性，它使得用不同的参数多次运行测试成为了可能，也为我们的单元测试带来许多便利。

利用@ValueSource等注解，指定入参，我们将可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试，省去了很多冗余代码。

@ValueSource: 为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型

@NullSource: 表示为参数化测试提供一个null的入参

@EnumSource: 表示为参数化测试提供一个枚举入参

@CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参

@MethodSource：表示读取指定方法的返回值作为参数化测试入参(注意方法返回需要是一个流)

当然如果参数化测试仅仅只能做到指定普通的入参还达不到让我觉得惊艳的地步。让我真正感到他的强大之处的地方在于他可以支持外部的各类入参。如:CSV,YML,JSON 文件甚至方法的返回值也可以作为入参。只需要去实现ArgumentsProvider接口，任何外部文件都可以作为它的入参。

 1 @ParameterizedTest
 2 @ValueSource(strings = {"one", "two", "three"})
 3 @DisplayName("参数化测试1")
 4 public void parameterizedTest1(String string) {
 5     System.out.println(string);
 6     Assertions.assertTrue(StringUtils.isNotBlank(string));
 7 }
 8 
 9 @ParameterizedTest
10 @MethodSource("method")    //指定方法名
11 @DisplayName("方法来源参数")
12 public void testWithExplicitLocalMethodSource(String name) {
13     System.out.println(name);
14     Assertions.assertNotNull(name);
15 }
16 
17 static Stream<String> method() {
18     return Stream.of("apple", "banana");
19 }