第七课 SpringBoot2基础-单元测试

最新推荐文章于 2024-07-22 10:13:33 发布
最新推荐文章于 2024-07-22 10:13:33 发布
阅读量124 收藏
点赞数
文章标签： spring boot 单元测试 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa18855953229/article/details/121112202
版权

第七课 SpringBoot2基础-单元测试

tags:

  • Spring Boot
  • 2021尚硅谷
  • 雷丰阳

文章目录

第一节 Junit5简介

  1. Spring Boot 2.2.0 版本开始引入 JUnit 5 作为单元测试默认库作为最新版本的JUnit框架，JUnit5与之前版本的Junit框架有很大的不同。由三个不同子项目的几个不同模块组成。
  2. 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的测试引擎。
  3. 注意：SpringBoot 2.4 以上版本移除了默认对 Vintage 的依赖。如果需要兼容junit4需要自行引入（不能使用junit4的功能 @Test）
  4. JUnit 5’s Vintage Engine Removed from spring-boot-starter-test,如果需要继续兼容junit4需要自行引入vintage
<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
  1. 引用和使用。
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>

@SpringBootTest
class Boot05WebAdminApplicationTests {


    @Test
    void contextLoads() {

    }
}
  1. 以前：pringBootTest + @RunWith(SpringTest.class)
  2. SpringBoot整合Junit以后。
    • 测试方法：@Test标注（注意需要使用junit5版本的注解）
    • Junit类具有Spring的功能，@Autowired、比如 @Transactional 标注测试方法，测试完成后自动回滚

第二节 JUnit5常用注解

  1. JUnit5的注解与JUnit4的注解有所变化
    • https://junit.org/junit5/docs/current/user-guide/#writing-tests-annotations
  2. @Test :表示方法是测试方法。但是与JUnit4的@Test不同，他的职责非常单一不能声明任何属性，拓展的测试将会由Jupiter提供额外测试
  3. @ParameterizedTest :表示方法是参数化测试，下方会有详细介绍
  4. @RepeatedTest :表示方法可重复执行，下方会有详细介绍
  5. @DisplayName :为测试类或者测试方法设置展示名称
  6. @BeforeEach :表示在每个单元测试之前执行
  7. @AfterEach :表示在每个单元测试之后执行
  8. @BeforeAll :表示在所有单元测试之前执行
  9. @AfterAll :表示在所有单元测试之后执行
  10. @Tag :表示单元测试类别，类似于JUnit4中的@Categories
  11. @Disabled :表示测试类或测试方法不执行，类似于JUnit4中的@Ignore
  12. @Timeout :表示测试方法运行如果超过了指定时间将会返回错误
  13. @ExtendWith :为测试类或测试方法提供扩展类引用
  14. import org.junit.jupiter.api.Test; //注意这里使用的是jupiter的Test注解！！
  15. 如果要使用springboot的自动注入功能，比如导入某些容器需要加上**@SpringBootTest**，注解。
package com.atguigu.boot05webadmin;

import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.concurrent.TimeUnit;

import static org.junit.jupiter.api.Assertions.*;



/*@RunWith*/

/**
 * @BootstrapWith(SpringBootTestContextBootstrapper.class)
 * @ExtendWith(SpringExtension.class)
 */
//@SpringBootTest
@DisplayName("junit5功能测试类")
public class Junit5Test {


    @Autowired
    JdbcTemplate jdbcTemplate;


    /**
     * 测试前置条件
     */
    @DisplayName("测试前置条件")
    @Test
    void testassumptions(){
        Assumptions.assumeTrue(false,"结果不是true");
        System.out.println("111111");

    }

    /**
     * 断言：前面断言失败，后面的代码都不会执行
     */
    @DisplayName("测试简单断言")
    @Test
    void testSimpleAssertions() {
        int cal = cal(3, 2);
        //相等
        assertEquals(6, cal, "业务逻辑计算失败");
        Object obj1 = new Object();
        Object obj2 = new Object();
        assertSame(obj1, obj2, "两个对象不一样");

    }

    @Test
    @DisplayName("array assertion")
    void array() {
        assertArrayEquals(new int[]{1, 2}, new int[]{1, 2}, "数组内容不相等");
    }

