乐趣区

关于云计算:JUnit5学习之六参数化测试Parameterized-Tests基础

jiezi

欢送拜访我的 GitHub

https://github.com/zq2599/blog_demos

内容：所有原创文章分类汇总及配套源码，波及 Java、Docker、Kubernetes、DevOPS 等；

对于《JUnit5 学习》系列

《JUnit5 学习》系列旨在通过实战晋升 SpringBoot 环境下的单元测试技能，一共八篇文章，链接如下：

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

本篇概览

  • 本文是《JUnit5 学习》系列的第六篇，一起来实战弱小参数化测试(Parameterized Tests)，即屡次执行同一个测试方法，每次应用不同的参数；
  • 因为参数化测试功能强大，内容也比前几篇的知识点多，为了不便大家浏览和实际，这里分为《根底》和《进阶》两篇来介绍，本篇以学习参数化测试 (Parameterized Tests) 的基础知识为主，蕴含以下内容：
  1. 极速体验；
  2. 版本依赖；
  3. ValueSource 数据源
  4. null、空字符串数据源
  5. 枚举数据源
  6. 办法数据源
  7. Csv 格局数据源
  8. Csv 文件数据源

源码下载

  1. 如果您不想编码，能够在 GitHub 下载所有源码，地址和链接信息如下表所示：
名称 链接 备注
我的项目主页 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”>parameterized</font> 子工程中，如下图：

极速体验

  1. 当初，咱们以起码的步骤体验最简略的参数化测试；
  2. 在父工程 junitpractice 里新建名为 <font color=”red”>parameterized</font> 的子工程，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>
  1. 新建测试类 <font color=”red”>HelloTest.java</font>，在这个地位：<font color=”blue”>junitpractice\parameterized\src\test\java\com\bolingcavalry\parameterized\service\impl</font>，内容如下：
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;

@SpringBootTest
@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);
    }
}
  1. 执行该测试类，后果如下图：

  1. 从上图可见执行参数化测试须要两步：首先用 <font color=”blue”>@ParameterizedTest</font> 取代 <font color=”blue”>@Test</font>，表名此办法要执行参数化测试，而后用 <font color=”blue”>@ValueSource</font> 指定每次测试时的参数来自字符串类型的数组：{“a”, “b”, “c”}，每个元素执行一次；
  2. 至此，咱们已体验过最简略的参数化测试，可见就是想方法使一个测试方法屡次执行，每次都用不同的参数，接下来无关参数化测试的更多配置和规定将配合实战编码一一开展，一起来体验吧；

版本要求

  • 先看看 <font color=”blue”>SpringBoot-2.3.4.RELEASE</font> 间接依赖的 <font color=”blue”>junit-jupiter-5.6.2</font> 版本中，<font color=”red”>ParameterizedTest</font> 的源码，如下图红框所示，此时的 ParameterizedTest 还只是 <font color=”red”> 体验版 </font>：

  • 再看看 <font color=”red”>junit-jupiter-5.7.0</font> 版本的 ParameterizedTest 源码，此时曾经是 <font color=”blue”> 稳定版 </font> 了：

  • 综上所述，如果要应用参数化测试，最好是将 junit-jupiter 降级到 <font color=”red”>5.7.0 或更高版本 </font>，如果您的利用应用了 SpringBoot 框架，junit-jupiter 是被 spring-boot-starter-test 间接依赖进来的，须要排除这个间接依赖，再手动依赖进来能力确保应用指定版本，在 pom.xml 中执行如下三步操作：
  1. dependencyManagement 节点增加 junit-bom，并指定版本号：
<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>
  1. 增加 junit-jupiter 依赖，此时会应用 dependencyManagement 中指定的版本号：
<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter</artifactId>
  <scope>test</scope>
</dependency>
  1. 如下图，刷新可见曾经用上了 5.7.0 版本：

  • 版本问题解决了，接下来正式开始学习 Parameterized Tests，先要理解的是有哪些数据源；

ValueSource 数据源

  1. ValueSource 是最简略罕用的数据源，反对以下类型的数组：
    short

    byte

    int

    long

    float

    double

    char

    boolean

    java.lang.String
    
    java.lang.Class
  1. 上面是整形数组的演示：
    @Order(2)
    @DisplayName("多个 int 型入参")
    @ParameterizedTest
    @ValueSource(ints = { 1,2,3})
    void intsTest(int candidate) {log.info("ints [{}]", candidate);
        assertTrue(candidate<3);
    }
  1. 从上述代码可见，入参等于 3 的时候 assertTrue 无奈通过，测试方法会失败，来看看理论执行成果，如下图：

null、空字符串数据源

  1. 在用字符串作为入参时，通常要思考入参为 null 的状况，此时 ValueSource 个别会这样写：
@ValueSource(strings = { null, "a", "b", "c"})
  1. 此时能够应用 @NullSource 注解来取代下面的 null 元素，上面这种写法和下面的成果截然不同：
    @NullSource
    @ValueSource(strings = { "a", "b", "c"})
  1. 执行后果如下图红框，可见 null 作为入参被执行了一次：

  1. 与 @NullSource 代表 null 入参相似，@EmptySource 代表 <font color=”blue”> 空字符串 </font> 入参，用法和执行后果如下图所示：

  1. 如果想同时用 null 和空字符串做测试方法的入参，能够应用 <font color=”blue”>@NullAndEmptySource</font>，用法和执行后果如下图所示：

