单元测试的写法(JUnit 5 )

单元测试的写法(JUnit 5 )

1 单元测试概念

单元测试时指针对最小的功能单元编写的测试代码，以判定实际结果与期望结果一致。
java中最小的功能单元就是方法。在针对方法的功能进行单元测试时不必关心方法的具体实现逻辑，只要结果与期望一致。方法中改动了代码，如果通过了单元测试，也意味着改动成功。单元测试可以通过mock来取代业务代码逻辑的强依赖性。

2 单元测试规则

单元测试规则

fast：单元测试应该是非常快速的执行完成

no of dependent：单元测试不应该有相互依赖，即不需要固定的执行顺序

repeateable：被测系统不改变，单元测试无论在哪个环境执行多少次，结果都应该一样

self-validating：单元测试必须包含足够多的断言，进行自我验证

3 单元测试写法

3.1 关于mockito

mockito既能mock接口也能mock实体类。

@RunWith注解什么用处

该注解将junit执行类修改为SpringRunner而SpringRunner是SpringFrameWork中测试类SpringJunit4ClassRunner的别名

使用@RunWith(SpringJunit4ClassRunner.class)或@RunWith(SpringRunner.class)

@RunWith就是一个运行器，@RunWith(SpringJUnit4ClassRunner.class),是指让测试运行于Spring测试环境。

3.2 关于@Mock

对于被测试的service,其通过@Resource或@AutoWried注入的bean都使用@Mock注解进行mock

@Mock会把整个对象屏蔽掉，把里面的所有的方法都替换成假的

而@Spy注解只会mock那些我们通过when()等方法隐藏过的方法，而其他的方法则仍会调用自己原来的真正方法。

注解使用，只需在要mock的对象上添加@Mock

import com.jingpin.at.dao.OaMapper;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.Mockito;

import java.util.LinkedList;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.mock;

class OaServiceImplTest {

    @Mock
    private OaMapper oaMapper;

    @Test
    void getOa() {
       //不使用注解要mock的对象
        LinkedList mockList = mock(LinkedList.class);
        //Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁
        //mock调用第1个mockList的元素返回first,不用给mockList使用add添加元素
        //此种行为为打桩
        Mockito.when(mockList.get(0)).thenReturn("first");
        System.out.println(mockList.get(0));
        //mock调用第2个mockList的元素返回异常
        Mockito.when(mockList.get(1)).thenThrow(new RuntimeException());
        System.out.println(mockList.get(1));
        //针对没有打桩的方法调用会返回null
        System.out.println(mockList.get(2));
    }

    @Test
    void init() {
    }
}

3.3 参数匹配器

//使用anyInt()来匹配任意int型参数
Mockito.when(mockList.get(anyInt())).thenReturn("anything");
System.out.println(mockList.get(3));
//使用anyString()来匹配任意String型参数
Mockito.when(mockList.add(anyString())).thenReturn(true);
System.out.println(mockList.add("anything"));
//可以使用自己定义的匹配器argThat(isHaveOneElement())是自定义的参数匹配器
//argThat(Matcher<T> matcher)方法用来应用自定义的规则，可以传入任何实现Matcher接口的实现类
Mockito.when(mockList.addAll(argThat(new IsHaveOneElement()))).thenReturn(true);
System.out.println(mockList.addAll(new ArrayList(Collections.singleton("aa"))));

}

    //自定义参数匹配器的时候需要继承ArgumentMatcher抽象类
    //它实现了Hamcrest框架的Matcher接口，定义了describeTo方法
    //所以我们只需要实现matches方法在其中定义规则即可
    class IsHaveOneElement implements ArgumentMatcher<List> {
        @Override
        public boolean matches(List argument) {
            return ((List) argument).size() == 1;
        }
    }

3.4 使用断言

在测试方法内部，使用断言非常常用，通过断言方法将实际信息与期望结果对比。

主要的断言方法如下：

