#yyds干货盘点#JUnit5学习之六:参数化测试(Parameterized Tests)基础

Posted 程序员欣宸

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了#yyds干货盘点#JUnit5学习之六:参数化测试(Parameterized Tests)基础相关的知识,希望对你有一定的参考价值。

欢迎访问我的GitHub

本篇概览

  • 本文是《JUnit5学习》系列的第六篇,一起来实战强大参数化测试(Parameterized Tests),即多次执行同一个测试方法,每次使用不同的参数;
  • 由于参数化测试功能强大,内容也比前几篇的知识点多,为了方便大家阅读和实践,这里分为《基础》和《进阶》两篇来介绍,本篇以学习参数化测试(Parameterized Tests)的基础知识为主,包含以下内容:
    1. 极速体验;
    2. 版本依赖;
    3. ValueSource数据源
    4. null、空字符串数据源
    5. 枚举数据源
    6. 方法数据源
    7. Csv格式数据源
    8. Csv文件数据源

      源码下载

    9. 如果您不想编码,可以在GitHub下载所有源码,地址和链接信息如下表所示:
名称 链接 备注
项目主页 https://github.com/zq2599/blog_demos 该项目在GitHub上的主页
git仓库地址(https) https://github.com/zq2599/blog_demos.git 该项目源码的仓库地址,https协议
git仓库地址(ssh) git@github.com:zq2599/blog_demos.git 该项目源码的仓库地址,ssh协议
  1. 这个git项目中有多个文件夹,本章的应用在==junitpractice==文件夹下,如下图红框所示:

  2. ==junitpractice==是父子结构的工程,本篇的代码在==parameterized==子工程中,如下图:

    极速体验

  3. 现在,咱们以最少的步骤体验最简单的参数化测试;
  4. 在父工程junitpractice里新建名为==parameterized==的子工程,pom.xml内容如下:

    <?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>parameterized</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>parameterized</name>
    <description>Demo project for parameterized expirence in Spring Boot junit</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.junit</groupId>
                <artifactId>junit-bom</artifactId>
                <version>5.7.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    
    </dependencyManagement>
    
    <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.jupiter</groupId>
                    <artifactId>junit-jupiter</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    </project>
  5. 新建测试类==HelloTest.java==,在这个位置:==junitpractice\\parameterized\\src\\test\\java\\com\\bolingcavalry\\parameterized\\service\\impl==,内容如下:
    
    package com.bolingcavalry.parameterized.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.assertTrue;

@SpringBootTestbr/>@Slf4j
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class HelloTest

@Order(1)
@DisplayName("多个字符串型入参")
@ParameterizedTest
@ValueSource(strings =  "a", "b", "c" )
void stringsTest(String candidate) 
    log.info("stringsTest []", candidate);
    assertTrue(null!=candidate);

