添加链接 注册    登录
link管理
链接快照平台
  • 输入网页链接，自动生成快照
  • 标签化管理网页链接
相关文章推荐
有胆有识的勺子  ·  GitHub - ...·  1 周前    · 
英俊的刺猬  ·  A guide to mocking ...·  2 周前    · 
飘逸的李子  ·  ES6 Class Mocks · Jest·  2 周前    · 
谈吐大方的大白菜  ·  Use ...·  2 周前    · 
一身肌肉的冲锋衣  ·  Mockito模拟静态方法报错：org.mo ...·  2 周前    · 
有胆有识的雪糕  ·  How to print the ...·  1 月前    · 
乐观的番茄  ·  干货：简析芯片反向设计流程 - 晶圆制造 ...·  2 月前    · 
淡定的啄木鸟  ·  ubuntu宏基因组物种注释·  5 月前    · 
爱旅游的蛋挞  ·  玄幻我天命大反派顾长歌最新章节txt下载 ...·  6 月前    · 
慷慨大方的柠檬  ·  albumentationsのpipインスト ...·  7 月前    · 
link管理  ›  单元测试之Mockito框架 | xyZGHio
string mockito 返回值 mock
https://xyzghio.xyz/Mockito/
严肃的机器人
10 月前

POM依赖

这里我们向POM中引入Mockito依赖，同时这里对于Junit框架，我们选用Junit 5版本 

1
2
3
4
5
6
7
8
9
10
11
12
13
 
<!-- Junit -->
<dependency>
  <groupId>org.junit.jupiter</groupId>
  <artifactId>junit-jupiter</artifactId>
  <version>5.5.2</version>
</dependency>

<!-- Mockito -->
<dependency>
  <groupId>org.mockito</groupId>
  <artifactId>mockito-junit-jupiter</artifactId>
  <version>3.1.0</version>
</dependency>

初探

引入依赖后我们来看看如何使用该框架来Mock对象，并对相关方法进行打桩。不难看出，其基本用法还是很简单的。如果Mock对象的方法被打桩了，则调用时会返回指定值；反之则会按照方法声明的返回值类型返回相应的空值。换言之，对于Mock而言，Mock的目标既可以是类、也可以是接口 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
public class MockDemo1 {

    @Test
    public void basic() {
        // Mock的目标既可以是类、也可以是接口
        List<String> list = Mockito.mock( List.class );

        // 方法打桩: 方法返回指定返回值
        Mockito.when( list.get(0) )
            .thenReturn( "Hello" );
        Assertions.assertEquals("Hello", list.get(0));

        Mockito.when( list.get(3) )
            .thenReturn( "Aaron" );
        Assertions.assertEquals("Aaron", list.get(3));

        // 方法打桩: 方法抛出指定异常
        Mockito.when( list.remove("Tony") )
            .thenThrow( new RuntimeException("不能没有Tony老师") );

        try {
            list.remove("Tony");
            Assertions.fail();  // 如果执行到该行, 则当前测试会直接失败
        } catch (Exception e) {
            Assertions.assertTrue( e instanceof RuntimeException );
            Assertions.assertEquals("不能没有Tony老师", e.getMessage());
        }

        // 对于未打桩的方法, 则根据方法的返回类型, 返回相应的空值
        Assertions.assertEquals(null, list.get(996));
        Assertions.assertEquals(0, list.size());
        Assertions.assertEquals( false, list.contains( "China" ) );
    }
    
}

参数匹配

在对方法进行打桩的过程中，我们还可以进行模糊匹配参数值。故在ArgumentMatchers类中内置了很多常见的参数匹配器。当然如果内置的参数匹配器无法满足时，我们还可以通过实现ArgumentMatcher函数式接口来自定义参数匹配器。然后通过argThat方法传入自定义参数匹配器即可 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
public class MockDemo1 {

