05_SpringBoot_Junit5

骑猪看日落 2023-10-03 22:51 7阅读 0赞

![e405916a24ff03c8e13842c02f7bedbf.png][]

springboot 2.2.0开始引入Junit5作为单元测试的默认库  
JUnit5和之前的版本有很大的不同,由单个子项目的几个不同模块组成  
JUnit Platform ,是在JVM上启动测试框架的技术,不仅支持Junit自己的测试引擎,其他的测试引擎也可以  
JUnit Jupiter,提供了Junit5的最新的编程模型,是Junit5 的核心,内部包含了一个测试引擎,用于在Junit Platform上运行  
JUnit Vintager: 提供了兼容Junit4/3 的测试引擎

Junit5 = JUnit Platform+ JUnit Jupiter+JUnit Vintager

![3ab836f0261e0f00f9ad51e4e22e3847.png][]

![72d427bc59a9170daa3778c297f30c05.png][]

Junit支持Spring中的注解,测试起来比较方便, @Autowired @Transactional 等

![83fd3adf85e928777a0700abea33a574.png][]

package com.msb;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.msb.mapper.DeptMapper;
    import com.msb.pojo.Dept;
    import com.msb.service.DeptService;
    import org.junit.jupiter.api.*;
    import org.junit.jupiter.api.extension.ExtendWith;
    import org.junit.platform.commons.annotation.Testable;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.boot.test.context.SpringBootTestContextBootstrapper;
    import org.springframework.test.context.BootstrapWith;
    import org.springframework.test.context.junit.jupiter.SpringExtension;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    @SpringBootTest // 使用springboot的容器功能
    /*@BootstrapWith(SpringBootTestContextBootstrapper.class)
    @ExtendWith({SpringExtension.class})*/
    @DisplayName("Junit5测试类")// 测试类描述
    class SpringbootMybatisplusApplicationTests2 {
        @Autowired
        private DeptMapper deptMapper;
        @BeforeEach
        public void testForeach(){
            System.out.println("beforeach");
        }
        @AfterEach
        public void testAftereach(){
            System.out.println("aferEach");
        }
        @BeforeAll
        public static void beforeAll(){
            System.out.println("beforall");
        }
        @AfterAll
        public static void aferAll(){
            System.out.println("afterAll");
        }
        @RepeatedTest(3)// 重复测试3次
        @Timeout(value = 10000,unit = TimeUnit.MILLISECONDS)// 超时时间设置
        @DisplayName("Junit测试方法1")
        @Test
        public void test1(){
            System.out.println("a");
            System.out.println(deptMapper);
        }
        @Disabled// 设置不可用
        @DisplayName("Junit测试方法2") // 方法描述
        @Test
        public void test2(){
            System.out.println("b");
        }
    }

断言机制  
断定某件事情,一定会发生,如果没有发生,那就是出现了问题,所欲的测试运行结束后,会有一个详细的断言报告  
用来对测试需要满足的条件进行验证,这些断言方法都是org.junit.jupiter.api.Assertions中的静态方法,  
简单断言

![39538fb1f1c7e65f7b3b106100ddb032.png][]

package com.msb;
    import org.junit.jupiter.api.Assertions;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    import org.springframework.boot.test.context.SpringBootTest;
    import java.time.Duration;
    import java.util.concurrent.TimeUnit;
    @SpringBootTest
    @DisplayName("Junit5断言测试类")
    class SpringbootMybatisplusApplicationTests3 {
        @DisplayName("简单断言1")
        @Test
        public void testAssertions1(){
            int add = add(1, 2);
            Assertions.assertEquals(6,add,"add结果计算错误");
        }
        public int add(int a,int b){
            return a+b;
        }
        @DisplayName("简单断言2")
        @Test
        public void testAssertions2(){
            String s =new String("xxx");
            String s2=new String("abc");
            Assertions.assertEquals(s,s2,"String对象不一样");
        }
        // 组合断言
        @DisplayName("组合断言")
        @Test
        public void testAssertAll(){
            Assertions.assertAll("AssertAll",
                    ()-> Assertions.assertTrue(true&& false),
                    ()-> Assertions.assertEquals(1,2));
        }
        // 异常断言 认为应该会出现异常
        @DisplayName("异常断言")
        @Test
        public void testAssertException(){
            Assertions.assertThrows(ArithmeticException.class, ()->{ int i=1/0;}, "没有抛出异常");
        }
        // 超时断言 判断有没有超时
        @DisplayName("超时断言")
        @Test
        public void testAssertTimeOut(){
            Assertions.assertTimeout(Duration.ofMillis(1000),()-> Thread.sleep(5000));
        }
        // 快速失败
        @DisplayName("快速失败")
        @Test
        public void testFail(){
            if(true){
                Assertions.fail("测试 失败");
            }
        }
    }

