SpringBoot教程(14) JUnit5详解 断言 assertEquals assertSame assertThrows assertThat

一、前言

断言，简单理解就是用来判断的语句。判断待测试的代码的结果和我们期望的结果是否一致。如果不一致，则说明这个UT失败了。

我们最最常见的断言就是assertEquals，判断值是否相等。JUnit5的断言非常丰富，下面举例几个工作中常用的断言，还有第三方库断言也会介绍下。

二、JUnit5断言

1. assertEquals 和 assertNotEquals

assertEquals第一个参数是期望的值，第二个参数是待测试方法的实际返回值。判断两者的值是否相等，换言之不判断类型是否相等。

Assertions.assertEquals(expected, actual);

第三个参数message是可选的，写判断失败的提示信息。
Assertions.assertEquals(expected, actual, message);

测试1：
虽然a和b类型不同，但依旧判断是成功的。

int a = 1;
long b = 1L;
Assertions.assertEquals(a, b);

测试2：
虽然a和b是指向不同的对象，但它们值相同，依旧判断是成功的。

UserInfo a = new UserInfo("亚瑟", "123");
UserInfo b = new UserInfo("亚瑟", "123");
Assertions.assertEquals(a, b);

assertNotEquals是与assertEquals相反的判断。
assertNotEquals第一个参数是你不期望的值，第二个参数是待测试方法的实际返回值。判断两者的值是否不相等，不相等则UT成功。

Assertions.assertNotEquals(unexpected, actual);

第三个参数message是可选的，写判断失败的提示信息。
Assertions.assertNotEquals(expected, actual, message);

2. assertSame 和 assertNotSame

assertSame和assertEquals有些许不同，assertSame不光判断值是否相同，还判断类型是否相同。
对于对象，就是判断两者的引用是否是同一个。
测试1：

int a = 1;
long b = 1L;
long c = 1L;

b和c比较，判断成功，因为他们的类型也相同。
Assertions.assertSame(b, c);

a和b比较，判断失败，因为他们的类型不相同。
Assertions.assertSame(a, b);

测试2：

UserInfo a = new UserInfo("亚瑟", "123");
UserInfo b = new UserInfo("亚瑟", "123");
UserInfo c = b;

b和c比较，判断成功，因为他们的引用是同一个。
Assertions.assertSame(b, c);

a和b比较，判断失败，因为他们的引用不相同。
Assertions.assertSame(a, b);

assertNotSame就是和assertSame 相反的判断，这里就不赘述了。

 Assertions.assertNotSame(unexpected, actual);
 Assertions.assertNotSame(unexpected, actual, message);

3. assertNull 和 assertNotNull

• assertNull ：是Null，则判断UT成功
• assertNotNull：不是Null，则判断UT成功

Assertions.assertNull(actual);

Assertions.assertNotNull(actual);

4. assertTrue 和 assertFalse

• assertTrue ：是True，则判断UT成功
• assertFalse ：是False，则判断UT成功

Assertions.assertTrue(boolean condition);

Assertions.assertFalse(boolean condition);

5. assertThrows

• 判断executable方法执行过程中是否抛出指定异常。
• 如果没有抛出异常，或者抛出的异常类型不对，则判断UT失败。

Assertions.assertThrows(Class<T> expectedType, Executable executable);

Assertions.assertThrows(Class<T> expectedType, Executable executable, String message);

测试1：
因为errorMethod()必然会抛出ArithmeticException，所以testAssertThrows()这个UT判断成功。

 @Test
 void testAssertThrows() {
    Assertions.assertThrows(ArithmeticException.class, () -> errorMethod());
 }

 private void errorMethod() {
     int a = 1/0;
 }

测试2：
因为errorMethod2()中，try catch了ArithmeticException ，没有抛出，所以testAssertThrows2()判断失败。

@Test
void testAssertThrows2() {
    Assertions.assertThrows(ArithmeticException.class, () -> errorMethod2());
}

private void errorMethod2() {
    try {
        int a = 1/0;
    } catch (ArithmeticException e){
        System.out.println(e.getMessage());
    }
}

运行结果：

/ by zero

org.opentest4j.AssertionFailedError: Expected java.lang.ArithmeticException to be thrown, but nothing was thrown.

6. assertDoesNotThrow

• assertDoesNotThrow判断测试方法是否抛出异常，如果没有抛出任何异常，则判断UT成功。

测试1：
因为rightMethod()没有抛出异常，则判断UT成功。

@Test
void testAssertDoesNotThrow() {
    Assertions.assertDoesNotThrow(() -> rightMethod());
}

private void rightMethod() {
    int a = 1/1;
}

7. assertAll

assertAll判断一组断言是否都成功，都成功，才判断整个UT成功。

Assertions.assertAll(
        () -> Assertions.assertEquals(1, 1),
        () -> Assertions.assertNotEquals(1, 2),
        () -> Assertions.assertNull(null)
);

三、第三方库断言

我们在项目中还经常看到assertThat这个断言，这个是第三方库的，AssertJ, Hamcrest他们都有这个assertThat。

但是从语法上我更加喜欢AssertJ的，感觉更加直观，易于理解。这里我就放几个简单的例子，具体的意思大家看方法名都能看懂。

@Test
void testAssertThat() {
    assertThat(testAdd(1, 2)).isEqualTo(3);
    assertThat(testAdd(1, 2)).isNotEqualTo(4);
    assertThat(testAdd(0, 0)).isZero();
    assertThat(testAdd(1, 2)).isNotZero();
    assertThat(returnNull()).isNull();
    assertThat(testAdd(1, 2)).isNotNull();
    assertThat(returnTrue()).isTrue();
    assertThat(returnFalse()).isFalse();
    assertThat(new ArrayList<>()).isEmpty();
    assertThat(getStringList()).hasSize(3);
    assertThat(getStringList()).contains("A");
    assertThat(getStringList()).containsNull();
    assertThat(Optional.of("A")).hasValue("A");
    assertThat("I am good").containsPattern("I am");
}

public Object returnNull() {
    return null;
}
public int testAdd(int a, int b){
    return a + b;
}
public boolean returnTrue() {
    return true;
}
public boolean returnFalse() {
    return false;
}
public List<String> getStringList() {
    List a = new ArrayList();
    a.add("A");
    a.add("B");
    a.add(null);
    return a;
}

四、结语

断言还是写UT的最最基本的知识，一定要牢牢的掌握，尤其是要区分assertEquals和assertSame的区别，不能混淆。

现在项目很多都是Web项目，必然用到SpringMVC，那么对于接口的测试，就得用到Mock了，这个在下一篇博客再细细道来。