    @Test
    public void testArgumentMatcher() {
        LinkedList<String> list1 = Mockito.mock( LinkedList.class );

        // 参数 匹配 任何对象(包括null)
        Mockito.when( list1.addAll( ArgumentMatchers.any() ) )
            .thenReturn( true );
        Assertions.assertTrue( list1.addAll(null) );
        Assertions.assertTrue( list1.addAll(new HashSet()) );

        // 对 boolean addAll(int index, Collection<? extends E> c) 方法进行打桩
        // 要求: index参数匹配非null Integer整型, c参数匹配非null的List
        Mockito.when( list1.addAll(ArgumentMatchers.anyInt(), ArgumentMatchers.anyList() ) )
            .thenReturn( true );
        Assertions.assertTrue( list1.addAll(24, new ArrayList()) );
        Assertions.assertFalse( list1.addAll(24, new TreeSet()) );

        // 参数 匹配 非null字符串
        Mockito.when( list1.add( ArgumentMatchers.anyString() ))
            .thenReturn(true);
        Assertions.assertTrue( list1.add("Bob") );

        // 参数 匹配 非null Integer整型
        Mockito.when( list1.remove( ArgumentMatchers.anyInt() ) )
            .thenReturn("删除指定位置上的元素成功");
        Assertions.assertEquals( "删除指定位置上的元素成功", list1.remove(25) );

        // 自定义参数匹配器,  参数 匹配 非null字符串, 且字符串长度不超过5
        ArgumentMatcher<String> argumentMatcher = e -> e != null && e.length()<5;
        // 通过argThat方法传入自定义参数匹配器
        Mockito.when( list1.contains( ArgumentMatchers.argThat(argumentMatcher) ) )
            .thenReturn(true);
        Assertions.assertTrue( list1.contains("Tony") );
    }
    
}

then 系列方法

thenReturn 方法

通过thenReturn可以实现对方法进行打桩以返回指定值 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
public class MockDemo1 {

    public void testThenReturn() {
        List<Integer> list = Mockito.mock( List.class );

        // 分别进行多次打桩 则会依次覆盖, 仅最后一次的打桩生效
        Mockito.when( list.get(0) )
            .thenReturn(27);
        Mockito.when( list.get(0) )
            .thenReturn(11);
        Mockito.when( list.get(0) )
            .thenReturn(24);
        Assertions.assertEquals(24, list.get(0));

        // 链式调用 thenReturn 指定多个返回值, 调用时返回值会依次出现
        // 当调用次数超过返回值的数量后，调用结果使用最后一个返回值
        Mockito.when( list.get(1) )
            .thenReturn(238)    // 第1次调用时的返回值
            .thenReturn(179)    // 第2次调用时的返回值
            .thenReturn(996);   // 第3次、后续所有调用时的返回值
        // 第1次调用
        Assertions.assertEquals( 238, list.get(1) );
        // 第2次调用
        Assertions.assertEquals( 179, list.get(1));
        // 第3次调用
        Assertions.assertEquals( 996, list.get(1));
        // 第4次调用
        Assertions.assertEquals( 996, list.get(1) );

        // 该方式等价于 链式调用 thenReturn 指定多个返回值
        Mockito.when( list.get(2) )
            .thenReturn(137, 12, 139);
        // 第1次调用
        Assertions.assertEquals( 137, list.get(2) );
        // 第2次调用
        Assertions.assertEquals( 12, list.get(2) );
        // 第3次调用
        Assertions.assertEquals( 139, list.get(2) );
        // 第4次调用
        Assertions.assertEquals( 139, list.get(2) );
    }
       
}

thenThrow 方法

通过thenThrow可以实现对方法进行打桩，以实现对方法调用抛出指定异常 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
public class MockDemo1 {

    @Test
    public void testThenThrow() {
        List<Integer> list = Mockito.mock( List.class );

        // 链式调用 thenReturn 指定多个返回值, 调用时返回值会依次出现
        // 当调用次数超过返回值的数量后，调用结果使用最后一个返回值
        Mockito.when( list.get(1) )
            .thenThrow( new RuntimeException("非法操作") )    // 第1次调用时抛出的异常
            .thenReturn( 12 )   // 第2次调用时的返回值
            .thenThrow( new RuntimeException("目标类不存在") )    // 第3次调用时抛出的异常
            .thenReturn(23);   // 第4次、后续所有调用时的返回值

        // 第1次调用
        Exception ex1 = Assertions.assertThrows(RuntimeException.class, ()->list.get(1) );
        Assertions.assertEquals("非法操作", ex1.getMessage() );

        // 第2次调用
        Assertions.assertEquals( 12, list.get(1) );

        // 第3次调用
        Exception ex3 = Assertions.assertThrows(RuntimeException.class, ()->list.get(1) );
        Assertions.assertEquals("目标类不存在", ex3.getMessage() );

        // 第4次调用
        Assertions.assertEquals( 23, list.get(1) );

        // 第5次调用
        Assertions.assertEquals( 23, list.get(1) );
    }
          
}

then、thenAnswer 方法

