单元测试实战（五）普通类的测试

以下是对DecimalWrapper进行测试的测试类：

package com.aaa.sdk.utils;
 
import java.math.BigDecimal;
import java.math.RoundingMode;
 
import org.junit.jupiter.api.Test;
 
import static org.junit.jupiter.api.Assertions.*;
 
class DecimalWrapperTest {
     
    @Test
    void testConstructBigDecimal() {
        DecimalWrapper d = DecimalWrapper.of(new BigDecimal("1.11"));
        assertEquals("1.11", d.format());
    }
     
    @Test
    void testConstructDouble() {
        DecimalWrapper d = DecimalWrapper.of(1.11);
        assertEquals("1.11", d.format());
    }
     
    @Test
    void testConstructString() {
        DecimalWrapper d = DecimalWrapper.of("1.11");
        assertEquals("1.11", d.format());
    }
     
    @Test
    void testConstructFloat() {
        DecimalWrapper d = DecimalWrapper.of(1.1f);
        assertEquals("1.10", d.format());
    }
 
    @Test
    void testConstructNullParam() {
        try {
            DecimalWrapper.of((String) null);
            fail("should not get here!");
        } catch (NullPointerException npe) {}
 
        try {
            DecimalWrapper.of((Double) null);
            fail("Should not get here!");
        } catch (NullPointerException npe) {}
 
        try {
            DecimalWrapper.of((Float) null);
            fail("Should not get here!");
        } catch (NullPointerException npe) {}
 
        try {
            DecimalWrapper.of((BigDecimal) null);
            fail("Should not get here!");
        } catch (NullPointerException npe) {}
 
    }
 
    @Test
    void testComparison() {
        DecimalWrapper d1 = DecimalWrapper.of(1.1);
        DecimalWrapper d2 = DecimalWrapper.of(1.2);
        DecimalWrapper d3 = DecimalWrapper.of(1.0);
        assertTrue(d1.compareTo(d2) < 0);
        assertTrue(d2.compareTo(d1) > 0);
        assertTrue(d3.compareTo(d1) < 0);
        assertTrue(d3.compareTo(d2) < 0);
 
        DecimalWrapper d4 = DecimalWrapper.of("1.00");
        assertTrue(d3.compareTo(d4) == 0);
 
        DecimalWrapper d5 = null;
        assertTrue(d3.compareTo(d5) > 0);
    }
 
    @Test
    void testToDecimal() {
        DecimalWrapper d1 = DecimalWrapper.of(1.11);
        assertEquals(d1.toBigDecimal(), new BigDecimal("1.11"));
    }
 
    @Test
    void testToDouble() {
        DecimalWrapper d1 = DecimalWrapper.of(1.11);
        assertEquals(d1.toDouble(), 1.11);
    }
 
    @Test
    void testEquals() {
        DecimalWrapper d1 = DecimalWrapper.of(1.12345);
        DecimalWrapper d2 = DecimalWrapper.of(1.12345f);
        DecimalWrapper d3 = DecimalWrapper.of("1.12345");
        DecimalWrapper d4 = DecimalWrapper.of(new BigDecimal("1.12345"));
        assertEquals(d1, d2);
        assertEquals(d2, d3);
        assertEquals(d3, d4);
    }
 
    @Test
    void testRoundDefault() {
        DecimalWrapper d1 = DecimalWrapper.of(1.12385);
        DecimalWrapper d2 = DecimalWrapper.of(1.12385f);
        DecimalWrapper d3 = DecimalWrapper.of("1.12385");
        DecimalWrapper d4 = DecimalWrapper.of(new BigDecimal("1.12385"));
        assertEquals(d1.round(), DecimalWrapper.of("1.12"));
        assertEquals(d2.round(), DecimalWrapper.of("1.12"));
        assertEquals(d3.round(), DecimalWrapper.of("1.12"));
        assertEquals(d4.round(), DecimalWrapper.of("1.12"));
    }
 
    @Test
    void testRound() {
        DecimalWrapper d1 = DecimalWrapper.of(1.12385);
        DecimalWrapper d2 = DecimalWrapper.of(1.12385f);
        DecimalWrapper d3 = DecimalWrapper.of("1.12385");
        DecimalWrapper d4 = DecimalWrapper.of(new BigDecimal("1.12385"));
        assertEquals(d1.round(3), DecimalWrapper.of("1.124"));
        assertEquals(d2.round(3), DecimalWrapper.of("1.124"));
        assertEquals(d3.round(3), DecimalWrapper.of("1.124"));
        assertEquals(d4.round(3), DecimalWrapper.of("1.124"));
        assertEquals(d4.round(3, RoundingMode.DOWN), DecimalWrapper.of("1.123"));
    }
 
    @Test
    void testFormat() {
        DecimalWrapper d1 = DecimalWrapper.of(1.12385);
        assertEquals(d1.format(), "1.12");
        assertEquals(d1.format(3), "1.124");
        assertEquals(d1.format(3, RoundingMode.DOWN), "1.123");
    }
 
    @Test
    void testAdd() {
        DecimalWrapper d1 = DecimalWrapper.of(1.12385);
        DecimalWrapper d2 = DecimalWrapper.of(1.12385);
        assertEquals(DecimalWrapper.of("2.24770"), d1.add(d2));
 
        DecimalWrapper d3 = DecimalWrapper.of(0);
        assertEquals(DecimalWrapper.of("1.12385"), d3.add(d2));
        assertTrue(d3.add(d3).isZero());
    }
 
