2 Mocking

JMockit提供了两套API，一套叫做Expectations，用于基于行为的单元测试；一套叫做Faking，用于基于状态的单元测试。

基于Expectations的单元测试创建mock对象，并且record相应的行为，之后调用被测代码（CodeUnderTest），然后进行verify。

Mocking主要考察被测试类与其依赖之间是否正确交互，交互的形式为方法调用。也就是说，Mocking考察被测试类是否正确调用了其依赖，正确调用包括：

• 调用了那些方法
• 通过怎样的参数
• 调用了多少次
• 调用的相对顺序

关于Mocking和Faking，有两篇文章对其进行了区分：
Mocks Aren't Stubs
Stub, Mock and Proxy Testing

2.1 创建并使用mock对象

JMockit可以mock任意class、interface。可以将mock对象声明为域或者方法的参数。默认情况下，mock对象的所有 非private 的方法（包括除了object的其他继承方法）都会被mock，对这些方法的调用不会执行原有代码，而是会转交给JMockit处理。进行mock风格的测试需要三个步骤：expectation--> 方法调用 --> verication，示例如下：

@Mocked Dependency mockedDependency

@Test
public void test(final @Mocked AnotherDenpendency anotherDependency) {
    new Expectations() {{
        mockedDependency.mockedMethod();
        result = 1;
    }};

    codeUnderTest();

    new Verifications(){{
        anotherDependency.anotherMethod();
        times = 1;
    }};
}

JMockit会对@Mocked注解的对象进行依赖注入，所以在Expectation、Verication以及CodeUnderTest中可以直接使用mock对象，不需要手动实例化。

在CodeUnderTest中通过new创建了一个Dependency并调用了其方法，JMockit会自动将这个方法调用转移到mock对象上。

public class CodeUnderTest {
    public int testMethod() {
        Dependency dependency = new Dependency();
        return dependency.mockMethod();
    }
}

public class Dependency {
    public int mockMethod() {
        return 1;
    }
}

Dependency类的mockMethod方法原本返回值为1，在Expectation中将其返回值设置为2，则在测试过程中该方法将会返回2。

@Mocked
Dependency dependency;

@Test
public void TestMethod() throws Exception {
    new NonStrictExpectations() {{
        dependency.mockMethod();
        result = 2;
    }};

    CodeUnderTest codeUnderTest = new CodeUnderTest();
    assertEquals(2, codeUnderTest.testMethod());
}

2.2 Expectations

Expectations中定义了mock对象将会被调用的方法以及方法的返回值。Expectations中出现的方法必须被调用，而调用的方法不必全部出现在Expectation中。

但是，如果定义了mock对象,并在测试代码中调用了它的某个方法，而该方法没有出现在Expectation中，JMockit并不会执行其原有代码，而是返回null或者原始类型的初始值。例如：

public class CodeUnderTest {
    public int testMethod() {
        Dependency dependency = new Dependency();
        return dependency.mockMethod();
    }
}

public class Dependency {
    public int mockMethod() {
        return 1;
    }
}

@RunWith(JMockit.class)
public class MyTest {

    @Mocked
    Dependency dependency;

    @Test
    public void TestMethod() throws Exception {
        CodeUnderTest codeUnderTest = new CodeUnderTest();
        assertEquals(0, codeUnderTest.testMethod());
    }
}

2.3 record-replay-verify模型

record : 录制将要被调用的方法和返回值
replay：调用录制的方法
verify：基于行为的验证

在record阶段实例化Expectations， 在verify阶段实例化Verifications。一个测试方法可以包括任意个（包括0）Expectation/Verification。

@Test
public void testMethod(Parameter p) {
    //常规准备代码
    
    //record
    new Expectations(){};
    
    //replay
    //调用测试代码
    
    //verify
    new Verifications(){};
    
    //其他验证代码
}

2.4 Regular v.s. Strict Expectation

NonStrictExpections中的方法至少被调用一次，否则会出现missing invocation错误。之所以说它是常规的，是因为其中的方法可以调用多次，也可以颠倒顺序，其中没出现的方法也可以调用。

StrictExpectations中方法调用的次数和顺序都必须严格执行。同时，如果出现了在StrictExpectations中没有声明的方法，会出现unexpected invocation错误。

• 可以混合使用StrictExpectations和NonStrictExpections，不过一般一个mock对象只出现在其中之一。
• StrictExpectations包含了隐式的verification。