通过then可以实现对方法进行打桩，以实现自定义返回值逻辑。具体地我们只需实现函数式接口Answer，并实现自定义返回值逻辑即可。特别地，then 方法 和 thenAnswer 方法作用是相同的 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
public class MockDemo1 {

    public void testThen() {
        Map<Integer, Integer> map = Mockito.mock( HashMap.class );

        // 调用then方法、并实现函数式接口Answer, 实现自定义返回值逻辑
        // then方法、thenAnswer方法是相同的
        Mockito.when( map.put(ArgumentMatchers.anyInt(), ArgumentMatchers.anyInt()) )
            .then( invocation -> {
            //.thenAnswer( invocation -> {  // 也可通过thenAnswer方法实现相同的作用
                Object[] args = invocation.getArguments();
                Integer key = (Integer) args[0];
                Integer value = (Integer)args[1];
                if( key.equals(1) ) {
                    return 110;
                } else if( key.equals(2) ) {
                    return 120;
                } else if( key < 100 ) {
                    return key+value;
                } else {
                    return value;
                }
            } );

        Assertions.assertEquals(110, map.put(1, 37));
        Assertions.assertEquals(120, map.put(2, 37));
        Assertions.assertEquals(10086, map.put(86, 10000));
        Assertions.assertEquals(520, map.put(996, 520));
    }
}

do 系列方法

doReturn 方法

与thenReturn方法作用类似，doReturn 方法也可以实现对方法进行打桩以返回指定值 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
public class MockDemo1 {

    @Test
    public void testDoReturn() {
        List<Integer> list1 = Mockito.mock( List.class );
        Mockito.doReturn(14)    // 第1次调用时的返回值
            .doReturn(27)   // 第2次、后续所有调用时的返回值
            .when(list1)
            .get(996);

        // 第1次调用
        Assertions.assertEquals( 14, list1.get(996) );
        // 第2次调用
        Assertions.assertEquals( 27, list1.get(996) );
        // 第3次调用
        Assertions.assertEquals( 27, list1.get(996) );
    }
    
}

doThrow 方法

与thenThrow方法作用类似，doThrow 方法也可以实现对方法进行打桩，以实现对方法调用抛出指定异常 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
public class MockDemo1 {

    @Test   
    public void testDoThrow() {
        List<Integer> list1 = Mockito.mock( List.class );
        Mockito.doThrow(new RuntimeException("今晚的月色真美"))    // 第1次调用时抛出的异常
            .doThrow( new RuntimeException("风也温柔") )    // 第2次、后续所有调用时抛出的异常
            .when(list1)
            .get(996);

        // 第1次调用
        Exception ex1 = Assertions.assertThrows( RuntimeException.class, ()->list1.get(996) );
        Assertions.assertEquals("今晚的月色真美", ex1.getMessage() );

        // 第2次调用
        Exception ex2 = Assertions.assertThrows( RuntimeException.class, ()->list1.get(996) );
        Assertions.assertEquals("风也温柔", ex2.getMessage() );

        // 第3次调用
        Exception ex3 = Assertions.assertThrows( RuntimeException.class, ()->list1.get(996) );
        Assertions.assertEquals("风也温柔", ex3.getMessage() );
    }

}

doAnswer 方法

与then、thenAnswer方法作用类似，doAnswer 方法也可以实现对方法进行打桩。以实现自定义返回值逻辑。具体地我们只需实现函数式接口Answer，并实现自定义返回值逻辑即可 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
public class MockDemo1 {

    @Test
    public void testDoAnswer() {
        List<String> list1 = Mockito.mock( List.class );

        // 调用doAnswer方法、并实现函数式接口Answer, 实现自定义返回值逻辑
        Mockito.doAnswer( invocation -> {
                Object[] args = invocation.getArguments();
                Integer index = (Integer) args[0];
                if ( index > 77 ) {
                    return "Aaron";
                } else if (index < 77){
                    return "Tony";
                } else {
                    return "Tim";
                }
            })
            .when( list1 )
            .get( ArgumentMatchers.anyInt() );


        Assertions.assertEquals("Aaron", list1.get(97) );
        Assertions.assertEquals("Tony", list1.get(13) );
        Assertions.assertEquals("Tim", list1.get(77));
    }

}

doNothing 方法

doNothing 方法可以对Void Method空方法进行打桩，其中所谓Void Method空方法指的是返回类型为void的方法。显然，对于Mock对象的Void Method空方法而言，没有打桩的必要。因为不打桩也不会调用真实的方法逻辑。故其更多的应用场景是对Spy对象的Void Method空方法进行打桩，使得当调用Void Method时，不会再调用真实的方法 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
public class MockDemo1 {