    @Test
    void testSubtract() {
        DecimalWrapper d1 = DecimalWrapper.of(2.24770);
        DecimalWrapper d2 = DecimalWrapper.of(1.12385);
        assertEquals(DecimalWrapper.of("1.12385"), d1.subtract(d2));
 
        DecimalWrapper d3 = DecimalWrapper.of(0); // change to: 0.0
        assertEquals(DecimalWrapper.of("1.12385"), d2.subtract(d3));
        assertTrue(d2.subtract(d2).isZero());
        assertTrue(d3.subtract(d3).isZero());
    }
 
    @Test
    void testMultiply() {
        DecimalWrapper d1 = DecimalWrapper.of(1.12385);
        DecimalWrapper d2 = DecimalWrapper.of(1.12385);
        assertEquals(DecimalWrapper.of("1.2630388225"), d1.multiply(d2));
        DecimalWrapper d3 = DecimalWrapper.of(0.00);
        assertTrue(d2.multiply(d3).isZero());
 
        DecimalWrapper d4 = DecimalWrapper.of(-1);
        assertEquals(DecimalWrapper.of("-1.12385"), d1.multiply(d4));
    }
 
    @Test
    void testDivide() {
        DecimalWrapper d1 = DecimalWrapper.of(10.0);
        DecimalWrapper d2 = DecimalWrapper.of(3);
        assertEquals(DecimalWrapper.of(3.33), d1.divide(d2));
 
        DecimalWrapper d3 = DecimalWrapper.of(0);
        assertTrue(d3.multiply(d1).isZero());
 
        try {
            d1.divide(d3);
            fail("divide by zero, should not get here!");
        } catch (Exception e){}
    }
 
    @Test
    void testNegate() {
        DecimalWrapper d1 = DecimalWrapper.of(-1.12385);
        assertTrue(d1.isNegative());
        assertFalse(d1.isZero());
        assertFalse(d1.isPositive());
        DecimalWrapper d2 = d1.negate();
        assertTrue(d2.isPositive());
        assertFalse(d2.isZero());
        assertFalse(d2.isNegative());
        assertTrue(d1.add(d2).isZero());
    }
 
}

测试类说明：

测试类的代码和被测类的代码都比较直观，不需做过多说明。

在该类中，我们为被测类的每个公共方法都创建了测试方法，且只用到了JUnit的@Test和Assertions；如果需要事前准备和事后清理工作，还可以加上@BeforeEach、@AfterEach、@BeforeAll、@AfterAll等方法。

第37行的testConstructNullParam是负面测试，测试当传入null值是不允许的，会抛出NullPointerException。

第101行的testRoundDefault、第113行的testRound，是对同一个方法的不同情况（精度）的测试。

私有方法的测试

私有方法不需要测试。对私有方法的测试，应通过调用它的公有方法的测试来进行。直接测试私有方法往往是一种代码“坏味道”。

虽然但是，有时候确实想给私有方法写一个测试，也不是做不到：

package com.aaa.api.auth.filter;
 
import com.aaa.sdk.utils.Utils;
import org.junit.jupiter.api.Test;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
import static org.junit.jupiter.api.Assertions.*;
class AuthNFilterTest {
 
    @Test
    void testExtractUsernameFromToken() throws InvocationTargetException, IllegalAccessException {
        String token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...";
        AuthNFilter filter = new AuthNFilter();
        Method m = Utils.doGetMethod(AuthNFilter.class, "extractUsernameFromToken", String.class);
        //long start = System.currentTimeMillis();
        String user = (String) m.invoke(filter, token);
        //System.out.println("User is " + user + ", used " + (System.currentTimeMillis() - start) + " ms");
        assertEquals("ioriogami", user);
    }
}

第15行，我们new了一个待测试对象。

第16行，我们用反射获取了AuthNFilter类的extractUsernameFromToken私有方法（该方法接受一个String类型的参数），然后在第18行对其进行调用。

 如需对构造方法、私有方法、静态方法、final类和方法进行mock，可以使用powermock提供的增强版Mockito：PowerMockito。

总结

普通类的测试以JUnit简单测试为主，一般不需要Spring上下文。

每一个public方法都有至少一个测试；对不同的情况/分支，建议有多个测试；最好也有负面测试。当然，一个完美的测试类应该测试每个方法的正面行为、负面行为、边缘情况；并应尽可能覆盖所有分支。但在有限的时间内，我们应识别最重要的方面进行测试。

单元测试针对单个类，原则上测试类与被测类一对一。当然也可以针对一组紧密相关的类/接口编写单元测试，比如pagewindow是一个实现无界分页的小模块，由几个接口和类组成，它的单元测试就是针对这一组类的。

Mock的原理是采用字节码生成的方式对要mock的类进行sub-class，然后生成这个子类的对象，以此达到对其行为进行订制的目的。显然，这种方式会受到Java继承机制的限制：静态类/方法、final类/方法、构造器、私有方法等都不能继承，因此就难以订制。

Mockito在2.1.0中加入了对final类/方法的支持。见 https://www.cnblogs.com/yuluoxingkong/p/14813558.html。

powermock提供的增强版Mockito：PowerMockito 则对这些方面提供了全面的支持。