    @Test
    @DisplayName("组合断言")
    void all() {
        /**
         * 所有断言全部需要成功
         */
        assertAll("test",
                () -> assertTrue(true && true, "结果不为true"),
                () -> assertEquals(1, 2, "结果不是1"));

        System.out.println("=====");
    }

    @DisplayName("异常断言")
    @Test
    void testException() {

        //断定业务逻辑一定出现异常
        assertThrows(ArithmeticException.class, () -> {
            int i = 10 / 2;
        }, "业务逻辑居然正常运行？");
    }

    @DisplayName("快速失败")
    @Test
    void testFail(){
        //xxxxx
        if(1 == 2){
            fail("测试失败");
        }

    }


    int cal(int i, int j) {
        return i + j;
    }

    @DisplayName("测试displayname注解")
    @Test
    void testDisplayName() {
        System.out.println(1);
        System.out.println(jdbcTemplate);
    }

    @Disabled
    @DisplayName("测试方法2")
    @Test
    void test2() {
        System.out.println(2);
    }

    // 重复注解 会测试5次
    @RepeatedTest(5)
    @Test
    void test3() {
        System.out.println(5);
    }

    /**
     * 规定方法超时时间。超出时间测试出异常
     *
     * @throws InterruptedException
     */
    @Timeout(value = 500, unit = TimeUnit.MILLISECONDS)
    @Test
    void testTimeout() throws InterruptedException {
        Thread.sleep(600);
    }


    @BeforeEach
    void testBeforeEach() {
        System.out.println("测试就要开始了...");
    }

    @AfterEach
    void testAfterEach() {
        System.out.println("测试结束了...");
    }

    @BeforeAll
    static void testBeforeAll() {
        System.out.println("所有测试就要开始了...");
    }

    @AfterAll
    static void testAfterAll() {
        System.out.println("所有测试以及结束了...");

    }
}

第三节 JUnit5断言（assertions）

  1. 断言（assertions）是测试方法中的核心部分，用来对测试需要满足的条件进行验证。这些断言方法都是 org.junit.jupiter.api.Assertions 的静态方法。
  2. 检查业务逻辑返回的数据是否合理。所有的测试运行结束以后，会有一个详细的测试报告；
  3. 断言：前面断言失败，当前测试中后面的代码都不会执行

3.1 简单断言

  1. 用来对单个值进行简单的验证。如：
    | 方法 | 说明 |
    | ---- | ---- |
    | assertEquals | 判断两个对象或两个原始类型是否相等 |
    | assertNotEquals | 判断两个对象或两个原始类型是否不相等 |
    | assertSame | 判断两个对象引用是否指向同一个对象 |
    | assertNotSame | 判断两个对象引用是否指向不同的对象 |
    | assertTrue | 判断给定的布尔值是否为 true |
    | assertFalse | 判断给定的布尔值是否为 false |
    | assertNull | 判断给定的对象引用是否为 null |
    | assertNotNull | 判断给定的对象引用是否不为 null |
@Test
@DisplayName("simple assertion")
public void simple() {
     assertEquals(3, 1 + 2, "simple math");
     assertNotEquals(3, 1 + 1);

     assertNotSame(new Object(), new Object());
     Object obj = new Object();
     assertSame(obj, obj);

     assertFalse(1 > 2);
     assertTrue(1 < 2);

     assertNull(null);
     assertNotNull(new Object());
}

3.2 数组断言

  1. 通过 assertArrayEquals 方法来判断两个对象或原始类型的数组是否相等.
@Test
@DisplayName("array assertion")
public void array() {
 assertArrayEquals(new int[]{1, 2}, new int[] {1, 2});
}

3.3 组合断言

  1. assertAll 方法接受多个 org.junit.jupiter.api.Executable 函数式接口的实例作为要验证的断言，可以通过 lambda 表达式很容易的提供这些断言.
  2. 所有断言全部需要成功, 有一个失败都失败。
// Math是组合断言的名称
@Test
@DisplayName("assert all")
public void all() {
 assertAll("Math",
    () -> assertEquals(2, 1 + 1),
    () -> assertTrue(1 > 0)
 );
}