    @Test
    public void testDoNothing() {
        // 对于Spy的对象而言，其默认会调用真实方法
        Person person2 = Mockito.spy(Person.class);
        person2.hello("Bob");
         // 通过 doNothing 实现对Void Method空方法进行打桩
        // 使其不再会调用真实方法
        Mockito.doNothing()
            .when( person2 )
            .hello( "奥特曼" );
        person2.hello("奥特曼");
    }

}

class Person {
    
    ...

    public void hello(String name) {
        System.out.println("Hello, I'm "+name);
    }

    ...
}

测试结果如下，可以看到Void Method空方法一旦被打桩掉之后。原方法就不会再执行了，控制台也不会输出了

reset 方法

reset 方法可以重置Mock、Spy的对象，移除对其的所有打桩 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
public class MockDemo1 {

    @Test
    public void testReset() {
        Person person1 = Mockito.mock(Person.class);
        // 对Mock的对象进行打桩
        Mockito.doReturn(200)
            .when( person1 )
            .calc(13, 31);
        Mockito.doReturn(500)
            .when( person1 )
            .calc(3, 10);
        // 对Mock的对象进行打桩, 则调用后会返回打桩值
        Assertions.assertEquals(200, person1.calc(13,31));
        Assertions.assertEquals(500, person1.calc(3,10));
        // 重置Mock的对象, 移除对其的所有打桩
        Mockito.reset( person1 );
        // 对于未打桩的方法, 则Mock的对象会根据方法的返回类型, 返回相应的空值
        Assertions.assertEquals(0, person1.calc(13,31));
        Assertions.assertEquals(0, person1.calc(3,10));

        Person person2 = Mockito.spy(Person.class);
        // 对Spy的对象进行打桩
        Mockito.doReturn(200)
            .when( person2 )
            .calc(13, 31);
        Mockito.doReturn(500)
            .when( person2 )
            .calc(3, 10);
        // 对Spy的对象进行打桩, 则调用后会返回打桩值
        Assertions.assertEquals(200, person2.calc(13,31));
        Assertions.assertEquals(500, person2.calc(3,10));
        // 重置Spy的对象, 移除对其的所有打桩
        Mockito.reset( person2 );
        // 对于未打桩的方法, 则Spy的对象会调用真实的方法
        Assertions.assertEquals(44, person2.calc(13,31));
        Assertions.assertEquals(13, person2.calc(3,10));
    }

}


class Person {
    
    ...

    public int calc(Integer a, Integer b) {
        return a+b;
    }

    ...
}

Spy对象

与Mock对象是模拟的不同，Spy出来的对象是一个真实的对象。所以对于Spy出来的对象而言，如果调用未打桩的方法, 其会调用真实的方法。并根据调用结果返回真实的返回值；反之，如果Spy对象的方法被打桩了，则后续调用该方法时，真实方法将不会再被被调用，并返回打桩后值。这里特别说明下，在对Spy对象进行打桩过程中。如果使用then系列方法进行打桩, 则会导致真实方法在打桩过程中被调用；而如果使用do系列方法进行打桩, 则真实方法在打桩过程中不会被调用 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
public class SpyDemo1 {

    @Test
    public void testDiffMockSpy() {
        Animal animal1 = Mockito.mock( Animal.class );

        // Mock出来的对象, 如果调用未打桩的方法, 并不会调用真实的方法
        // 其根据方法的返回类型, 返回相应的空值
        Assertions.assertNull( animal1.getInfo("Aaron") );

        // Mock出来的对象, 通过then系列方法进行打桩
        // 并不会调用真实的方法, 其会直接返回相应的打桩值
        Mockito.when( animal1.getInfo("Bob") )
            .thenReturn("Hi, Bob");
        Assertions.assertEquals("Hi, Bob", animal1.getInfo("Bob"));

        // Mock出来的对象, 通过do系列方法进行打桩
        // 并不会调用真实的方法, 其会直接返回相应的打桩值
        Mockito.doReturn( "Hi, Tony" )
            .when( animal1 )
            .getInfo("Tony");
        Assertions.assertEquals("Hi, Tony", animal1.getInfo("Tony"));


        // Spy的对象是一个真实的对象
        Animal animal2 = Mockito.spy( Animal.class );

        // Spy出来的对象, 如果调用未打桩的方法, 其会调用真实的方法
        // 并根据调用结果返回真实的返回值
        Assertions.assertEquals("I'm 张三", animal2.getInfo("张三") );

        // Spy出来的对象, 利用then系列方法进行打桩, 则会导致真实方法在打桩过程中被调用
        Mockito.when( animal2.getInfo(ArgumentMatchers.anyString() ) )
            .thenReturn("我是李四");
        // 当打桩完毕后, 再调用该方法, 则不会调用真实方法
        Assertions.assertEquals("我是李四", animal2.getInfo("李四"));

        // Spy出来的对象, 利用do系列方法进行打桩, 则真实方法在打桩过程中不会被调用
        Mockito.doReturn("我是王二麻子")
            .when( animal2 )
            .getInfo("王二麻子");
        // 当打桩完毕后, 再调用该方法, 也不会调用真实方法
        Assertions.assertEquals("我是王二麻子", animal2.getInfo("王二麻子"));
    }
}