前置条件(assumptions假设)  
类似于断言,不同在于,不满足断言回事方法测试失败,而不满足的前置条件会使得的是方法的执行中止,前置条件可以看成是测试方法执行的前提,当条件不满足时,就没有继续执行的必要

package com.msb;
    import org.junit.jupiter.api.Assertions;
    import org.junit.jupiter.api.Assumptions;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    import org.springframework.boot.test.context.SpringBootTest;
    import java.time.Duration;
    @SpringBootTest
    @DisplayName("Junit5测试前置条件")
    class SpringbootMybatisplusApplicationTests4 {
        @DisplayName("测试前提条件")
        @Test
        public void testAssumptions(){
            // 假设为true,才会执行
            Assumptions.assumeTrue(false,"结果不是true");
            System.out.println("后面的测试代码前提条件");
        }
        @DisplayName("简单断言1")
        @Test
        public void testAssertions1(){
            int add =10;
            Assertions.assertEquals(6,add,"add结果计算错误");
            System.out.println("后面的测试代码简单断言");
        }
    }

嵌套测试

package com.msb;
    import org.junit.jupiter.api.*;
    import static org.junit.jupiter.api.Assertions.*;
    import java.util.EmptyStackException;
    import java.util.Stack;
    @DisplayName("嵌套测试")
    class SpringbootMybatisplusApplicationTests5 {
        Stack<Object> stack;
        @Test
        @DisplayName("is instantiated with new Stack()")
        void isInstantiatedWithNew() {
            new Stack<>();
            // 外层的测试不能驱动内层的测试方法
            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 // 内层Test可以驱动外层的BeforeEach
                void pushAnElement() {
                    stack.push(anElement);
                }
                @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());
                }
            }
        }
    }

参数化测试

![05885a94fbc99673d2870d58bcb9cf9d.png][]

![27a98d37b145d3d90bca93beea34bc2b.png][]

package com.msb;
    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("参数化测试")
    class SpringbootMybatisplusApplicationTests6 {
        @ParameterizedTest
        @ValueSource(ints = { 1, 2, 3 })
        void testWithValueSource(int argument) {
            System.out.println(argument);
            assertTrue(argument > 0 && argument < 4);
        }
        @ParameterizedTest
        @MethodSource("stringProvider")
        void testWithExplicitLocalMethodSource(String argument) {
            assertNotNull(argument);
        }
        static Stream<String> stringProvider() {
            return Stream.of("apple", "banana");
        }
    }

[e405916a24ff03c8e13842c02f7bedbf.png]: https://img-blog.csdnimg.cn/img_convert/e405916a24ff03c8e13842c02f7bedbf.png
[3ab836f0261e0f00f9ad51e4e22e3847.png]: https://img-blog.csdnimg.cn/img_convert/3ab836f0261e0f00f9ad51e4e22e3847.png
[72d427bc59a9170daa3778c297f30c05.png]: https://img-blog.csdnimg.cn/img_convert/72d427bc59a9170daa3778c297f30c05.png
[83fd3adf85e928777a0700abea33a574.png]: https://img-blog.csdnimg.cn/img_convert/83fd3adf85e928777a0700abea33a574.png
[39538fb1f1c7e65f7b3b106100ddb032.png]: https://img-blog.csdnimg.cn/img_convert/39538fb1f1c7e65f7b3b106100ddb032.png
[05885a94fbc99673d2870d58bcb9cf9d.png]: https://img-blog.csdnimg.cn/img_convert/05885a94fbc99673d2870d58bcb9cf9d.png
[27a98d37b145d3d90bca93beea34bc2b.png]: https://img-blog.csdnimg.cn/img_convert/27a98d37b145d3d90bca93beea34bc2b.png