皓慕

单元测试junit

一、介绍

官网：https://junit.org/
JUnit是一个Java语言的单元测试框架，Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何完成功能和完成什么样的功能，Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了

1.1注意事项

测试方法必须使用 @Test 修饰
测试方法必须使用 public void 进行修饰，不能带参数
一般使用单元测试会新建一个 test 目录存放测试代码，在生产部署的时候只需要将 test 目录下代码删除即可
测试代码的包应该和被测试代码包结构保持一致
测试单元中的每个方法必须可以独立测试，方法间不能有任何依赖
测试类一般使用 Test 作为类名的后缀
测试方法使一般用 test 作为方法名的前缀

1.2测试失败说明

Failure：一般是由于测试结果和预期结果不一致引发的，表示测试的这个点发现了问题
error：是由代码异常引起的，它可以产生于测试代码本身的错误，也可以是被测试代码中隐藏的 bug

1.3常用注解

@Test:将一个普通方法修饰成一个测试方法
- @Test(excepted=xx.class): xx.class 表示异常类，表示测试的方法抛出此异常时，认为是正常的测试通过的
- @Test(timeout = 毫秒数) ：测试方法执行时间是否符合预期
@BeforeClass：会在所有的方法执行前被执行，static 方法，全局只会执行一次，而且是第一个运行
@AfterClass：会在所有的方法执行之后进行执行，static 方法，全局只会执行一次，而且是最后一个运行
@Before：会在每一个测试方法被运行前执行一次
@After：会在每一个测试方法运行后被执行一次
@Ignore：所修饰的测试方法会被测试运行器忽略
@RunWith：可以更改测试运行器 org.junit.runner.Runner
@Parameters：参数化注解

1.4Assert类

void assertEquals(boolean expected, boolean actual)：检查预期值和实际值是否相等
void assertTrue(boolean condition)：检查条件为真
void assertFalse(boolean condition)：检查条件为假
void assertNotNull(Object object)：判断对象是否不为空
void assertNull(Object object)：判断对象是否不为空
void assertSame(Object expected, Object actual)：判断两个对象是否指向同一个对象
void assertNotSame(Object expected, Object actual)：判断两个对象是否不指向同一个对象
void assertArrayEquals(expectedArray, resultArray)：判断两个数组是否相等

二、junit4测试案例

2.1普通工程

2.1.1导入依赖

<dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.13.2version>
      <scope>testscope>
dependency>

2.1.2创建一个作为要测试的类

public class Calculate {

    public int add(int a , int b){
        return a + b;
    }

    public int subtract(int a , int b){
        return a - b;
    }

    public int multiply(int a , int b){
        return a * b;
    }

    public int divide(int a , int b){
        return a / b;
    }
}

2.1.3创建测试类

在test目录下与要测试的类相同包路径下创建测试类，也可以选择要测试的类的类名点击右键—Go To—Test进行快捷创建

这里的junit版本选择junit4

public class CalculateTest {

    @BeforeClass
    public static void beforeClass(){
        System.out.println("beforeClass…………");
    }

    @Before
    public void before(){
        System.out.println("before^^^^^^^^");
    }

    @Test
    public void testAdd() {
        Calculate calculate = new Calculate();
        int add = calculate.add(1, 2);
        System.out.println(add);
    }

    @Test
    public void testSubtract() {
        Calculate calculate = new Calculate();
        int subtract = calculate.subtract(3, 1);
        System.out.println(subtract);
    }

    @Test
    public void testMultiply() {
        Calculate calculate = new Calculate();
        int multiply = calculate.multiply(1, 3);
        System.out.println(multiply);
    }

    @Test
    public void testDivide() {
        Calculate calculate = new Calculate();
        int divide = calculate.divide(10, 2);
        System.out.println(divide);
    }

    @AfterClass
    public static void afterClass(){
        System.out.println("afterClass…………");
    }

    @After
    public void after(){
        System.out.println("after^^^^^^^");
    }
}

2.2junit4集成SpringBoot工程

2.2.1导入依赖

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.4.3version>
parent>
  
<dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starterartifactId>
dependency>

<dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-testartifactId>
      <scope>testscope>
dependency>

<dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.13.2version>
      <scope>testscope>
dependency>

2.2.2 创建springboot启动类，并创建要测试的类

@SpringBootApplication
public class SpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootApplication.class,args);
    }
}

public class Calculate {

    public int add(int a , int b){
        return a + b;
    }

    public int subtract(int a , int b){
        return a - b;
    }

    public int multiply(int a , int b){
        return a * b;
    }

    public int divide(int a , int b){
        return a / b;
    }
}

2.2.3 创建测试类

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest()
public class SpringBootJunit4 {
    @Test
    public void add(){
        Calculate calculate = new Calculate();
        int add = calculate.add(1, 2);
        System.out.println(add);
    }
}

三、junit5

3.1组成结构

JUnit Platform: 是在JVM上启动测试框架的基础，不仅支持Junit自制的测试引擎，其他测试引擎也都可以接入
JUnit Jupiter: 提供了JUnit5的新的编程模型，是JUnit5新特性的核心。内部包含了一个测试引擎，用于在Junit Platform上运行
JUnit Vintage: 由于JUint已经发展多年，为了照顾老的项目，其提供了兼容JUnit4.x,Junit3.x的测试引擎

3.2引入的依赖


<dependency>
    <groupId>org.junit.jupitergroupId>
    <artifactId>junit-jupiterartifactId>
    <version>5.7.1version>
    <scope>testscope>
dependency>


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-testartifactId>
    <scope>testscope>
dependency>

3.3常用注解

