单元测试--Mockito之spy

曾经终败给现在 2024-04-19 12:04 100阅读 0赞

**目录**

spy和mock的相同点和区别：

Shadow和spy的异同点：

使用场景一：

使用场景二：

使用场景三：

使用场景四：

典型错误示例：

spy对象和被spy对象的关系

--------------------

### spy和mock的相同点和区别： ###

1.得到的对象同样可以进行“监管”，即验证和打桩。

2.如果不对spy对象的methodA打桩，那么调用spy对象的methodA时，会调用真实方法。

3.如果不对mock对象的methodA打桩，将doNothing，且返回默认值（null,0,false）。

### **Shadow和spy的异同点**： ###

1.同样可以对对象的特定public方法进行打桩。

2.Shadow可以对public static的方法进行打桩，spy不可以。

3.当测试对象为Shadow对象时，无法被统计覆盖率，spy对象可以被统计。

4.Shadow需要定义一个类，并且需要使用注解，spy不用。

5.无法对Shadow对象的public方法进行verify，spy对象可以。

6.Shadow对象不需要我们主动显式注入到测试程序中，因为测试程序在创建Shadow的目标对象后，会自动为目标对象打桩，而spy对象需要我们主动显式注入到测试程序中，否则桩无法生效，也无法verify。1.

### 使用场景一： ###

public class TestSubject{
       public void methodA(){
          throw new RuntimeException();
       }
    
       public void methodB(){
          System.out.println("methodB begin");
          methodA();
          methodC()
          System.out.println("methodB end");
       }
    
       public void methodC(){
          System.out.println("methodC");
       }
    } 
    
    public class Test{
       //此用例中使用spy的原因是我要测试的是TestSubject的methodB方法，所以调用methodB时必须执行其
       //真实的方法体，methodB会调用methodA，methodA会抛异常，所以要绕过methodA
       @Test
       public void testMethodB(){
          TestSubject t = new TestSubject();
          TestSubject spyT  = Mockito.spy(t);
          //避免调用mehtodB时抛运行时异常。
          doNothing().when(spyT).methodA();
          sptT.methodB();
       }
    }

### 使用场景二： ###

public class TestSubject{
       public int methodA(){
          //根据某成员变量的值去计算得出一个value，这个过程包含了复杂的逻辑和层层方法嵌套调用
          return value；
       }
    
       public void methodB(){
          int key = methodA();
          switch（key）{
             case 0:
                //do something
             case 1:
                //do something
             case 2:
                //do something
          }
       }
    
    } 
    
    public class Test{
       //此用例中使用spy的原因是我要测试的是TestSubject的methodB方法，所以需要
       //调用真实对象的methodB，methodB的输入来自methodA的返回值。但是methodA的计算十分复杂，
       //那么想要methodA返回你想要的值就不那么容易，别人看起来也不直观，不确定methodA否是真的
       //返回0，1，2。那么就可以对methodA打桩，对真实对象打桩，就要用到spy.
       @Test
       public void testMethodB(){
          TestSubject t = new TestSubject();
          TestSubject spyT  = Mockito.spy(t);
          //第一次，第二次，第三次调用methodA时，分别返回0，1，2
          when(spyT.methodA()).thenReturn(0,1,2);
          for(int i=0; i<=2; i++){
             spyT.methodB();
          }
          //assert && verify
       }
    }

### 使用场景三： ###

public class TestSubject{
       public void methodA(){
          System.out.println("methodA");
       }
    
       public void methodB(int i){
          int key；
          //根据参数i进行复杂运算，得出结果赋值给key
          switch（key）{
             case 0:
                methodA();
             case 1:
                methodC();
             case 2:
                methodD();
          }
       }
       public void methodC(){
          System.out.println("methodC");
       }
    
       public void methodD(){
          System.out.println("methodD");
       }
    
    } 
    
    public class Test{
       //此用例中使用spy的原因是我要测试的是TestSubject的methodB方法，所以需要
       //调用真实对象的methodB，此例中需要verify输入特定的i,是否能分别走进case 0,1,2,
       //methodA,C,D方法体内的东西都没法获取并证明methodA,C,D被调用过。那么就只能verify了，
       //verify只能针对mock对象，其实spy对象，也可以使用verify
       @Test
       public void testMethodB(){
          TestSubject t = new TestSubject();
          TestSubject spyT  = Mockito.spy(t);
          //假定输入1，能让key==0
          spyT.methodB(1);
          //assert && verify
          verify(spyT).methodA();
       }
    }

### 使用场景四： ###

public class TestSubject{
    
       public void methodB(TestObject obj, i){
          int key；
          //这方法执行的内容非常必要，所以obj需要真实对象。
          obj.doImportantThing();
          //根据参数i进行复杂运算，得出结果赋值给key
          switch（key）{
             case 0:
                LayoutInflater inflater = obj.getLayoutInfalter();
                ViewGroup v = inflater.inflate(R.layout.complex_layout,null,false);
                v.setVisibility(View.GONE);
                //do something can be verify
             case 1:
                methodC();
             case 2:
                methodD();
          }
       }
       public void methodC(){
          System.out.println("methodC");
       }
    
