乐趣区

关于云计算:JUnit5学习之二Assumptions类

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 学习》系列的第二篇，学习一个重要的知识点：Assumptions 类，只有理解了它们，才好持续前面的学习，全篇章节如下：

  1. Assertions 和 Assumptions 简介
  2. 写一段代码比照成果
  3. Assumptions 编码
  4. 查看执行后果

源码下载

  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”>assertassume</font> 子工程中，如下图：

Assertions 和 Assumptions 简介

Assumptions 和 Assertions 容易混同，因而这里通过比照它们来学习：

  1. Assertions 即断言类，外面提供了很多静态方法，例如 assertTrue，如果 assertTrue 的入参为 false，就会抛出 AssertionFailedError 异样，Junit 对抛出此异样的办法断定为失败；
  2. Assumptions 即假如类，外面提供了很多静态方法，例如 assumeTrue，如果 assumeTrue 的入参为 false，就会抛出 TestAbortedException 异样，Junit 对抛出此异样的办法断定为跳过；
  3. 简略的说，Assertions 的办法抛出异样意味着测试不通过，Assumptions 的办法抛出异样意味着测试被跳过(为什么称为 ” 跳过 ”？因为 <font color=”blue”>mvn test</font> 的执行后果被标记为 <font color=”red”>Skipped</font>)；

写一段代码比照成果

  1. 用代码来验证的成果最好，如下所示，一共四个办法，assertSuccess 不抛出 AssertionFailedError 异样，assertFail 抛出 AssertionFailedError 异样，assumpSuccess 不抛出 TestAbortedException 异样，assumpFail 抛出 TestAbortedException 异样
package com.bolingcavalry.assertassume.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

@SpringBootTest
@Slf4j
public class AssertAssumpTest {

    /**
     * 最简略的胜利用例
     */
    @Test
    void assertSuccess() {assertEquals(2, Math.addExact(1,1));
    }

    /**
     * 最简略的失败用例
     */
    @Test
    void assertFail() {assertEquals(3, Math.addExact(1,1));
    }

    /**
     * assumeTrue 不抛出异样的用例
     */
    @Test
    void assumpSuccess() {
        // assumeTrue 办法的入参如果为 true，就不会抛出异样，前面的代码才会继续执行
        assumeTrue(true);
        // 如果打印出此日志，证实 assumeTrue 办法没有抛出异样
        log.info("assumpSuccess 的 assumeTrue 执行实现");
        // 接下来是惯例的单元测试逻辑
        assertEquals(2, Math.addExact(1,1));
    }

    /**
     * assumeTrue 抛出异样的用例
     */
    @Test
    void assumpFail() {
        // assumeTrue 办法的入参如果为 false，就会抛出 TestAbortedException 异样，前面就不会执行了
        assumeTrue(false, "未通过 assumeTrue");
        // 如果打印出此日志，证实 assumpFail 办法没有抛出异样
        log.info("assumpFail 的 assumeTrue 执行实现");
        // 接下来是惯例的单元测试逻辑，但因为后面抛出了异样，就不再执行了
        assertEquals(2, Math.addExact(1,1));
    }
}
  1. 点击下图红框地位执行单元测试：

  1. 执行后果如下：

  1. 另外，在 target 目录，能够看到 surefire 插件生成的单元测试报告 <font color=”blue”>TEST-com.bolingcavalry.assertassume.service.impl.AssertAssumpTest.xml</font>，如下图所示，testcase 节点中呈现了 <font color=”blue”>skipped</font> 节点：

  • 上述比照验证再次阐明 Assertions 和 Assumptions 的区别：都用来比照预期值和理论值，当预期值和理论值不统一时，Assertions 的测试后果是执行失败，Assumptions 的测试后果是跳过(或者疏忽)；

Assumptions 实战

弄清楚的 Assertions 和 Assumptions 的区别，接下来趁热打铁，学习 Assumptions 类中几个重要的静态方法：assumeTrue、assumingThat

  1. 最简略的用法如下，可见只有 assumeTrue 不抛出异样，前面的 log.info 才会执行：
    @Test
    @DisplayName("最一般的 assume 用法")
    void tryAssumeTrue() {assumeTrue("CI".equals(envType));

        log.info("CI 环境才会打印的 assumeTrue");
    }
  1. assumeTrue 能够承受 Supplier 类型作为第二个入参，如果 assumeTrue 失败就会将第二个参数的内容作为失败提醒：