3.4 异常断言

  1. junit4时期，想要测试方法的异常情况时，需要用@Rule注解的ExpectedException变量还是比较麻烦的。而JUnit5提供了一种新的断言方式ssertions.assertThrows(),配合函数式编程就可以进行使用。
  2. 判断这个程序一定要抛出异常，如果没有断言失败。
@Test
@DisplayName("异常测试")
public void exceptionTest() {
    ArithmeticException exception = Assertions.assertThrows(
           //扔出断言异常
            ArithmeticException.class, () -> System.out.println(1 % 0));

}

3.5 超时断言

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

3.6 快速失败

  1. 通过 fail 方法直接使得测试失败。
@Test
@DisplayName("fail")
public void shouldFail() {
 fail("This should fail");
}

第四节 前置条件（assumptions）

  1. JUnit 5 中的前置条件（assumptions【假设】）类似于断言，不同之处在于不满足的断言会使得测试方法失败，而不满足的前置条件只会使得测试方法的执行终止。前置条件可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要。
    /**
     * 测试前置条件
     */
    @DisplayName("测试前置条件")
    @Test
    void testassumptions(){
        Assumptions.assumeTrue(false,"结果不是true");
        System.out.println("111111");
    }

第五节 嵌套测试

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


import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;

import java.util.EmptyStackException;
import java.util.Stack;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.*;

@DisplayName("嵌套测试")
public class TestingAStackDemo {

    Stack<Object> stack;



    @ParameterizedTest
    @DisplayName("参数化测试")
    @ValueSource(ints = {1,2,3,4,5})
    void testParameterized(int i){
        System.out.println(i);
    }


    @ParameterizedTest
    @DisplayName("参数化测试")
    @MethodSource("stringProvider")
    void testParameterized2(String i){
        System.out.println(i);
    }


    static Stream<String> stringProvider() {
        return Stream.of("apple", "banana","atguigu");
    }

    @Test
    @DisplayName("new Stack()")
    void isInstantiatedWithNew() {
        new Stack<>();
        //嵌套测试情况下，外层的Test不能驱动内层的Before(After)Each/All之类的方法提前/之后运行
        assertNull(stack);
    }

    @Nested
    @DisplayName("when new")
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        @Test
        @DisplayName("is empty")
        void isEmpty() {
            assertTrue(stack.isEmpty());
        }

        @Test
        @DisplayName("throws EmptyStackException when popped")
        void throwsExceptionWhenPopped() {
            assertThrows(EmptyStackException.class, stack::pop);
        }

        @Test
        @DisplayName("throws EmptyStackException when peeked")
        void throwsExceptionWhenPeeked() {
            assertThrows(EmptyStackException.class, stack::peek);
        }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing {

            String anElement = "an element";

            @BeforeEach
            void pushAnElement() {
                stack.push(anElement);
            }

            /**
             * 内层的Test可以驱动外层的Before(After)Each/All之类的方法提前/之后运行
             */
            @Test
            @DisplayName("it is no longer empty")
            void isNotEmpty() {
                assertFalse(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when popped and is empty")
            void returnElementWhenPopped() {
                assertEquals(anElement, stack.pop());
                assertTrue(stack.isEmpty());
            }

            @Test
            @DisplayName("returns the element when peeked but remains not empty")
            void returnElementWhenPeeked() {
                assertEquals(anElement, stack.peek());
                assertFalse(stack.isEmpty());
            }
        }
    }
}

第六节 参数化测试

  1. 参数化测试是JUnit5很重要的一个新特性，它使得用不同的参数多次运行测试成为了可能，也为我们的单元测试带来许多便利。
  2. 利用@ValueSource等注解，指定入参，我们将可以使用不同的参数进行多次单元测试，而不需要每新增一个参数就新增一个单元测试，省去了很多冗余代码。
  3. @ValueSource: 为参数化测试指定入参来源，支持八大基础类以及String类型,Class类型
  4. @NullSource: 表示为参数化测试提供一个null的入参
  5. @EnumSource: 表示为参数化测试提供一个枚举入参
  6. @CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参
  7. @MethodSource：表示读取指定方法的返回值作为参数化测试入参(注意方法返回需要是一个流)
  8. 支持外部的各类入参。如:CSV,YML,JSON 文件甚至方法的返回值也可以作为入参。只需要去实现ArgumentsProvider接口，任何外部文件都可以作为它的入参
@ParameterizedTest
@ValueSource(strings = {"one", "two", "three"})
@DisplayName("参数化测试1")
public void parameterizedTest1(String string) {
    System.out.println(string);
    Assertions.assertTrue(StringUtils.isNotBlank(string));
}


@ParameterizedTest
@MethodSource("method")    //指定方法名
@DisplayName("方法来源参数")
public void testWithExplicitLocalMethodSource(String name) {
    System.out.println(name);
    Assertions.assertNotNull(name);
}

// 方法必须返回一个流 而且是静态的
static Stream<String> method() {
    return Stream.of("apple", "banana");
}

第七节 迁移指南