       public void methodD(){
          System.out.println("methodD");
       }
    
    } 
    
    public class TestObject{
       public void doImportantThing(){
          //do something nessisary for TestSubject
       }
       //一个layout文件经常无法inflate出一个ViewGroup，所以很可能你需要该方法返回一个
       //mock对象，然后你可以随心所欲指定inflate出来的ViewGroup对象
       public LayoutInflater getLayoutInfalter(){
          //obtain LayoutInflater
       }
    }
    
    public class Test{
       //此用例中使用spy的原因是我要测试的是TestSubject的methodB方法，所以需要
       //调用真实对象的methodB，此例中需要verify输入1后，是否进入case 0;因为
       //TestObject#doImportantThing（）中的内容是必须执行的，所以TestObject需要传入的
       //真实对象，但是R.layout.complex_layout太复杂了，里面都是厂商定制的控件，无法加载，
       //进入case 0后，将无法正常跑下去，那么可以通过spy TestObject，然后对getLayoutInfalter
       //打桩，使得返回一个mock LayoutInfalter，然后再对mock LayoutInfalter的inflate方法打桩，
       //使得不去真正加载R.layout.complex_layout，而是返回一个自己创建好ViewGroup,使得代码
       //能继续跑下去
       @Test
       public void testMethodB(){
          TestSubject t = new TestSubject();
          TestSubject spyT  = Mockito.spy(t);
          TestObject obj = new TestObject();
          TestObject spyObj = Mockito.spy(obj);
          LayoutInflater mockInflater = mock(LayoutInflater.class);
          ViewGroup mockViewGroup = mock(ViewGroup.class);
          when(mockInflater).inflate(anyInt(), isNull(ViewGroup.class), anyBoolean()).thenReturn(mockViewGroup);
          doReturn(mockInflater).when(spyObj).getLayoutInfalter();
          //假定输入1，能让key==0
          spyT.methodB(1);
          //assert && verify
          verify(mockViewGroup).setVisibility(View.GONE);
          //verify other
       }
    }

总而言之，如果你想对一个真实对象的某个方法打桩( doReturn().when().method() )，verify真实对象的public方法( verify().method() )，绕过真实对象的某个public方法( doNothing().when().method() ),你可以使用spy后的对象，如：

TestSubject t = new TestSubject();
    TestSubject spyT = Mockito.spy(t);

特别需要注意的是，t和spyT是两个不同的对象，后面的代码必须要使用spyT，打桩才有效，才能verify TestSubject的方法。如果你只是spy(t),而后面的代码仍然调用t.methodB()的话，则打桩无效，无法verify。而要是保证调用的是spyT.methodB()。

### 典型错误示例： ###

public class TestSubject{
       public void methodA(){
          throw new RuntimeException();
       }
    
       public void methodB(){
          System.out.println("methodB begin");
          methodA();
          methodC()
          System.out.println("methodB end");
       }
    
       public void methodC(){
          System.out.println("methodC");
       }
    
       public void mothodD(TestObject obj){
          obj.doSomething();
       }
    } 
    
    public class TestObject{
       public void doSomething(){
       }
    }
    
    public class Test{
       //错误用法1
       @Test
       public void testMethodB(){
          TestSubject t = new TestSubject();
          TestSubject spyT  = Mockito.spy(t);
          //避免调用mehtodB时抛运行时异常。
          doNothing().when(spyT).methodA();
          
          t.methodB();//错误
          //spyT.methodB();//正确
       }
    
       //错误用法2
       @Test
       public void testMethodB(){
          TestSubject t = new TestSubject();
          TestSubject spyT  = Mockito.spy(t);
          //避免调用mehtodB时抛运行时异常。
          doNothing().when(t).methodA();//错误
          //doNothing().when(spyT).methodA();//正确
         
          spyT.methodB();
       }
    
       //错误用法3
       @Test
       public void testMethodB(){
          TestSubject t = new TestSubject();
          TestObject obj = new TestObject();
          TestObject spyObj = Mockito.spy(obj);
         
          t.methodD(obj);//错误
          //t.methodD(spyObj);//正确
          //verify
          verify(spyObj).doSomething();//正确
          //verify(obj).doSomething();//错误
       }
    }

### spy对象和被spy对象的关系 ###

Object obj = new Object();

Object spyObj = spy(obj);

关于obj和spyObj的关系，下面我先直接给出结论：

1.可以说obj和spyObj类似是浅克隆的关系，而不是动态代理的关系。也就是在执行完Object spyObj = spy(obj);后，obj和spyObj的成员变量是指向同一个对象。

2.spyObj的类型中的方法和obj的类型的方法的不同之处在于spyObj的类型多了记录调用次数等一些跟统计有关的功能代码，当然还会判断某些标志位以确定是否调用实际代码（如：调用Mockito.doNothing().when(spyObj).equal(anyStrinig())后，执行spyObj.equals("")将不会执行Object\#equals()方法）。

