Junit单元测试

      LLT是测试系统的一部分，主要是由代码开发人员来编写，Mock的意思是效仿模仿的意思，就是最测试过程中不需要的一些类和方法模拟出相应的返回值，称为打桩，测试关注的是一个类或方法的结果而不是过程调用，打桩涉及到不同的类，有返回值、无返回值、参数验证、静态类静态方法、final方法等不同的方式。

  流行的Mock工具如jMock、EsayMock、Mockito等不能mock静态、final、私有方法

 

PowerMock中的注释

1. 程序运行顺序注释

1）Test将一个普通的方法装饰成为一个测试方法

2）@BeforeClass 它会在所有的方法运行之前进行执行，static修饰

3）@AfterClass 它会在所有的方法运行结束之后进行执行，static修饰

4）@Before 会在每个测试方法运行之前执行一次

5）@After 会在每个测试方法运行之后执行一次

其中@Before @Test @After 这三个标签是组成执行的。有几个@Test，就会执行多少次。

2. 其他运行注解

1）@RunWith 可以修改测试运行期 org.junit.runner.Runner，当需要mock私有方法调用的私有方法是，需要加上@RunWith(PowerMockRunner.class)

2）@PrepareForTest 在使用mock是，首先要在该项添加mock的类@PrepareForTest({类名.class})

@PrepareForTest 注解和@RunWith注解是结合使用的，不要用单独使用它们中的任何一个，否则不起作用，当使用PowerMock和去mock静态，final或者私有方法时，需要机上两个注解。

 

常用的Mock方法：

1.Mock普通对象（有返回值）

public class Calculator{
    public int Add(int a, int b){
        return a + b;
    }
}

Mock方法如下（这里不需要添加PrepareForTest 和RunWith注解）

@Test
public void testAdd(){
    Calculator calculator = PowerMockito.mock(Calculator.class);
    PowerMockito.when(calculator.Add(Mockito.anyInt(), Mockito.anyInt())).thenReturn(10);
    assertEquals(10, calculator.Add(1, 1));
}

2. Mock普通对象（无返回值）

public class Calculator{
    public void print(){
        System.out.println("Hello World");
    }
}

Mock方法如下（这里不需要添加PrepareForTest 和RunWith注解）

 

@Test
public void testPrint(){
    Calculator calculator = PowerMockito.mock(Calculator.class);
    PowerMockito.doNothing().when(calculator).print();
    calculator.print();
    //验证Mock对象被调用
    Mockito.verify(calculator).print();
}

 

3. Mock静态方法

public class ClassThatContainsStaticMethod(){
    public static String getUserName(int id){
        String string = "UserName" + id;
        return string;
    }
}

Mock方法如下（这里不需要添加PrepareForTest 和RunWith注解）

@RunWith(PowerMockito.class)
@PreparaForTest(ClassThatContainsStaticMethod.class)
pulic class testClassThatContainsstaticMethod{
    @Test
    public void testGetUserName() throws Exception{
        PowerMockito.mockStatic(ClassThatContainsStaticMethod.class);
        PowerMockito.when(ClassThatContainsStaticMethod.getUserName(Mockito.anyInt())).thenReturn(null);
        assertEquals(ClassThatContainsStaticMethod.getUserName(123), null);
    }
}

4. Mock私有方法

使用PowerMockito.method获取Method对象调用私有方法，除此之外，还有Whitebox.InvokeMethod直接调用，在此不做说明；

public class Calculator{
    private int addPrivate(int a, int b){
        return a + b;
    }
}

Mock方法如下：

@Test
public void testAddPrivate() throws Exception{
    Calculator calculator = PowerMockito.mock(Calculator.class);
    PowerMockito.when(calculator, "addPrivate", Mockito.anyInt(), Mockito.anyInt).thenReturn(10);

    Method method = PowerMockito.method(Calculator.class, "addPrivate", int.class, int.class);
    int result = (Integer) method.invoke(calculator, 1,1);
    assertEquals(10, result)
}

5. Mock final类或者方法

public final class Calculator{
    public final int add(int a, int b){
        return a + b;
    }
    public final void addVoid(int a, int b){
        System.out.println(a + b);
    }
}

Mock方法如下：

@RunWith(PowerMockito.class)
@PreparaForTest(Calculator.class)
public class CalculatorTest{
    @Test
    public void testAdd(){
        Calculator calculator PowerMockito.mock(Calculator.class);
        PowerMockito.when(calculator.add(Mockito.anyInt(), Mockito.anyInt())).thenReturn(10);
        int result = calculator.add(1,1);
        assertEquals(result, 10);
    }
    @Test
    public void testAddVoid(){
        Calculator calculator = PowerMockito.mock(Calculator.class);
        PowerMockito.doNothing().when(calculator).addVoid(Mockito.anyInt(), Mockito.anyInt());
        calculator.addVoid(100,100);
        Mockito.verify(calculator).addVoid(100,100);
    }
}

6. Mock构造函数

类一：

public class ClassUnderTest(){
    public boolean callFinalMethod(){
        ClassDependency classDependency = new ClassDependency();
        return classDependency.isAlive();
    }
}

类二：

public class ClassDependency{
    public final boolean isAlive(){
        return false;
    }
}

Mock方法如下（whenNew创建对象是若不成功（如无对应构造函数））会抛出异常，讲义在test块抛出异常而不是用try。。。catch捕获，这样方便问题定位。

@RunWith(PowerMockito.class)
@PreparaForTest({ClassUnderTest.class, ClassDependency.class})
public class TestClassUnderTest{
    @Test
    public void testCallFinalMethod() throws Exception{
        ClassDependency dependency = PowerMockito.mock(ClassDependency.class);
        //该项创建可能会抛出异常
        PowerMockito.whenNew(ClassDependency.class).withNoArguments().thenReturn(dependency);
        ClassUnderTest classUnderTest = new ClassUnderTest();
        Assert.assertEquals(classUnderTest.callFinalMethod());
    }
}

7. 反射设置变量的值

该方法主要是使用WhiteBox的setInternalState方法对变量在某个类中进行替代，模块中代码中经常用该方法mock掉数据库查询的操作。用本地化的mock数据库操作（如查询map对象替代）

public class ReflectObject{
    private String privateStr = "str";
    protected String protectedStr = "str";
    private static String staticStr = "str";

    public String getPrivateStr(){
        return privateStr;
    }

    public String getProtectedStr(){
        return protectedStr;
    }

    public static String getStaticStr(){
        return staticStr;
    }
}

Mock方法如下：

public class ReflectObjectTest(){
    @Test
    public void testReflect() throws Exception{
        ReflectObject reflect = new ReflectObject();
        WhiteBox.setInternalState(reflect, "privateStr", "privateStr");
        WhiteBox.setInternalState(reflect, "protectedStr", "protectedStr");
        WhiteBox.setInternalState(reflect, "staticStr", "staticStr");

        assertEquals("privateStr", reflect.getPrivateStr());
        assertEquals("protectedStr", reflect.getProtectedStr());
        assertEquals("staticStr", reflect.getStaticStr());
    }
}

8. Mock静态方法抛异常

public class ThrowsException{
    public static void throwsException() throws RuntimeException{
        //do nothing
    }
}

Mock方法如下：

public class ThrowsException{
    @Test(expected=RuntimeException.class)
    public void testThrowsException(){
        PowerMockito.mockStatic(ThrowsException.class);
        PowerMockito.doThrows(new RuntimeException("Test exception")).when(ThrowsException);
        ThrowsException.throwsException();
    }
}