  1. junit4迁移到junit5在进行迁移的时候需要注意如下的变化(去看官网迁移说明)：
  2. 注解在 org.junit.jupiter.api 包中，断言在 org.junit.jupiter.api.Assertions 类中，前置条件在 org.junit.jupiter.api.Assumptions 类中。
  3. 把@Before 和@After 替换成@BeforeEach 和@AfterEach。
  4. 把@BeforeClass 和@AfterClass 替换成@BeforeAll 和@AfterAll。
  5. 把@Ignore 替换成@Disabled。
  6. 把@Category 替换成@Tag。
  7. 把@RunWith、@Rule 和@ClassRule 替换成@ExtendWith。
道教儒佛电磁波
关注
专栏目录
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 9万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
springBoot
u012532092的博客
11-23 549
1、微服务、微框架 使用springBoot会使编码，配置，部署，监控变得很简单。。 第一节、springBoot是的springMVC升级版，两者没有必然的联系，可以直接学springBoot。 微服务：当下比较流行的架构或者说解决方案，很多公司都在用，spring家族为微服务架构提供了一整套组件，统称为SpringCloud。要使用SpringCloud就必须要先学会使用Spring...
Junit5用户手册
01-16
文档是提供全面的深入指导程序员编写测试程序的用户指导。
Junit5的使用
Gavin
02-10 1828
Junit5 描述: JUnit 5 是 JUnit4的下一代产品。与以前版本的 JUnit 不同，JUnit 5 由来自三个不同子项目的几个不同模块组成。 JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage 目标是为 JVM 上的开发人员端测试创建最新的基础。这包括专注于Java 8及更高版本，以及支持许多不同风格的测试。 springboot 2.2.0开始引入Junit5作为单元测试的默认库 在spring test中已经导入了关于.
Junit5相关应用
woshiwjma956的博客
02-03 171
Junit5的变化 Spring Boot 2.2.0版本开始引入Junit5作为单元测试默认库 整合SpringBoot之后加入@SpringBootTest可以使用Spring的相关功能如@Autowired 加入@Transactional 标注的 测试方法完成之后会自动回滚 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-start
Junuit5的使用说明
HM_1011000000的博客
05-18 1365
JUnit 5采用模块化架构，由JUnit Platform、JUnit Jupiter和JUnit Vintage三个子项目组成。JUnit Platform提供了测试运行和扩展的基础设施，JUnit Jupiter是JUnit 5新引入的编写测试的API，而JUnit Vintage提供了对JUnit 3和JUnit 4的兼容性支持。除了使用内置的参数源注解，您还可以自定义参数解析器来提供参数。通过实现ArgumentsProvider接口，您可以创建自己的参数解析器，并将其应用于参数化测试。
Junit5 单元测试框架的使用
qq_40815999的博客
01-24 1157
Junit5 简单使用总结 作为一款测试框架，一般我们需要从以下几个方面去考虑 TestCase ： 测试用例的管理 Assertions : 用例断言的管理 Test Execution: 测试执行，以何种顺序执行 Test Fixtures : 测试装置，测试用例运行的前后动作，用来管理测试用例的执行 Test Suites: 测试套，控制用例批量运行 Test Runner： 测试用例的运行器 Test Result Report： 测试报告 Junit5 架构 junit5 大体由3个模块组成
Springboot精讲42课.zip
11-11
8. **测试**：讲解如何编写单元测试和集成测试，使用`@SpringBootTest`和`@WebMvcTest`等注解进行测试。 9. **持续集成与部署**：如何将Spring Boot应用与Docker结合，以及使用Jenkins、GitLab CI/CD等工具进行持续...
springboot
以梦为马 不负韶华
12-19 1215
第一节 Spring技术的3个大的发展历史阶段 spring1.x版本阶段 所有的依赖关系，都是使用xml进行描述——不管是IOC还是AOP的关系都是这样处理，都是历史背景决定的。 spring2.x版本阶段 伴随着JDK1.5而来，它支持注解，使得xml配置文件的体积大大减小了，配置文件的数量也大大减少了。争论了很久 ，最终统一了使用方式：一些系统的配置使用xml完成，一些业务逻辑配置使用...
全套SpringBoot入门到项目实战课程.zip
07-04
1. **SpringBoot基础** - **起步依赖**：SpringBoot通过“起步依赖”（Starter POMs）简化了添加Spring及其他相关库的过程。 - **自动配置**：SpringBoot会根据引入的依赖自动配置相应的Bean，减少手动配置工作。 ...
junit5-samples,使用junit 5的示例应用程序集合。.zip
09-25
欢迎使用junit 5示例，一个示例应用程序和扩展的集合
JUnit5使用学习
E_Possible的博客
07-31 480
转载自：https://www.yuque.com/atguigu/springboot/ksndgx
【测试学习】Junit5的简单使用
qq_48479056的博客
06-26 1563
如果Selenium编写的自动化测试用例是灯，Junit就是控制灯怎么去亮，灯亮的颜色是什么颜色，灯亮的顺序是什么等。要解决的问题：现在有a01，a02，a03...a10一共10个class文件都要执行，正常操作是如果要执行a10，点击a10，执行a9，点击a9...以此类推。（2）表示注解的：@Test，@BeforeAll，@AfterAll，@BeforeEach，@AfterEach。不论有几个测试用例，都只执行一次；执行结果：先执行包1中的a01，a02，然后执行包2中的a01。
JUnit5学习与使用
陈沫尘的博客
01-16 1366
JUnit5是最新的JUnit框架，与之前的JUnit框架有许多不同，它由三个不同子项目的几个不同模块构成，它们分别是JUnit Platform、JUnit Jupiter和JUnit Vintage。JUnit Platform是在 JVM 上启动测试框架的基础。它还定义了用于开发在平台上运行的测试框架的 API。此外，该平台还提供了一个控制台启动器，用于从命令行启动平台，并提供JUnit平台套件引擎，以便在平台上使用一个或多个测试引擎运行自定义测试套件。
JUnit5单元测试框架简单使用
qq_52655865的博客
09-11 1005
TestMethodOrder(MethodOrderer.OrderAnnotation.class)//按照自定义顺序排序@Test@Order(3)}@Test@Order(1)}@Test@Order(4)}@Test@Order(2)}}多个测试用例之间需要排序，在测试中多个测试用例之间可能存在关联关系，不定义执行顺序会导致执行的顺序发生变化，出现错误。
JUnit5注释的基础使用
最新发布
m0_69119792的博客
07-22 850
本文介绍关于学习Junit5的基础使用，测试用例/测试类排序，断言方式，单或多参数化配置，mvn启动测试用例等
JUnit5单元测试框架的使用教程与简单实例
热门推荐
pan_junbiao的博客
02-13 3万+
1、JUnit5的使用教程 1.1 简介 JUnit是一个Java语言的单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个。 JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。 JUnit5旨在调整java8样式的编码，并且比JUnit4更强大和灵...
JUnit Assert方法总结
小灰灰的部落
11-01 930
今天看hibernate的书时遇到JunitTest，遇到Assert.assertEquals(user.getId().intValue()&gt;0,true);一句不太明白，到网上搜了一篇JUnit Assert方法总结的文章，贴在这里备忘   junit中的assert方法全部放在Assert类中，总结一下junit类中assert方法的分类。1.assertTrue/False([St...
SpringBoot整合Swagger-V2与Bootstrap-UI实战
资源摘要信息:"SpringBoot演示Swagger v2结合Bootstrap UI" --- Swagger是一个用于设计、构建、记录和使用RESTful Web服务的开源软件框架。它帮助开发人员设计、构建、记录以及使用RESTful Web服务的整个过程。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值