1. 何为Mock
项目中各个模块，各个类之间会有互相依赖的关系，在单元测试中，我们只关心被测试的单元，对于其依赖的单元并不关心（会有另外针对该单元的测试）。
比如，逻辑层A类依赖了数据访问层B类的取数方法，然后进行逻辑处理。在对A的单元测试中，我们关注的是在B返回不同的查询结果的时候，A是怎么处理的，而不是B到底是怎么取的数，如何封装成一个模型等等。
因此，要屏蔽掉这些外部依赖，而Mock让我们有了一套仿真的环境。
目前业界有几种Mock，这里选用最全面的JMockit进行总结。
2. JMockit简介
JMockit的工作原理是通过asm修改原有class的字节码，再利用jdk的instrument机制替换现有class的内容，从而达到mock的目的。
这里使用的JMockit是1.21版本，具体使用方法可能与其他版本的不一样，但思想是相通的。Maven 配置如下：
<dependency>
<groupId>org.jmockit</groupId>
<artifactId>jmockit</artifactId>
<version>1.21</version>
<scope>test</scope>
</dependency>
JMockit有两种测试方式，一种是基于行为的，一种是基于状态的测试。
1） Behavior-oriented(Expectations & Verifications)
2）State-oriented(MockUp<GenericType>)
通俗点讲，Behavior-oriented是基于行为的mock，对mock目标代码的行为进行模仿，更像黑盒测试。State-oriented 是基于状态的mock，是站在目标测试代码内部的。可以对传入的参数进行检查、匹配，才返回某些结果，类似白盒。而State-oriented的 new MockUp基本上可以mock任何代码或逻辑。
假设现在有两个类，Service和DAO. Service通过数据库查询出不同分组货物的数量，得到货物是否畅销。
package com.khlin.test.junit.jmockit.demo;
public class Service {
private DAO dao;
public void setDao(DAO dao) {
this.dao = dao;
}
/**
* 根据存货量判断货物是否畅销
* @param group
* @return
*/
public Status checkStatus(String group) {
int count = this.dao.getStoreCount(group);
if (count <= 0) {
return Status.UNKOWN;
} else if (count <= 800) {
return Status.UNSALABLE;
} else if (count <= 1000) {
return Status.NORMAL;
} else {
return Status.SELLINGWELL;
}
}
}
package com.khlin.test.junit.jmockit.demo; import java.util.HashMap;
import java.util.Map; public class DAO { private Map<String, Integer> groupCounts = new HashMap<String, Integer>(); /**
* 假数据
*/
{
this.groupCounts.put("A", 500);
this.groupCounts.put("B", 1000);
this.groupCounts.put("C", 1200);
} public int getStoreCount(String group) {
Integer count = this.groupCounts.get(group); return null == count ? -1 : count.intValue();
}
}
package com.khlin.test.junit.jmockit.demo;
public enum Status {
/**
* 畅销
*/
SELLINGWELL,
/**
* 一般
*/
NORMAL,
/**
* 滞销
*/
UNSALABLE,
/**
* 状态未知
*/
UNKOWN
}
基于行为的Mock 测试，一共三个阶段：record、replay、verify。
1）record：在这个阶段，各种在实际执行中期望被调用的方法都会被录制。
2）repaly：在这个阶段，执行单元测试Case，原先在record 阶段被录制的调用都可能有机会被执行到。这里有“有可能”强调了并不是录制了就一定会严格执行。
3）verify：在这个阶段，断言测试的执行结果或者其他是否是原来期望的那样。
假设现在我只想测试Service，在存货量900件的情况下，是否能正确返回NORMAL的状态。那么，我并不关心传入DAO的到底是哪个分组，也不关心DAO怎么去数据库取数，我只想让DAO返回900，这样就可以测试Service了。
示例代码：
@RunWith(JMockit.class)
public class ServiceBehavier { @Mocked
DAO dao = new DAO(); private Service service = new Service(); @Test
public void test() { // 1. record 录制期望值
new NonStrictExpectations() {
{
/**
* 录制的方法
*/
dao.getStoreCount(anyString);// mock这个方法，无论传入任何String类型的值，都返回同样的值，达到黑盒的效果
/**
* 预期结果，返回900
*/
result = 900;
/**
times必须调用两次。在Expectations中，必须调用，否则会报错，因此不需要作校验。
在NonStrictExpectations中不强制要求，但要进行verify验证.但似乎已经强制要求了
此外还有maxTimes，minTimes
*/
times = 1;
}
};
service.setDao(dao); // 2. replay 调用
Assert.assertEquals(Status.NORMAL, service.checkStatus("D")); // Assert.assertEquals(Status.NORMAL, service.checkStatus("D")); //3.校验是否只调用了一次。如果上面注释的语句再调一次，且把录制的times改为2，那么在验证阶段将会报错。
new Verifications() {
{
dao.getStoreCount(anyString);
times = 1;
}
}; }
}
基于状态的Mock测试
通过MockUp类，直接改写了mock类的代码逻辑，有点类似白盒测试。
public class ServiceState {
private DAO dao;
private Service service;
@Test
public void test() {
//1. mock对象
MockUp<DAO> mockUp = new MockUp<DAO>() {
@Mock
public int getStoreCount(String group) {
return 2000;
}
};
//2. 获取实例
dao = mockUp.getMockInstance();
service = new Service();
service.setDao(dao);
//3.调用
Assert.assertEquals(Status.SELLINGWELL, service.checkStatus("FFF"));
//4. 还原对象，避免测试方法之间互相影响。其实对一个实例来说没什么影响，对静态方法影响较大。旧版本的tearDown()方法是Mockit类的静态方法
mockUp.tearDown();
}
}
3. JMockit mock各种类型或方法的示例代码
抽象类
package com.khlin.test.junit.jmockit.demo.jmockit;
public abstract class AbstractA {
public abstract int getAbstractAnything();
public int getAnything() {
return 1;
}
}
接口类
package com.khlin.test.junit.jmockit.demo.jmockit;
public interface InterfaceB {
public int getAnything();
}
普通类
package com.khlin.test.junit.jmockit.demo.jmockit;
public class ClassA {
InterfaceB interfaceB;
private int number;
public void setInterfaceB(InterfaceB interfaceB) {
this.interfaceB = interfaceB;
}
public int getAnything() {
return getAnythingPrivate();
}
private int getAnythingPrivate() {
return 1;
}
public int getNumber() {
return number;
}
public static int getStaticAnything(){
return getStaticAnythingPrivate();
}
private static int getStaticAnythingPrivate() {
return 1;
}
public int getClassBAnything() {
return this.interfaceB.getAnything();
}
}
接口实现类
package com.khlin.test.junit.jmockit.demo.jmockit;
public class ClassB implements InterfaceB {
public int getAnything() {
return 10;
}
}
终极测试代码
package com.khlin.test.junit.jmockit.demo; import mockit.Deencapsulation;
import mockit.Expectations;
import mockit.Injectable;
import mockit.Mock;
import mockit.MockUp;
import mockit.Mocked;
import mockit.NonStrictExpectations;
import mockit.Tested;
import mockit.Verifications;
import mockit.integration.junit4.JMockit; import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith; import com.khlin.test.junit.jmockit.demo.jmockit.AbstractA;
import com.khlin.test.junit.jmockit.demo.jmockit.ClassA;
import com.khlin.test.junit.jmockit.demo.jmockit.ClassB;
import com.khlin.test.junit.jmockit.demo.jmockit.InterfaceB; @RunWith(JMockit.class)
public class JMockitTest { /**
* mock私有方法
*/
@Test
public void testPrivateMethod() { final ClassA a = new ClassA();
// 局部参数，把a传进去
new NonStrictExpectations(a) {
{
Deencapsulation.invoke(a, "getAnythingPrivate");
result = 100;
times = 1;
}
}; Assert.assertEquals(100, a.getAnything()); new Verifications() {
{
Deencapsulation.invoke(a, "getAnythingPrivate");
times = 1;
}
};
} /**
* mock私有静态方法
*/
@Test
public void testPrivateStaticMethod() { new NonStrictExpectations(ClassA.class) {
{
Deencapsulation
.invoke(ClassA.class, "getStaticAnythingPrivate");
result = 100;
times = 1;
}
}; Assert.assertEquals(100, ClassA.getStaticAnything()); new Verifications() {
{
Deencapsulation
.invoke(ClassA.class, "getStaticAnythingPrivate");
times = 1;
}
}; } /**
* mock公有方法
*/
@Test
public void testPublicMethod() {
final ClassA classA = new ClassA();
new NonStrictExpectations(classA) {
{
classA.getAnything();
result = 100;
times = 1;
}
}; Assert.assertEquals(100, classA.getAnything()); new Verifications() {
{
classA.getAnything();
times = 1;
}
};
} /**
* mock公有静态方法--基于行为
*/
@Test
public void testPublicStaticMethod() { new NonStrictExpectations(ClassA.class) {
{
ClassA.getStaticAnything();
result = 100;
times = 1;
}
}; Assert.assertEquals(100, ClassA.getStaticAnything()); new Verifications() {
{
ClassA.getStaticAnything();
times = 1;
}
};
} /**
* mock公有静态方法--基于状态
*/
@Test
public void testPublicStaticMethodBaseOnStatus() { MockUp<ClassA> mockUp = new MockUp<ClassA>() {
@Mock
public int getStaticAnything() { //注意这里不用声明为static
return 100;
}
}; Assert.assertEquals(100, ClassA.getStaticAnything());
} /**
* mock接口
*/
@Test
public void testInterface() { InterfaceB interfaceB = new MockUp<InterfaceB>() {
@Mock
public int getAnything() {
return 100;
}
}.getMockInstance(); ClassA classA = new ClassA();
classA.setInterfaceB(interfaceB); Assert.assertEquals(100, classA.getClassBAnything());
} /**
* mock接口--基于状态
*/
@Test
public void testInterfaceBasedOnStatus() {
final InterfaceB interfaceB = new ClassB(); new NonStrictExpectations(interfaceB) {
{
interfaceB.getAnything();
result = 100;
times = 1;
}
}; ClassA classA = new ClassA();
classA.setInterfaceB(interfaceB); Assert.assertEquals(100, classA.getClassBAnything()); new Verifications() {
{
interfaceB.getAnything();
times = 1;
}
};
} /**
* mock抽象类
*/
@Test
public void testAbstract() {
AbstractA abstractA = new MockUp<AbstractA>() {
@Mock
public int getAbstractAnything(){
return 100;
} @Mock
public int getAnything(){
return 1000;
}
}.getMockInstance(); Assert.assertEquals(100, abstractA.getAbstractAnything()); Assert.assertEquals(1000, abstractA.getAnything());
}
}