2.5 为Expectation录制结果

对于返回值非空的函数（包括构造器），可以通过result设置返回值或抛出异常，该值在replay阶段生效。

可以record多个结果，

mockObject.mockMethod();
result = new Object();
result = new Object();
result = new SomeException();

等价于

mockObject.mockMethod();
returns(new Obejct(), new Object());
result = new SomeException();

Note:

• 返回值可以使用returns()函数，异常值必须要使用result。

• 异常值需要在CodeUnderTest中捕获，否则无法通过测试。

• 假设在StrictExpectations中录制了n个结果，在replay阶段并不强制要求调用n次该函数，调用1次即可。

2.6 调用特定对象的方法

通常，声明了mock对象并在Expectation中进行了record，则在replay阶段对该类其他对象的调用也会返回record的结果。也就是说，在replay阶段，JMockit并不关心调用的是哪个对象，只要是该mock类的对象就会引用record中的结果。

示例如下：

@Test
public void TestMethod(@Mocked final Dependency dependency) throws Exception {
    new NonStrictExpectations() {{
        dependency.intReturnMethod();
        returns(1, 2, 3);
    }};

    Dependency dependency1 = new Dependency();
    assertEquals(1, dependency1.intReturnMethod());

    Dependency dependency2 = new Dependency();
    assertEquals(2, dependency2.intReturnMethod());

    Dependency dependency3 = new Dependency();
    assertEquals(3, dependency3.intReturnMethod());
}

在大多数情况下，CodeUnderTest使用mock类的某一个对象，所以是在CodeUnderTest中创建的还是作为参数传给它的并不重要。但是，如果CodeUnderTest中包含多个mock对象，而我们需要

• 只mock其中某个对象，其它的并不mock
• 指定调用某个mock对象的方法

这时，使用 @Injectable 可以mock某个对象。当然，即使用 @Mock 注解mock该类所有对象，也有其他方法限制Expectation中的匹配。

@Injectable

public class Dependency {
    public String mockMethod() {
        return "realMethod";
    }
}

@Test
public void TestMethod(@Injectable final Dependency mockDependency) {
    new NonStrictExpectations() {{
        mockDependency.mockMethod();
        result = "mockMethod";
    }};
    assertEquals("mockMethod", mockDependency.mockMethod());
    assertEquals("realMethod", new Dependency().mockMethod());
}

其他对象不受影响，正常执行原有代码。

note：

• 需要将mock对象传递给CodeUnderTest
• static方法和constructor无法被mock

声明多个mock对象

声明多个mock对象可以限制和Expectation的匹配。

示例如下：

//参数中的anotherDependency只是起到占位作用，不会被真正使用
@Test
public void TestMethod(@Mocked final Dependency mockDependency, 
                       @Mocked Dependency anotherDependency) {
    new NonStrictExpectations() {{
        mockDependency.mockMethod();
        result = "mockMethod";
    }};
    
    //这个会被mock
    assertEquals("mockMethod", mockDependency.mockMethod());
    
    //JMockit仍然拦截了这次调用，但是由于在Expectation中没有record，所以返回null
    assertNull("realMethod", new Dependency().mockMethod());
}

这种方法看起来比较奇怪，主要用于当CodeUnderTest中包含多个Dependency类的对象，而想要测试其中某个确定对象会被调用。

mock特定constructor产生的实例

有两种方式可以实现这个效果，方式1：

@Test
//mockDependency不会被使用
public void TestMethod(@Mocked Dependency mockDependency) {
    new NonStrictExpectations() {{
        Dependency dependency1 = new Dependency("dependency1");
        dependency1.mockMethod(); result="dependency1";
        Dependency dependency2 = new Dependency("dependency2");
        dependency2.mockMethod(); result="dependency2";
    }};
    
    //可以创建多个对象，会匹配到同一个Expectation
    assertEquals("dependency1", new Dependency("dependency1").mockMethod());
    assertEquals("dependency1", new Dependency("dependency1").mockMethod());
    
    assertEquals("dependency2", new Dependency("dependency2").mockMethod());
    
    //JMockit仍然拦截了这次调用，但是由于在Expectation中没有record，所以返回null
    assertNull(new Dependency("dependency2").mockMethod());
}

方式2：