class Animal {
    public String getInfo(String name) {
        String info = "I'm " + name;
        System.out.println( info );
        return info;
    }
}

then系列方法、do系列方法 区别

虽然then系列方法、do系列方法的作用上是相同的。但在某些场景时可能无法使用then系列方法，使得我们只能使用do系列方法

对Spy对象进行打桩

前面提到，在对Spy对象进行打桩过程中。如果使用then系列方法进行打桩, 则会导致真实方法在打桩过程中被调用。此时即可能会导致打桩失败。这时则应该使用do系列方法进行打桩 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
public class DoThenDiff {

    /**
     * 对Spy对象的方法进行打桩
     */
    @Test
    public void stubOnSpy() {
        LinkedList<Integer> list1 = Mockito.spy( LinkedList.class );

        /*************** thenReturn、doReturn ***********************/
        try{
            Mockito.when( list1.get(3) )
                .thenReturn(32);
        } catch (IndexOutOfBoundsException e) { // 索引下标越界异常
            System.out.println("[thenReturn] Happen Exception : " + e.getMessage());
        }

        Mockito.doReturn(132)
            .when( list1 )
            .get( 13 );
        Assertions.assertEquals(132, list1.get(13));

        /**************** thenThrow、doThrow ************************/
        try{
            Mockito.when( list1.get(4) )
                .thenThrow( new RuntimeException("非法操作") );
        } catch (IndexOutOfBoundsException e) { // 索引下标越界异常
            System.out.println("[thenThrow] Happen Exception : " + e.getMessage());
        }

        Mockito.doThrow( new RuntimeException("这不是非法操作") )
            .when( list1 )
            .get( 14 );
        Exception ex1 =  Assertions.assertThrows(RuntimeException.class, ()->list1.get(14) );
        Assertions.assertEquals("这不是非法操作", ex1.getMessage() );

        /**************** then、thenAnswer、doAnswer ************************/
        try{
            Mockito.when( list1.get(5) )
                //.thenAnswer( invocation -> 211 );  // 也可通过thenAnswer方法实现相同的作用
                .then( invocation -> 211 );
        } catch (IndexOutOfBoundsException e) { // 索引下标越界异常
            System.out.println("[then] Happen Exception : " + e.getMessage());
        }

        Mockito.doAnswer( invocationOnMock -> 985 )
            .when( list1 )
            .get(15);
        Assertions.assertEquals(985, list1.get(15) );
    }
    
}

测试结果如下所示

对Void Method进行打桩

then系列方法无法对Void Method方法进行打桩，其会导致无法通过编译。故此时也只能选择do系列方法进行打桩 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
public class DoThenDiff {
    
    /**
     * 对Void Method空方法进行打桩
     */
    @Test
    public void stubOnVoidMethod() {
        List<String> list1 = Mockito.mock(LinkedList.class);

        // then系列方法无法对void方法进行打桩, 即下述代码会无法通过编译
//        Mockito.when( list1.add(7, "Tony") )
//            .thenThrow( new RuntimeException("今晚的月色真美") );

        Mockito.doThrow( new RuntimeException("风也温柔") )
            .when( list1 )
            .add(3, "Aaron");
        Exception ex1 =  Assertions.assertThrows(RuntimeException.class, ()->list1.add(3, "Aaron") );
        Assertions.assertEquals("风也温柔", ex1.getMessage() );
    }

}

基于注解的模拟