4. 执行该测试类,结果如下图:
![在这里插入图片描述](https://s4.51cto.com/images/blog/202202/23190912_621615d825b3219643.jpg?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
5. 从上图可见执行参数化测试需要两步:首先用==@ParameterizedTest==取代==@Test==,表名此方法要执行参数化测试,然后用==@ValueSource==指定每次测试时的参数来自字符串类型的数组: "a", "b", "c" ,每个元素执行一次;
6. 至此,咱们已体验过最简单的参数化测试,可见就是想办法使一个测试方法多次执行,每次都用不同的参数,接下来有关参数化测试的更多配置和规则将配合实战编码逐个展开,一起来体验吧;
### 版本要求
- 先看看==SpringBoot-2.3.4.RELEASE==间接依赖的==junit-jupiter-5.6.2==版本中,==ParameterizedTest==的源码,如下图红框所示,此时的ParameterizedTest还只是==体验版==:
![在这里插入图片描述](https://s4.51cto.com/images/blog/202202/23190912_621615d82921650364.jpg?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
- 再看看==junit-jupiter-5.7.0==版本的ParameterizedTest源码,此时已经是==稳定版==了:
![在这里插入图片描述](https://s4.51cto.com/images/blog/202202/23190912_621615d87747c71431.jpg?x-oss-process=image/watermark,size_14,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=)
- 综上所述,如果要使用参数化测试,最好是将junit-jupiter升级到==5.7.0或更高版本==,如果您的应用使用了SpringBoot框架,junit-jupiter是被spring-boot-starter-test间接依赖进来的,需要排除这个间接依赖,再手动依赖进来才能确保使用指定版本,在pom.xml中执行如下三步操作:
1. dependencyManagement节点添加junit-bom,并指定版本号:
```xml
<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.junit</groupId>
      <artifactId>junit-bom</artifactId>
      <version>5.7.0</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>
  1. 排除spring-boot-starter-test和junit-jupiter的间接依赖关系:
    <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
    <exclusion>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
    </exclusion>
    </exclusions>
    </dependency>
  2. 添加junit-jupiter依赖,此时会使用dependencyManagement中指定的版本号:
    <dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <scope>test</scope>
    </dependency>
  3. 如下图,刷新可见已经用上了5.7.0版本:
    • 版本问题解决了,接下来正式开始学习Parameterized Tests,先要了解的是有哪些数据源;

      ValueSource数据源

  4. ValueSource是最简单常用的数据源,支持以下类型的数组:

    short
    
    byte
    
    int
    
    long
    
    float
    
    double
    
    char
    
    boolean
    
    java.lang.String
    
    java.lang.Class
  5. 下面是整形数组的演示:
    @Order(2)
    @DisplayName("多个int型入参")
    @ParameterizedTest
    @ValueSource(ints =  1,2,3 )
    void intsTest(int candidate) 
        log.info("ints []", candidate);
        assertTrue(candidate<3);
    
  6. 从上述代码可见,入参等于3的时候assertTrue无法通过,测试方法会失败,来看看实际执行效果,如下图:

null、空字符串数据源

  1. 在用字符串作为入参时,通常要考虑入参为null的情况,此时ValueSource一般会这样写:
    @ValueSource(strings =  null, "a", "b", "c" )
  2. 此时可以使用@NullSource注解来取代上面的null元素,下面这种写法和上面的效果一模一样:
    @NullSource
    @ValueSource(strings =  "a", "b", "c" )
  3. 执行结果如下图红框,可见null作为入参被执行了一次:
  4. 与@NullSource代表null入参类似,@EmptySource代表==空字符串==入参,用法和执行结果如下图所示:
  5. 如果想同时用null和空字符串做测试方法的入参,可以使用==@NullAndEmptySource==,用法和执行结果如下图所示:

    枚举数据源(EnumSource)

  6. EnumSource可以让一个枚举类中的全部或者部分值作为测试方法的入参;
  7. 创建枚举类Types.java,用于接下来的实战,如下,很简单只有三个值:
    public enum Types 
    SMALL,
    BIG,
    UNKNOWN
    
  8. 先尝试用Types的每个值作为入参执行测试,可见只要添加@EnumSource即可,JUnit根据测试方法的入参类型知道要使用哪个枚举:
    @Order(6)
    @DisplayName("多个枚举型入参")
    @ParameterizedTest
    @EnumSource
    void enumSourceTest(Types type) 
        log.info("enumSourceTest []", type);
    
  9. 执行结果如下图所示:
  10. 如果不想执行枚举的所有值,而只要其中一部分,可以在==name属性==中指定:
    @EnumSource(names="SMALL", "UNKNOWN")
  11. 执行结果如下图所示:
  12. 也可以指定哪些值==不被执行==,此时要添加mode属性并设置为==EXCLUDE==(mode属性如果不写,默认值是INCLUDE,前面的例子中就是默认值):
    @EnumSource(mode= EnumSource.Mode.EXCLUDE, names="SMALL", "UNKNOWN")
  13. 执行结果如下,可见SMALL和UNKNOWN都==没有执行==:

    方法数据源(MethodSource)

  14. @MethodSource可以指定一个方法名称,该方法返回的元素集合作为测试方法的入参;
  15. 先来定义一个方法,该方法一般是static类型(否则要用@TestInstance修饰),并且==返回值是Stream类型==:
    static Stream<String> stringProvider() 
        return Stream.of("apple1", "banana1");
    
  16. 然后,测试方法用@MethodSource,并指定方法名==stringProvider==:
    @Order(9)
    @DisplayName("静态方法返回集合,用此集合中每个元素作为入参")
    @ParameterizedTest
    @MethodSource("stringProvider")
    void methodSourceTest(String candidate) 
        log.info("methodSourceTest []", candidate);
    
  17. 上面的stringProvider方法和测试方法methodSourceTest在同一个类中,如果它们不在同一个类中,就要指定静态方法的整个package路径、类名、方法名,如下所示,类名和方法名之间用==#==连接:
    @Order(10)
    @DisplayName("静态方法返回集合,该静态方法在另一个类中")
    @ParameterizedTest
    @MethodSource("com.bolingcavalry.parameterized.service.impl.Utils#getStringStream")
    void methodSourceFromOtherClassTest(String candidate) 
        log.info("methodSourceFromOtherClassTest []", candidate);
    
  18. 如果不在@MethodSource中指定方法名,JUnit会寻找和测试方法同名的静态方法,举例如下,静态方法==methodSourceWithoutMethodNameTest==会被作为测试方法的数据来源:

    static Stream<String> methodSourceWithoutMethodNameTest() 
        return Stream.of("apple3", "banana3");
    
    
    @Order(11)
    @DisplayName("静态方法返回集合,不指定静态方法名,自动匹配")
    @ParameterizedTest
    @MethodSource
    void methodSourceWithoutMethodNameTest(String candidate) 
        log.info("methodSourceWithoutMethodNameTest []", candidate);
    
  19. 执行结果如下:

    Csv格式数据源(CsvSource)

  20. 前面的测试方法入参都只有一个,在面对多个入参的测试方法时,@CsvSource就派上用场了,演示代码如下所示,可见数据是普通的CSV格式,每条记录有两个字段,对应测试方法的两个入参:
    @Order(12)
    @DisplayName("CSV格式多条记录入参")
    @ParameterizedTest
    @CsvSource(
            "apple1, 11",
            "banana1, 12",
            "lemon1, lime1, 0x0A"
    )
    void csvSourceTest(String fruit, int rank) 
        log.info("csvSourceTest, fruit [], rank []", fruit, rank);
    
  21. 执行结果如下,通过日志可以确定,每条记录的两个字段能匹配到测试方法的两个入参中:

  22. 另外@CsvSource还提供了一个属性==nullValues==,作用是将指定的字符串识别为null,下面这个设置就是把CSV数据中所有的==NIL==识别为null,再传给测试方法:
    @Order(13)
    @DisplayName("CSV格式多条记录入参(识别null)")
    @ParameterizedTest
    @CsvSource(value = 
            "apple2, 21",
            "banana2, 22",
            "lemon2, lime2, 0x0A",
            "NIL, 3" ,
            nullValues = "NIL"
    )
    void csvSourceWillNullTokenTest(String fruit, int rank) 
        log.info("csvSourceWillNullTokenTest, fruit [], rank []", fruit, rank);
    
  23. 执行结果如下,可见字符串==NIL==到测试方法后已变成==null==:

    Csv文件数据源

  24. @CsvSource解决了测试方法入参有多个字段的问题,但是把作为入参的测试数据写在源文件中似乎不合适,尤其是数据量很大的情况下,这种场景适合用@CsvFileSource,该注解用于指定csv文件作为数据源,注意==numLinesToSkip==属性指定跳过的行数,可以用来跳过表头:
    @Order(14)
    @DisplayName("CSV文件多条记录入参")
    @ParameterizedTest
    @CsvFileSource(files = "src/test/resources/two-column.csv", numLinesToSkip = 1)
    void csvFileTest(String country, int reference) 
        log.info("csvSourceTest, country [], reference []", country, reference);
    
  25. 在==src/test/resources/==创建文件two-column.csv,内容如下:
    Country, reference
    Sweden, 1
    Poland, 2
    "United States of America", 3
  26. 上述代码执行结果如下,代码中没有测试数据,显得更加简洁一些:

    期待《进阶》篇

    • 至此,咱们队JUnit5的参数化测试(Parameterized)有了初步的了解,可以通过各种数据源注解给测试方法制造更多的参数,但仅掌握这些还是不够的,依然有一些问题待解决,例如更自由的数据源定制、跟完善的多字段处理方案等等,下一篇《进阶》咱们一起来体验更多参数化测试的高级功能;

欢迎关注51CTO博客:程序员欣宸

以上是关于#yyds干货盘点#JUnit5学习之六:参数化测试(Parameterized Tests)基础的主要内容,如果未能解决你的问题,请参考以下文章

#yyds干货盘点#JUnit5学习之二:Assumptions类

#yyds干货盘点#jackson学习之六:常用类注解

#yyds干货盘点#Linux学习之Vim编辑器

#yyds干货盘点#jackson学习之九:springboot整合(配置文件)

#yyds干货盘点#jackson学习之七:常用Field注解

#yyds干货盘点#jackson学习之五:JsonInclude注解