@Test
public void TestMethod(@Mocked final Dependency mockDependency1,
                       @Mocked final Dependency mockDependency2) {
    new NonStrictExpectations() {{
        new Dependency("dependency1");
        result = mockDependency1;
        new Dependency("dependency2");
        result = mockDependency2;
        mockDependency1.mockMethod();
        result = "dependency1";
        mockDependency2.mockMethod();
        result = "dependency2";
    }};
    assertEquals("dependency1", new Dependency("dependency1").mockMethod());
    assertEquals("dependency1", new Dependency("dependency1").mockMethod());
    assertEquals("dependency2", new Dependency("dependency2").mockMethod());
    assertNull("dependency3", new Dependency("dependency3").mockMethod());
}

两种方法等效。

2.7 灵活的参数匹配

在record和verify阶段进行方法匹配时，

• 对于原始类型对象，数值相同即可；
• 对于Object的子类，需要equals()返回true；
• 对于数组，需要长度相等且每个对象equals()返回true;

除此之外，如果不关心replay时的具体参数，可以使用anyXyz或者withXyz(...)方法。

使用"any"

@Test
public void someTestMethod(@Mocked final DependencyAbc abc)
{
   final DataItem item = new DataItem(...);

   new Expectations() {{
      abc.voidMethod(anyString, (List) any);
   }};

   new UnitUnderTest().doSomething(item);

   new Verifications() {{
      abc.anotherVoidMethod(anyLong);
   }};
}

• 任何的基本类型都有对应的anyXyz，anyString对应任意字符串。
• any对应任意的对象，在使用时需要进行显式类型转换: (CastClass) any
• mockit.Invocations类中有可以使用所有anyXyz
• 使用时参数位置需要一致

使用"with"

any的限制太宽松，with可以选择特定的子集。

@Test
public void someTestMethod(@Mocked final DependencyAbc abc) {
   final DataItem item = new DataItem(...);

   new Expectations() {{
      abc.voidMethod("str", (List) withNotNull());
      abc.stringReturningMethod(withSameInstance(item), withSubstring("xyz"));
   }};

   new UnitUnderTest().doSomething(item);

   new Verifications() {{
      abc.anotherVoidMethod(withAny(1L));
   }};
}

也可以自定义with方法。

使用"null"

null可以与任何对象匹配，好处是避免类型转换，但是需要有一个any或者with。

@Test
public void TestMethod(@Mocked final Dependency mock) {
    new StrictExpectations() {{
    
        //测试会失败，因为没有any或者with
        mock.mockMethod(2,  null);
        
        //测试通过
        mock.mockMethod(anyInt,  null);
    }};
    mock.mockMethod(new Integer(2), "hello world");
}

如何需要的是null，则应该用 withNull() 方法。

varargs

要么使用常规的参数，要么使用any/with，不能混合使用。

2.8 调用次数的限制

在record和verify阶段可以使用times，minTimes，maxTimes来限制。
默认为minTimes = 1。

2.9 显式验证

对于NonStrictExpectation，可以进行verification。对于StrictExpectation则没有必要。在new Verifications(){}中的方法至少被调用一次。

验证某个方法没被调用

times = 0

验证顺序调用

普通的new Verifications(){}没有验证其中方法的调用顺序。new VerificationsInOrder(){}用来验证（相对）顺序。

验证部分顺序

使用unverifiedInvocations()方法固定不需要验证的方法的位置。

第一种场景是验证部分方法的顺序，其余方法不需要验证：

@Test
public void TestMethod(@Mocked final Dependency mock) {
    mock.mockMethod1();
    mock.mockMethod2();
    mock.mockMethod3();
    mock.mockMethod4();

    new VerificationsInOrder(){
        {
            // 下面的代码会失败:
            // Unexpected invocation of: Dependency#mockMethod2()
            // 如果两个方法相连，则其在replay中也必须直接相连
            // unverifiedInvocations();
            // mock.mockMethod1();
            // mock.mockMethod4();
            
            // 成功
            mock.mockMethod1();
            unverifiedInvocations();
            mock.mockMethod4();
        }
    };
}

第二种场景是关心部分方法顺序，另一些方法也需要验证，但是不关心顺序。这时需要两个Verification块:

@Test
public void TestMethod(@Mocked final Dependency mock) {
    mock.mockMethod1();
    mock.mockMethod2();
    mock.mockMethod3();
    mock.mockMethod4();

    new VerificationsInOrder(){{
            mock.mockMethod1();
            unverifiedInvocations();
            mock.mockMethod4();
    }};

    new Verifications(){{
        mock.mockMethod3();
        mock.mockMethod2();
    }};
}