知道了以上关系后，那么在对spyObj打桩时就要注意了，不要通过obj 打桩，而要通过调用spyObj 打桩，否则这个桩就无效了。

以下是证明上述关系的代码和打印结果：

static class DataItem {
            ArrayList mData = new ArrayList(4);
            void setData(ArrayList list){
                mData = list;
            }
    
            void add(Object obj){
                mData.add(obj);
            }
        }
        @Test
        public void test(){
            DataItem dataSet = new DataItem();
            ArrayList list = new ArrayList<>(4);
            list.add(0);
            dataSet.setData(list);
            DataItem spySet = spy(dataSet);
            System.out.println(spySet.getClass().getName());
            //打印结果是  com.champion.loaddexdemo.ExampleUnitTest$DataItem$MockitoMock$988576336
            //结果说明spySet的类型是DataItem的子类
            System.out.println("dataSet length: " + dataSet.mData.size() + " spySet length: "
                    + spySet.mData.size());
            //打印结果是  dataSet length: 1 spySet length: 1
            //结果说明spySet在创建对象是复制了dataSet的成员变量的
            dataSet.add(-1);
            System.out.println("dataSet length: " + dataSet.mData.size() + " spySet length: "
                    + spySet.mData.size());
            //打印结果是  dataSet length: 2 spySet length: 2
            //结果说明spySet对dataSet的成员变量指向同一个对象，就是说是浅复制
            ArrayList spylist = new ArrayList<>(4);
            spylist.add(1);
            spylist.add(2);
            spylist.add(3);
            spySet.mData = spylist;
            System.out.println("dataSet length: " + dataSet.mData.size() + " spySet length: "
                    + spySet.mData.size());
            //打印结果是  dataSet length: 2 spySet length: 3
            //结果说明spySet和dataSet是两个对象，有各自的成员变量
            spySet.add(4);
            System.out.println("dataSet length: " + dataSet.mData.size() + " spySet length: "
                    + spySet.mData.size());
            //打印结果是  dataSet length: 2 spySet length: 4
            //结果说明调用spySet的方法时，并没有去调用dataSet的方法，说明spySet和datSet不是动态代理的关系
        }

发表评论取消回复

表情：

评论列表（有 0 条评论，100人围观）

还没有评论，来说两句吧...

相关阅读

相关单元测试--Mockito之spy

*目录** spy和mock的相同点和区别： Shadow和spy的异同点：使用场景一：使用场景二：使用场景三：使用场景四：典型错误示例： s...

曾经终败给现在/ 2024年04月19日 12:04/ 0 赞/ 101 阅读

相关 Android 单元测试之JUnit和Mockito

Android 单元测试之JUnit和Mockito [Android 单元测试之JUnit和Mockito][Android _JUnit_Mockito] [An

骑猪看日落/ 2023年10月17日 08:30/ 0 赞/ 601 阅读

相关 Mockito单元测试的学习

刚换到另一个项目组，今天让用Mockito写单元测试，之前从来没有接触过，由于别人不能看到公司内部代码，只能找公司同事，但是几乎问了所有认识的同事，他们都不会，只能自己硬着头皮

一时失言乱红尘/ 2023年02月22日 05:12/ 0 赞/ 53 阅读

相关单元测试框架--mockito

mockito https://github.com/IBXiaomi/studynote/tree/master/src/test/java/com/baxixiaom

墨蓝/ 2022年12月02日 15:24/ 0 赞/ 226 阅读

相关 Mockito spy

List list = new LinkedList(); List spy = spy(list); //optionally,

淩亂°似流年/ 2022年11月13日 00:54/ 0 赞/ 159 阅读

相关 Mockito单元测试

Mockito单元测试 Maven依赖 <dependency> <groupId>junit</groupId> <art

悠悠/ 2022年07月16日 15:13/ 0 赞/ 266 阅读

相关 spring autowired mockito单元测试

这两天在做spring service层的单元测试时，遇到了一些问题。service层会自动注入（autowired）dao层的interface，如何正常测试service层

川长思鸟来/ 2022年05月25日 07:09/ 0 赞/ 483 阅读

相关使用mockito进行单元测试

一、前言在进行单元测试时，由于类之间存在依赖关系，使单元测试比较困难如：对service层进行测试时dao层并未开发这时就无法测试 @Autowired

àì夳堔傛蜴生んèń/ 2022年03月22日 13:40/ 0 赞/ 376 阅读

相关 Mockito文档-单元测试技术

<table style="color:333333;font-family:Helvetica, Arial, sans-serif;font-size:14px;line-

偏执的太偏执、/ 2021年12月13日 23:47/ 0 赞/ 553 阅读

相关单元测试利器Mockito框架

前言 `Mockito` 是当前最流行的单元测试 `Mock` 框架。采用 `Mock` 框架，我们可以虚拟出一个外部依赖，降低测试组件之间的耦合度，只注重

你的名字/ 2021年06月10日 20:40/ 0 赞/ 561 阅读