乐趣区

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

欢送拜访我的 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

退出移动版