@Test：被注解的方法是一个测试方法，与junit4相同
@BeforeAll：static 方法，会在所有的方法执行前被执行，全局只会执行一次而且是第一个运行，与junit4中的BeforeClass一样
@AfterAll：static 方法，会在所有的方法执行后被执行，全局只会执行一次而且是最后一个运行，与junit4中的AfterClass一样
@BeforeEach：被注解的方法将在当前类的每个@Test方法前执行，与junit4中的Before一样
@@AfterEach：被注解的方法将在当前类的每个@Test方法后执行，与junit4中的After一样
@Disable：被注解的方法不会执行，与junit4中的Ignore一样
@DisplayName：测试类或方法的显示名称
@Tag：为测试类或方法加标签
@RepeatedTest：额外重复执行，根据参数额外执行指定次数
@Nested：嵌套测试
@Timeout：表示测试方法超过了指定时间将返回错误，可以有两个参数，一个为时间，一个为时间单位，默认为秒

3.4断言 static org.junit.jupiter.api.Assertions.*

assertEquals：判断两个对象是否相等
assertNotEquals：判断两个对象是否不相等
assertSame：判断两个对象是否指向通个对象
assertNotSame：判断两个对象是否不指向通个对象
assertTrue：判断是否为true
assertFalse：判断是否为false
assertNull：判断是否为空
assertNotNull：判断是否不为空

3.5前置条件 org.junit.jupiter.api

类似于断言，只不过不满足的断言会使得测试方法失败，而不满足的前置条件只会使得测试方法的执行终止，可以看成是测试方法执行的前提，当该前提不满足时，就没有继续执行的必要

3.6代码案例

import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest
public class SpringBootJunit5 {

    @BeforeAll
    public static void before(){
        System.out.println("before^^^^^^^");
    }

    @RepeatedTest(2)
    @DisplayName("测试一下")
    @Test
    public void add(){
        Calculate calculate = new Calculate();
        int add = calculate.add(1, 2);
        System.out.println(add);
    }

    @Test
    @Timeout(value = 500 , unit = TimeUnit.MILLISECONDS)
    public void divide(){
        Calculate calculate = new Calculate();
        int divide = calculate.divide(8, 2);
        System.out.println(divide);
        try {
            Thread.sleep(501);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 如果预期值与实际值一致，正常执行
     * 如果预期值与实际值不一样，打印错误信息和预期值、实际值
     */
    @Test
    public void multiply(){
        Calculate calculate = new Calculate();
        int multiply = calculate.multiply(1, 2);
        System.out.println(multiply);
        assertEquals(multiply ,2 , "两个对象一样");
    }

    @Test
    public void subtract(){
        Assumptions.assumeTrue(false,"不满足就不执行");
        Calculate calculate = new Calculate();
        int subtract = calculate.subtract(5, 1);
        System.out.println(subtract);
    }

    @AfterAll
    public static void after(){
        System.out.println("after^^^^^^^");
    }
}

注解@DisplayName和@RepeatedTest执行效果，使用@RepeatedTest注解会另加执行指定次数所标注的方法

注解@Timeout执行效果，超过指定时间会失败

断言不一致的执行效果，程序会失败，并指出预期值与实际值

前置条件不一致的执行效果，方法不执行，打印指定的消息

3.7 嵌套测试

JUnit 5 通过 Java 中的内部类和@Nested 注解实现嵌套测试，将相关的测试方法组织在一起，在内部类中可以使用@BeforeEach 和@AfterEach 注解，而且嵌套的层次没有限制
外层测试方法的执行不会驱动内层方法，当内层方法有 before 或 after 等注解调用外层测试方法，并不会驱动其提前或最后执行
内层方法的执行，可以驱动外层方法，当外层方法定义了某一数据结果时，内层测试方法可以直接调用该结构

import org.junit.jupiter.api.*;
import org.springframework.boot.test.context.SpringBootTest;

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

    @BeforeAll
    public static void before(){
        System.out.println("beforeAll^^^^^^");
    }

    @Test
    @DisplayName("外层测试方法1")
    void outer1() {
        System.out.println("在嵌套测试情况下，外层的test不能驱动内层的beforeAll等方法,内层的test可以驱动外层");
    }

    @Test
    @DisplayName("外层测试方法2")
    String outer2(){
        return "外层测试方法2";
    }

    @Nested
    @DisplayName("内部类1")
    class InnerClass1{

        @BeforeEach
        void innerClass1BeforeEach() {
            System.out.println("InnerClass1BeforeEach1^^^^^^^");
        }

        @Test
        @DisplayName("内部类1内部方法1")
        void InnerClass1Method1() {
            String s = outer2();
            System.out.println("内部类1内部方法1 " +s);
        }

        @Nested
        @DisplayName("内部类2")
        class InnerClass2 {

            @BeforeEach
            void innerClass2BeforeEach() {
                System.out.println("InnerClass2BeforeEach1^^^^^^^^^^");
            }

            @Test
            @DisplayName("内部类2内部方法2")
            void InnerClass2Method2() {
                System.out.println("内部类2内部方法2");
            }
        }
    }
}

执行整个类效果

3.8参数化测试

可以指定测试方法的输入参数

@ValueSource：为参数化测试指定入参来源，支持八大基础类以及String类型、Class类型
@NullSource：表示为参数化测试提供一个null的入参
@EnumSource：表示为参数化测试提供一个枚举入参
@CsvFileSource：表示读取指定CSV文件内容作为参数化测试入参
@MethodSource：表示读取指定方法的返回值作为参数化测试入参，方法的返回值为流

package com.haomu;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.stream.Stream;

@SpringBootTest
public class ParametricTest {

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

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

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