3. springboot中常用的测试方法

CAFEBABE 34

已于 2022-05-11 18:02:52 修改

阅读量952

点赞数 1

分类专栏： springboot 文章标签： java spring boot intellij-idea

于 2022-05-11 18:02:38 首次发布

本文链接：https://blog.csdn.net/hznb_369/article/details/124537776

版权

springboot 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

一、常用的测试注解

@DisplayName(“测试displayName注解”) 注明要测试的方法名

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

@Disabled 标注过期的测试

	@Disabled
    @DisplayName("测试displayName注解2")
    @Test
    void testDisplayName2(){
        System.out.println(2);
    }

@Timeout(value = 5,unit = TimeUnit.MILLISECONDS)

	@Timeout(value = 5,unit = TimeUnit.MILLISECONDS)
    @Test
    void testTimeout() throws InterruptedException {
        Thread.sleep(5);
    }

@BeforeEach 在所有测试方法开始前执行

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

@AfterEach 在所有测试方法执行完之后执行

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

@BeforeAll 属于测试类的方法只执行一次在一开始就执行

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

@AfterAll 属于测试类的方法在所有测试执行完之后执行

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

@RepeatedTest(5) 设置测试次数

	@RepeatedTest(5)
    @Test
    void test3(){
        System.out.println(5);
    }

二、断言

定义一个类中的方法

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

测试简单断言

	/**
     * 前面断言失败，后面断言不会执行
     */
    @DisplayName("测试简单断言")
    @Test
    void testSimpleAssertion(){
        int cal = cal(2, 3);
        assertEquals(5, cal, "业务逻辑计算失败");
        String s1 = " a";
        String s2 = " b";
        String s3 = " a" + " b";
        assertSame((s1 + s2), s3, "不是同一个对象");
    }

assertArrayEquals 比较两个对象的内容是否一致

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

组合断言

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

异常断言

	@DisplayName("异常断言")
    @Test
    void testException(){
        /**
         * 断定业务逻辑一定会出现异常
         */
        assertThrows(ArithmeticException.class,() -> {
             int i = 10 / 1;
        },"业务逻辑不应该正常运行");
    }

快速失败

	@DisplayName("快速失败")
    @Test
    void testFail(){
        fail("测试失败");
    }

前置条件

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

三、嵌套测试

@DisplayName("嵌套测试")
public class TestingAStackDemo {
    Stack<Object> stack;

    /**
     * 外层测试不能访问内层测试的beforeEach
     */
    @Test
    @DisplayName("is instantiated with new Stack()")
    void isInstantiatedWithNew() {
        new 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可以驱动外层的beforeEach
             */
            @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());
            }
        }
    }
}

五、参数化测试

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

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

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