@Test
    @DisplayName("assume 失败时带自定义错误信息")
    void tryAssumeTrueWithMessage() {
        // 第二个入参是 Supplier 实现，返回的内容用作跳过用例时的提示信息
        assumeTrue("CI".equals(envType),
                () -> "环境不匹配而跳过，以后环境：" + envType);

        log.info("CI 环境才会打印的 tryAssumeTrueWithMessage");
    }

成果如下图：

  1. 还有个 <font color=”blue”>assumingThat</font> 办法，能够承受 Executable 类型作为第二个入参，如果第一个入参为 true 就会执行 Executable 的 execute 办法，留神 assumingThat 办法的特点：<font color=”red”> 不抛出异样 </font>，因而其所在的办法不会被跳过，这是和 assumeTrue 相比最大的区别(assumeTrue 一旦入参为 false 就会抛出异样，其所在办法就被标记为跳过)：
    @Test
    @DisplayName("assume 胜利时执行指定逻辑")
    void tryAssumingThat() {
        // 第二个入参是 Executable 实现，// 当第一个参数为 true 时，执行第二个参数的 execute 办法
        assumingThat("CI".equals(envType),
                () -> {log.info("这一行内容只有在 CI 环境才会打印");
                });

        log.info("无论什么环境都会打印的 tryAssumingThat");
    }
  • 接下来咱们执行上述代码，看看成果；

执行 Assumptions 代码

  1. 先做筹备工作，本次实战的 springboot 工程名为 <font color=”blue”>assertassume</font>，咱们在工程的 resources 目录下增加两个配置文件：application.properties 和 application-test.properties，地位如下图：

  1. application-test.properties 内容如下：
envType:CI
  1. application.properties 内容如下：
envType:PRODUCTION
  1. 残缺的单元测试类如下，通过注解 ActiveProfiles，指定了应用 application-test.properties 的配置，因而 envType 的值为 <font color=”red”>CI</font>：
package com.bolingcavalry.assertassume.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import static org.junit.jupiter.api.Assumptions.assumeTrue;
import static org.junit.jupiter.api.Assumptions.assumingThat;

@SpringBootTest
@Slf4j
@ActiveProfiles("test")
public class AssumptionsTest {@Value("${envType}")
    private String envType;

    @Test
    @DisplayName("最一般的 assume 用法")
    void tryAssumeTrue() {assumeTrue("CI".equals(envType));

        log.info("CI 环境才会打印的 assumeTrue");
    }

    @Test
    @DisplayName("assume 失败时带自定义错误信息")
    void tryAssumeTrueWithMessage() {
        // 第二个入参是 Supplier 实现，返回的内容用作跳过用例时的提示信息
        assumeTrue("CI".equals(envType),
                () -> "环境不匹配而跳过，以后环境：" + envType);

        log.info("CI 环境才会打印的 tryAssumeTrueWithMessage");
    }

    @Test
    @DisplayName("assume 胜利时执行指定逻辑")
    void tryAssumingThat() {
        // 第二个入参是 Executable 实现，// 当第一个参数为 true 时，执行第二个参数的 execute 办法
        assumingThat("CI".equals(envType),
                () -> {log.info("这一行内容只有在 CI 环境才会打印");
                });

        log.info("无论什么环境都会打印的 tryAssumingThat");
    }
}
  1. 执行后果如下图，可见 assume 通过，所有信息都被打印进去了：

  1. 接下来把代码中的 ActiveProfiles 注解那一行正文掉，如下图红框：

  1. 执行后果如下，可见 tryAssumingThat 办法被标记为胜利，不过从日志可见 assumingThat 的第二个入参 executable 没有被执行：

  • 至此，Assumptions 类的罕用办法体验实现，接下来的章节会持续学习其余罕用类；

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

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

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

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

退出移动版