枚举数据源(EnumSource)

  1. EnumSource 能够让一个枚举类中的全副或者局部值作为测试方法的入参；
  2. 创立枚举类 Types.java，用于接下来的实战，如下，很简略只有三个值：
public enum Types {
    SMALL,
    BIG,
    UNKNOWN
}
  1. 先尝试用 Types 的每个值作为入参执行测试，可见只有增加 @EnumSource 即可，JUnit 依据测试方法的入参类型晓得要应用哪个枚举：
    @Order(6)
    @DisplayName("多个枚举型入参")
    @ParameterizedTest
    @EnumSource
    void enumSourceTest(Types type) {log.info("enumSourceTest [{}]", type);
    }
  1. 执行后果如下图所示：

  1. 如果不想执行枚举的所有值，而只有其中一部分，能够在 <font color=”blue”>name 属性 </font> 中指定：
@EnumSource(names={"SMALL", "UNKNOWN"})
  1. 执行后果如下图所示：

  1. 也能够指定哪些值 <font color=”red”> 不被执行 </font>，此时要增加 mode 属性并设置为 <font color=”blue”>EXCLUDE</font>（mode 属性如果不写，默认值是 INCLUDE，后面的例子中就是默认值）：
@EnumSource(mode= EnumSource.Mode.EXCLUDE, names={"SMALL", "UNKNOWN"})
  1. 执行后果如下，可见 SMALL 和 UNKNOWN 都 <font color=”red”> 没有执行 </font>：

办法数据源(MethodSource)

  1. @MethodSource 能够指定一个办法名称，该办法返回的元素汇合作为测试方法的入参；
  2. 先来定义一个办法，该办法个别是 static 类型(否则要用 @TestInstance 润饰)，并且 <font color=”blue”> 返回值是 Stream 类型 </font>：
    static Stream<String> stringProvider() {return Stream.of("apple1", "banana1");
    }
  1. 而后，测试方法用 @MethodSource，并指定办法名 <font color=”blue”>stringProvider</font>：
    @Order(9)
    @DisplayName("静态方法返回汇合，用此汇合中每个元素作为入参")
    @ParameterizedTest
    @MethodSource("stringProvider")
    void methodSourceTest(String candidate) {log.info("methodSourceTest [{}]", candidate);
    }
  1. 下面的 stringProvider 办法和测试方法 methodSourceTest 在同一个类中，如果它们不在同一个类中，就要指定静态方法的整个 package 门路、类名、办法名，如下所示，类名和办法名之间用 <font color=”blue”>#</font> 连贯：
@Order(10)
    @DisplayName("静态方法返回汇合，该静态方法在另一个类中")
    @ParameterizedTest
    @MethodSource("com.bolingcavalry.parameterized.service.impl.Utils#getStringStream")
    void methodSourceFromOtherClassTest(String candidate) {log.info("methodSourceFromOtherClassTest [{}]", candidate);
    }
  1. 如果不在 @MethodSource 中指定办法名，JUnit 会寻找和测试方法同名的静态方法，举例如下，静态方法 <font color=”blue”>methodSourceWithoutMethodNameTest</font> 会被作为测试方法的数据起源：
    static Stream<String> methodSourceWithoutMethodNameTest() {return Stream.of("apple3", "banana3");
    }

    @Order(11)
    @DisplayName("静态方法返回汇合，不指定静态方法名，主动匹配")
    @ParameterizedTest
    @MethodSource
    void methodSourceWithoutMethodNameTest(String candidate) {log.info("methodSourceWithoutMethodNameTest [{}]", candidate);
    }
  1. 执行后果如下：

Csv 格局数据源(CsvSource)

  1. 后面的测试方法入参都只有一个，在面对多个入参的测试方法时，@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);
    }
  1. 执行后果如下，通过日志能够确定，每条记录的两个字段能匹配到测试方法的两个入参中：

  1. 另外 @CsvSource 还提供了一个属性 <font color=”blue”>nullValues</font>，作用是将指定的字符串辨认为 null，上面这个设置就是把 CSV 数据中所有的 <font color=”red”>NIL</font> 辨认为 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);
    }
  1. 执行后果如下，可见字符串 <font color=”red”>NIL</font> 到测试方法后已变成 <font color=”blue”>null</font>：

Csv 文件数据源

  1. @CsvSource 解决了测试方法入参有多个字段的问题，然而把作为入参的测试数据写在源文件中仿佛不适合，尤其是数据量很大的状况下，这种场景适宜用 @CsvFileSource，该注解用于指定 csv 文件作为数据源，留神 <font color=”blue”>numLinesToSkip</font> 属性指定跳过的行数，能够用来跳过表头：
    @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);
    }
  1. 在 <font color=”blue”>src/test/resources/</font> 创立文件 two-column.csv，内容如下：
Country, reference
Sweden, 1
Poland, 2
"United States of America", 3
  1. 上述代码执行后果如下，代码中没有测试数据，显得更加简洁一些：

期待《进阶》篇

  • 至此，咱们队 JUnit5 的参数化测试 (Parameterized) 有了初步的理解，能够通过各种数据源注解给测试方法制作更多的参数，但仅把握这些还是不够的，仍然有一些问题待解决，例如更自在的数据源定制、跟欠缺的多字段解决计划等等，下一篇《进阶》咱们一起来体验更多参数化测试的高级性能；

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

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

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

微信搜寻「程序员欣宸」，我是欣宸，期待与您一起畅游 Java 世界 …
https://github.com/zq2599/blog_demos

退出移动版