前面我们通过都是Mockito的mock、spy方法来模拟对象。事实上，我们还可以通过@Mock、@Spy注解标识其是一个Mock、Spy的对象。为了让这两个注解生效、并生成相应的对象。我们有两种方式实现

  • 方式1：在测试类上添加 @ExtendWith(MockitoExtension.class) 注解
  • 方式2：在测试类的初始化方法添加 MockitoAnnotations.initMocks(this) 实现

    • 进一步地，我们还可以使用 @InjectMocks 注解以实现将@Mock、@Spy修饰的对象自动注入到@InjectMocks修饰的对象中。其支持字段注入、构造器注入、set方法注入 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    		 
    // 使@Mock、@Spy注解生效 方式1
    @ExtendWith(MockitoExtension.class)
    public class AnnotationDemo {
        
        @Mock   // 标识该对象是一个Mock的对象
        private Man man;

        @Spy    // 标识该对象是一个Spy的对象
        private Woman woman;

        @InjectMocks // 将@Mock、@Spy修饰的对象自动注入到@InjectMocks修饰的对象中
        @Spy    // 标识该对象是一个Spy的对象
        private Human human;

        @BeforeEach
        public void init() {
            // 使@Mock、@Spy注解生效 方式2
            //MockitoAnnotations.initMocks(this);
        }

        @Test
        public void test1() {
            // 验证man已经被成功Mock了
            Assertions.assertNull( man.hello("Aaron") );
            Mockito.doReturn( "你好, 我是男人" )
                .when( man )
                .hello( ArgumentMatchers.anyString() );
            Assertions.assertEquals("你好, 我是男人", man.hello("Aaron") );

            // 验证woman已经被成功Spy了
            Assertions.assertEquals("Bye, I'm Tony", woman.bye("Tony") );
            Mockito.doReturn( "你好, 我是女人" )
                .when( woman )
                .bye( ArgumentMatchers.anyString() );
            Assertions.assertEquals("你好, 我是女人", woman.bye("Tony") );
        }

        /**
         *  验证human已经被成功Spy、且相关依赖也注入成功
         */
        @Test
        public void test2() {
            String info1 = human.getInfo("张三");
            Assertions.assertEquals("null...Bye, I'm 张三", info1);

            Mockito.doReturn( "你好, 我是男人" )
                .when( man )
                .hello( ArgumentMatchers.anyString() );
            Mockito.doReturn( "你好, 我是女人" )
                .when( woman )
                .bye( ArgumentMatchers.anyString() );

            String info2 = human.getInfo("李四");
            Assertions.assertEquals("你好, 我是男人...你好, 我是女人", info2);
        }

    }

    class Human {
        private Man man;

        private Woman woman;

        public String getInfo(String name) {
            String helloMsg = man.hello(name);
            String byeMsg = woman.bye(name);
            String info = helloMsg + "..." + byeMsg;
            return info;
        }
    }

    class Man {
        public String hello(String name) {
            String info = "Hello, I'm " + name;
            return info;
        }
    }

    class Woman {
        public String bye(String name) {
            String info = "Bye, I'm " + name;
            return info;
        }
    }
     
    推荐文章
    有胆有识的勺子  ·  GitHub - wecom-sidebar/wecom-sidebar-react-tpl: 企业微信侧边栏 React 开发模板
    1 周前
    英俊的刺猬  ·  A guide to mocking functions and modules with Jest
    2 周前
    飘逸的李子  ·  ES6 Class Mocks · Jest
    2 周前
    谈吐大方的大白菜  ·  Use org.mockito.exceptions.misusing.WrongTypeOfReturnValue.MissingMethodInvocationException in Mocki
    2 周前
    一身肌肉的冲锋衣  ·  Mockito模拟静态方法报错：org.mockito.exceptions.misusing.MissingMethodInvocationException-百度开发者中心
    2 周前
    有胆有识的雪糕  ·  How to print the distinct value on list - Python Help - Discussions on Python.org
    1 月前
    乐观的番茄  ·  干货：简析芯片反向设计流程 - 晶圆制造 - 半导体行业观察
    2 月前
    淡定的啄木鸟  ·  ubuntu宏基因组物种注释
    5 月前
    爱旅游的蛋挞  ·  玄幻我天命大反派顾长歌最新章节txt下载 - 天命反派著 - 玄幻小说 - 笔趣阁手机阅读
    6 月前
    慷慨大方的柠檬  ·  albumentationsのpipインストール時に生じたopencv-python-headless buildエラーの解消法 #Python3 - Qiita
    7 月前
    Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
    link管理 - 链接快照平台