多个verification块时，其相对顺序会引起比较诡异的事：

@Test
public void TestMethod(@Mocked final Dependency mock) {
    mock.mockMethod1();
    mock.mockMethod2();
    mock.mockMethod3();
    mock.mockMethod4();
    
    //下面的代码会失败
    //MissingInvocation: Missing invocation of:Dependency#mockMethod2()
    //颠倒一下两个verification的顺序则会通过
    //原因似乎是Verifications会将验证过的方法删除

    new Verifications(){{
        mock.mockMethod3();
        mock.mockMethod2();
    }};

    new VerificationsInOrder(){{
        mock.mockMethod1();
        mock.mockMethod2();
        mock.mockMethod4();
    }};
}

full verification

new FullVerifications() {...}可以保证replay阶段调用的所有方法在verify代码块中都有相应的匹配，顺序可以不一致。

full verification in order

使用new FullVerificationsInOrder()

限制full verification的目标类型

默认使用full verification时，所有mock类的所有调用都必须显式验证。如果需要限定验证的类或者实例，使用FullVerifications(xxx.class)或者FullVerifications(mockObject)。

验证没有调用发生

使用空的FullVerifications(xxx.class)或者FullVerifications(mockObject)可以验证在指定类/实例上没有调用方法。但是如果Expectation中有minTimes和times的方法会被正常验证。

2.10 在verification中捕获调用参数

单次调用捕获

使用withCapture()捕获最后一次调用的参数。

@Test
public void capturingArgumentsFromSingleInvocation(@Mocked final Collaborator mock)
{
   new Collaborator().doSomething(0.5, new int[2], "test");

   new Verifications() {{
      double d;
      String s;
      mock.doSomething(d = withCapture(), null, s = withCapture());

      assertTrue(d > 0.0);
      assertTrue(s.length() > 1);
   }};
}

多次调用捕获

使用withCapture(List)捕获所有参数。

@Test
public void capturingArgumentsFromMultipleInvocations(@Mocked final Collaborator mock)
{
   mock.doSomething(dataObject1);
   mock.doSomething(dataObject2);

   new Verifications() {{
      List dataObjects = new ArrayList<>();
      mock.doSomething(withCapture(dataObjects));

      assertEquals(2, dataObjects.size());
      DataObject data1 = dataObjects.get(0);
      DataObject data2 = dataObjects.get(1);
      // Perform arbitrary assertions on data1 and data2.
   }};
}

捕获新实例

使用withCapture(new XX())

@Test
public void capturingNewInstances(@Mocked Person mockedPerson) {
   new Person("Paul", 10);
   new Person("Mary", 15);
   new Person("Joe", 20);

   new Verifications() {{
      List personsInstantiated = withCapture(new Person(anyString, anyInt));
   }};
}

2.11 使用Delegate在Expectation中定制result

使用场景：在Expectation中需要根据replay时的参数值决定返回值。
原理：JMockit拦截调用，转交给Delegate处理。

@Test
public void delegatingInvocationsToACustomDelegate(@Mocked final DependencyAbc anyAbc){
   new Expectations() {{
      anyAbc.intReturningMethod(anyInt, null);
      result = new Delegate() {
         int aDelegateMethod(int i, String s)
         {
            return i == 1 ? i : s.length();
         }
      };
   }};

   // Calls to "intReturningMethod(int, String)" will execute the delegate method above.
   new UnitUnderTest().doSomething();
}

• delegate方法的参数应该与原始方法一致，返回值需要兼容或者为异常。
• 可以delegate构造器，这时返回值设置为空。
• delegate参数中可以有一个 Invocation对象，从而获得调用者的引用。

2.12 级联mock

出现obj1.getObj2(...).getYetAnotherObj().doSomething(...)时可能需要mock多个对象。对于一个mock对象:

• Expectation中进行了record，则会返回record的result；
• 如果没有record，JMockit会自动创建一个返回被注解@Injectable的子对象

public class Dependency {

    public CascadeDependency getCascadeDependency() {
        //JMockit会拦截这个方法，返回一个非null对象
        return null;
    }
    
    public CascadeDependency getAnotherCascadeDependency() {
        //JMockit会拦截这个方法，返回一个非null对象
        return null;
    }

    public String getString() {
        //仍旧返回null
        return null;
    }

    public Object getObject() {
        //仍旧返回null
        return null;
    }

    public List