//hhh 上面截图太长了，方法名相同，参数不同的情况太多啦
//断言
//assertTrue();期待结果为true
//assertFalse();期待结果为false
//assertNotNull();期待结果不为空
int a = 1;
//assertEquals();期待两个变量相等
assertEquals(a, equals(1));
//assertNotEquals();期待两个变量不相等
assertNotEquals(a, 2);
//期待在1秒中结束，休眠500ms，运行成功
assertTimeoutPreemptively(Duration.of(1, ChronoUnit.SECONDS), () -> Thread.sleep(500));
//期待在1秒中结束，休眠500ms，运行失败
assertTimeoutPreemptively(Duration.of(1, ChronoUnit.SECONDS), () -> Thread.sleep(1200));

3.5 异常测试

在代码中经常需要进行异常处理，Junit提供assertThrows()来测试代码是否抛出了所需的异常，其中第一个参数为期望捕捉的指定异常类，第2个参数封装了准备执行的会产生异常的方法，通常可以结合lambda表达式来使用。

@Test
void testInvalidArgument() {
    assertThrows(InvalidArgumentException.class, () -> {
        ObjectName.testMethod("wrong");
    });
}

3.6 条件测试

在进行单元测试时，有时不需要执行某些@Test方法，这种情况下可以用@Disabled来标记某些@Test方法。为什么干脆不写这个方法的测试，而是加上@Test，@Disabled呢？

加上@Disabled，JUnit仍然识别出这是个测试方法，只是暂时不运行。

类似@Disabled这种注解就称为条件测试，JUnit根据不同的条件注解，决定是否运行当前的@Test方法。@EnableOnOs就是一个条件测试判断，下面的例子是指只在mac系统上运行。

@Test
    @EnabledOnOs(OS.MAC)
    void testMac() {
        assertEquals(1, equals(1));
    }

3.7 验证方法

3.7.1 是否被执行、执行次数

mockList.add("once");
//verify函数默认验证是执行一次，times(1)通常被省略
verify(mockList).add("once");
verify(mockList, times(2)).add("once");
//没有被执行过
verify(mockList, never()).add("never");
//至少执行1次
verify(mockList, atLeastOnce()).add("once");
mockList.add("twice");
mockList.add("twice");
//至少执行2次
verify(mockList, atLeast(2)).add("twice");
//至多执行1次
verify(mockList, atMostOnce()).add("once");
//至多执行2次
verify(mockList, atMost(2)).add("twice");
List mock2 = mock(List.class);
List mock3 = mock(List.class);
//验证mock2，mock3是否交互过
verifyZeroInteractions(mock2,mock3);//已过时

3.7.2 执行顺序

//验证mock一个对象的函数执行顺序
mockList.add("first");
mockList.add("second");
//验证先执行add first,后执行add second
InOrder inOrder = inOrder(mockList);
inOrder.verify(mockList).add("first");
inOrder.verify(mockList).add("second");
//验证mock多个对象的函数执行顺序
List list1 = mock(List.class);
List list2 = mock(List.class);
list1.add("first");
list2.add("second");
InOrder inOrder1 = inOrder(list1, list2);
inOrder1.verify(list1).add("first");
inOrder1.verify(list2).add("second");

3.7.3 验证mock对象的方法是否都被验证过

mockList.add("one");
mockList.add("two");
//mockList依次调用了add("one") add("two")
verify(mockList).add("one");
//verifyNoMoreInteractions(mockList);//验证失败
//verifyNoMoreInteractions代表上一次verify之后再无与list的交互
verify(mockList).add("two");
verifyNoMoreInteractions(mockList);//验证成功

3.7.4 @Spy和spy

@Spy注解跟@Mock注解用法相同，只是被@Spy注解的类调用其方法时默认会走真实方法，有返回值返回返回值。@Mock默认不执行，有返回值返回null。

spy与mock用法相同，默认走真实方法

List list = new LinkedList();
//spyList为监控对象
List spyList = spy(list);
//打桩
when(spyList.size()).thenReturn(100);
// 通过spy对象调用真实对象的函数
spyList.add("one");
spyList.add("two");
// 因为size()函数被打桩了,因此这里返回的是100
System.out.println(spyList.size());
List list1 = new LinkedList();

List spyList1 = spy(list);
//当spyList1为空的时候，不能用when().thenReturn()会下标越界
//when(spyList.get(0)).thenReturn("spyList");
//打桩
doReturn("spyList").when(spyList).get(0);
System.out.println(spyList.get(0));