个人中心
gpt4 book ai didi

SpringBoot 单元测试实战(Mockito,MockBean)

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章SpringBoot 单元测试实战(Mockito,MockBean)由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

一个测试方法主要包括三部分

1）setup 。

2）执行操作 。

3）验证结果 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class CalculatorTest {
     Calculator mCalculator;
     @Before // setup
     public void setup() {
         mCalculator = new Calculator();
     }
     @Test //assert 部分可以帮助我们验证一个结果
     public void testAdd() throws Exception {
         int sum = mCalculator.add( 1 , 2 );
         assertEquals( 3 , sum);  //为了简洁，往往会static import Assert里面的所有方法。
     }
     @Test
     @Ignore ( "not implemented yet" ) // 测试时忽略该方法
     public void testMultiply() throws Exception {
     }
     // 表示验证这个测试方法将抛出 IllegalArgumentException 异常，若没抛出，则测试失败
     @Test (expected = IllegalArgumentException. class )
     public void test() {
         mCalculator.divide( 4 , 0 );
     }
}

Junit 基本注解介绍

  • @BeforeClass 在所有测试方法执行前执行一次，一般在其中写上整体初始化的代码。
  • @AfterClass 在所有测试方法后执行一次，一般在其中写上销毁和释放资源的代码。
?
1
2
3
4
5
6
7
8
// 注意这两个都是静态方法
@BeforeClass
public static void test(){
    
}
@AfterClass
public static void test(){
}
  • @Before 在每个方法测试前执行，一般用来初始化方法（比如我们在测试别的方法时，类中与其他测试方法共享的值已经被改变，为了保证测试结果的有效性，我们会在@Before注解的方法中重置数据）
  • @After 在每个测试方法执行后，在方法执行完成后要做的事情。
  • @Test(timeout = 1000) 测试方法执行超过1000毫秒后算超时，测试将失败。
  • @Test(expected = Exception.class) 测试方法期望得到的异常类，如果方法执行没有抛出指定的异常，则测试失败。
  • @Ignore("not ready yet") 执行测试时将忽略掉此方法，如果用于修饰类，则忽略整个类。
  • @Test 编写一般测试用例用。
  • @RunWith 在 Junit 中有很多个 Runner，他们负责调用你的测试代码，每一个 Runner 都有各自的特殊功能，你根据需要选择不同的 Runner 来运行你的测试代码。

如果我们只是简单的做普通 Java 测试，不涉及 Spring Web 项目，你可以省略 @RunWith 注解，你要根据需要选择不同的 Runner 来运行你的测试代码.

测试方法执行顺序

按照设计，Junit不指定test方法的执行顺序.

  • @FixMethodOrder(MethodSorters.JVM):保留测试方法的执行顺序为JVM返回的顺序。每次测试的执行顺序有可能会所不同。
  • @FixMethodOrder(MethodSorters.NAME_ASCENDING) :根据测试方法的方法名排序,按照词典排序规则(ASC,从小到大,递增)。

Failure 是测试失败，Error 是程序出错.

测试方法命名约定

Maven本身并不是一个单元测试框架，它只是在构建执行到特定生命周期阶段的时候，通过插件来执行JUnit或者TestNG的测试用例。这个插件就是maven-surefire-plugin，也可以称为测试运行器(Test Runner)，它能兼容JUnit 3、JUnit 4以及TestNG.

在默认情况下，maven-surefire-plugin的test目标会自动执行测试源码路径（默认为src/test/java/）下所有符合一组命名模式的测试类。这组模式为:

  • */Test.java：任何子目录下所有命名以Test开关的Java类。
  • */Test.java：任何子目录下所有命名以Test结尾的Java类。
  • */TestCase.java：任何子目录下所有命名以TestCase结尾的Java类。

基于 Spring 的单元测试编写

首先我们项目一般都是 MVC 分层的，而单元测试主要是在 Dao 层和 Service 层上进行编写。从项目结构上来说，Service 层是依赖 Dao 层的，但是从单元测试角度，对某个 Service 进行单元的时候，他所有依赖的类都应该进行Mock。而 Dao 层单元测试就比较简单了，只依赖数据库中的数据.

Mockito

Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁.

Mockito 是一个针对 Java 的单元测试模拟框架，它与 EasyMock 和 jMock 很相似，都是为了简化单元测试过程中测试上下文 ( 或者称之为测试驱动函数以及桩函数 ) 的搭建而开发的工具 。

相对于 EasyMock 和 jMock，Mockito 的优点是通过在执行后校验哪些函数已经被调用，消除了对期望行为（expectations）的需要。其它的 mocking 库需要在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码.

SpringBoot 中的 pom.xml 文件需要添加的依赖:

?
1
2
3
4
5
< dependency >
     < groupId >org.springframework.boot</ groupId >
     < artifactId >spring-boot-starter-test</ artifactId >
     < scope >test</ scope >
</ dependency >

进入 spring-boot-starter-test-2.1.3.RELEASE.pom 可以看到该依赖中已经有单元测试所需的大部分依赖，如:

  • junit
  • mockito
  • hamcrest

若为其他 spring 项目，需要自己添加 Junit 和 mockito 项目.

常用的 Mockito 方法

方法名 描述
Mockito.mock(classToMock) 模拟对象
Mockito.verify(mock) 验证行为是否发生
Mockito.when(methodCall).thenReturn(value1).thenReturn(value2) 触发时第一次返回value1，第n次都返回value2
Mockito.doThrow(toBeThrown).when(mock).[method] 模拟抛出异常。
Mockito.mock(classToMock,defaultAnswer) 使用默认Answer模拟对象
Mockito.when(methodCall).thenReturn(value) 参数匹配
Mockito.doReturn(toBeReturned).when(mock).[method] 参数匹配（直接执行不判断）
Mockito.when(methodCall).thenAnswer(answer)) 预期回调接口生成期望值
Mockito.doAnswer(answer).when(methodCall).[method] 预期回调接口生成期望值（直接执行不判断）
Mockito.spy(Object) 用spy监控真实对象,设置真实对象行为
Mockito.doNothing().when(mock).[method] 不做任何返回
Mockito.doCallRealMethod().when(mock).[method] //等价于Mockito.when(mock.[method]).thenCallRealMethod(); 调用真实的方法
reset(mock) 重置mock

示例

验证行为是否发生 。

?
1
2
3
4
5
6
7
8
//模拟创建一个List对象
List<Integer> mock =  Mockito.mock(List. class );
//调用mock对象的方法
mock.add( 1 );
mock.clear();
//验证方法是否执行
Mockito.verify(mock).add( 1 );
Mockito.verify(mock).clear();

多次触发返回不同值 。

?
1
2
3
4
5
6
7
8
//mock一个Iterator类
Iterator iterator = mock(Iterator. class );
//预设当iterator调用next()时第一次返回hello，第n次都返回world
Mockito.when(iterator.next()).thenReturn( "hello" ).thenReturn( "world" );
//使用mock的对象
String result = iterator.next() + " " + iterator.next() + " " + iterator.next();
//验证结果
Assert.assertEquals( "hello world world" ,result);

模拟抛出异常 。

?
1
2
3
4
5
6
7
@Test (expected = IOException. class ) //期望报IO异常
public void when_thenThrow() throws IOException{
       OutputStream mock = Mockito.mock(OutputStream. class );
       //预设当流关闭时抛出异常
       Mockito.doThrow( new IOException()).when(mock).close();
       mock.close();
   }

使用默认Answer模拟对象 。

RETURNS_DEEP_STUBS 是创建mock对象时的备选参数之一 。

以下方法deepstubsTest和deepstubsTest2是等价的 。

?
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
@Test
public void deepstubsTest(){
     A a=Mockito.mock(A. class ,Mockito.RETURNS_DEEP_STUBS);
     Mockito.when(a.getB().getName()).thenReturn( "Beijing" );
     Assert.assertEquals( "Beijing" ,a.getB().getName());
}
@Test
public void deepstubsTest2(){
     A a=Mockito.mock(A. class );
     B b=Mockito.mock(B. class );
     Mockito.when(a.getB()).thenReturn(b);
     Mockito.when(b.getName()).thenReturn( "Beijing" );
     Assert.assertEquals( "Beijing" ,a.getB().getName());
}
class A{
     private B b;
     public B getB(){
         return b;
     }
     public void setB(B b){
         this .b=b;
     }
}
class B{
     private String name;
     public String getName(){
         return name;
     }
     public void setName(String name){
         this .name = name;
     }
     public String getSex(Integer sex){
         if (sex== 1 ){
             return "man" ;
         } else {
             return "woman" ;
         }
     }
}

参数匹配 。

?
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
@Test
public void with_arguments(){
     B b = Mockito.mock(B. class );
     //预设根据不同的参数返回不同的结果
     Mockito.when(b.getSex( 1 )).thenReturn( "男" );
     Mockito.when(b.getSex( 2 )).thenReturn( "女" );
     Assert.assertEquals( "男" , b.getSex( 1 ));
     Assert.assertEquals( "女" , b.getSex( 2 ));
     //对于没有预设的情况会返回默认值
     Assert.assertEquals( null , b.getSex( 0 ));
}
class B{
     private String name;
     public String getName(){
         return name;
     }
     public void setName(String name){
         this .name = name;
     }
     public String getSex(Integer sex){
         if (sex== 1 ){
             return "man" ;
         } else {
             return "woman" ;
         }
     }
}

匹配任意参数 。

  • Mockito.anyInt() 任何 int 值 ；
  • Mockito.anyLong() 任何 long 值 ；
  • Mockito.anyString() 任何 String 值 ；

Mockito.any(XXX.class) 任何 XXX 类型的值 等等.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void with_unspecified_arguments(){
     List list = Mockito.mock(List. class );
     //匹配任意参数
     Mockito.when(list.get(Mockito.anyInt())).thenReturn( 1 );
     Mockito.when(list.contains(Mockito.argThat( new IsValid()))).thenReturn( true );
     Assert.assertEquals( 1 ,list.get( 1 ));
     Assert.assertEquals( 1 ,list.get( 999 ));
     Assert.assertTrue(list.contains( 1 ));
     Assert.assertTrue(!list.contains( 3 ));
}
class IsValid extends ArgumentMatcher<List>{
     @Override
     public boolean matches(Object obj) {
         return obj.equals( 1 ) || obj.equals( 2 );
     }
}

注意：使用了参数匹配，那么所有的参数都必须通过matchers来匹配 。

Mockito继承Matchers，anyInt()等均为Matchers方法 。

当传入两个参数，其中一个参数采用任意参数时，指定参数需要matchers来对比 。

?
1
2
3
4
5
6
Comparator comparator = mock(Comparator. class );
comparator.compare( "nihao" , "hello" );
//如果你使用了参数匹配，那么所有的参数都必须通过matchers来匹配
Mockito.verify(comparator).compare(Mockito.anyString(),Mockito.eq( "hello" ));
//下面的为无效的参数匹配使用
//verify(comparator).compare(anyString(),"hello");

自定义参数匹配 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void argumentMatchersTest(){
    //创建mock对象
    List<String> mock = mock(List. class );
    //argThat(Matches<T> matcher)方法用来应用自定义的规则，可以传入任何实现Matcher接口的实现类。
    Mockito.when(mock.addAll(Mockito.argThat( new IsListofTwoElements()))).thenReturn( true );
    Assert.assertTrue(mock.addAll(Arrays.asList( "one" , "two" , "three" )));
}
class IsListofTwoElements extends ArgumentMatcher<List>
{
    public boolean matches(Object list)
    {
        return ((List)list).size()== 3 ;
    }
}

预期回调接口生成期望值 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void answerTest(){
       List mockList = Mockito.mock(List. class );
       //使用方法预期回调接口生成期望值（Answer结构）
       Mockito.when(mockList.get(Mockito.anyInt())).thenAnswer( new CustomAnswer());
       Assert.assertEquals( "hello world:0" ,mockList.get( 0 ));
       Assert.assertEquals( "hello world:999" ,mockList.get( 999 ));
   }
   private class CustomAnswer implements Answer<String> {
       @Override
       public String answer(InvocationOnMock invocation) throws Throwable {
           Object[] args = invocation.getArguments();
           return "hello world:" +args[ 0 ];
       }
   }

等价于：(也可使用匿名内部类实现) 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@Test
  public void answer_with_callback(){
       //使用Answer来生成我们我们期望的返回
       Mockito.when(mockList.get(Mockito.anyInt())).thenAnswer( new Answer<Object>() {
           @Override
           public Object answer(InvocationOnMock invocation) throws Throwable {
               Object[] args = invocation.getArguments();
               return "hello world:" +args[ 0 ];
           }
       });
       Assert.assertEquals( "hello world:0" ,mockList.get( 0 ));
      Assert. assertEquals( "hello world:999" ,mockList.get( 999 ));
   }

预期回调接口生成期望值（直接执行） 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test
public void testAnswer1(){
List<String> mock = Mockito.mock(List. class ); 
       Mockito.doAnswer( new CustomAnswer()).when(mock).get(Mockito.anyInt()); 
       Assert.assertEquals( "大于三" , mock.get( 4 ));
       Assert.assertEquals( "小于三" , mock.get( 2 ));
}
public class CustomAnswer implements Answer<String> { 
   public String answer(InvocationOnMock invocation) throws Throwable { 
       Object[] args = invocation.getArguments(); 
       Integer num = (Integer)args[ 0 ]; 
       if ( num> 3 ){ 
           return "大于三" ; 
       } else { 
           return "小于三" ;  
       } 
   }
}

修改对未预设的调用返回默认期望（指定返回值） 。

?
1
2
3
4
5
6
7
8
9
10
11
//mock对象使用Answer来对未预设的调用返回默认期望值
List mock = Mockito.mock(List. class , new Answer() {
      @Override
      public Object answer(InvocationOnMock invocation) throws Throwable {
          return 999 ;
      }
  });
  //下面的get(1)没有预设，通常情况下会返回NULL，但是使用了Answer改变了默认期望值
  Assert.assertEquals( 999 , mock.get( 1 ));
  //下面的size()没有预设，通常情况下会返回0，但是使用了Answer改变了默认期望值
  Assert.assertEquals( 999 ,mock.size());

用spy监控真实对象,设置真实对象行为 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test (expected = IndexOutOfBoundsException. class )
public void spy_on_real_objects(){
     List list = new LinkedList();
     List spy = Mockito.spy(list);
     //下面预设的spy.get(0)会报错，因为会调用真实对象的get(0)，所以会抛出越界异常
     //Mockito.when(spy.get(0)).thenReturn(3);
     //使用doReturn-when可以避免when-thenReturn调用真实对象api
     Mockito.doReturn( 999 ).when(spy).get( 999 );
     //预设size()期望值
     Mockito.when(spy.size()).thenReturn( 100 );
     //调用真实对象的api
     spy.add( 1 );
     spy.add( 2 );
     Assert.assertEquals( 100 ,spy.size());
     Assert.assertEquals( 1 ,spy.get( 0 ));
     Assert.assertEquals( 2 ,spy.get( 1 ));
     Assert.assertEquals( 999 ,spy.get( 999 ));
}

不做任何返回 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Test
public void Test() {
     A a = Mockito.mock(A. class );
     //void 方法才能调用doNothing()
     Mockito.doNothing().when(a).setName(Mockito.anyString());
     a.setName( "bb" );
     Assert.assertEquals( "bb" ,a.getName());
}
class A {
     private String name;
     private void setName(String name){
         this .name = name;
     }
     private String getName(){
         return name;
     }
}

调用真实的方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void Test() {
     A a = Mockito.mock(A. class );
     //void 方法才能调用doNothing()
     Mockito.when(a.getName()).thenReturn( "bb" );
     Assert.assertEquals( "bb" ,a.getName());
     //等价于Mockito.when(a.getName()).thenCallRealMethod();
     Mockito.doCallRealMethod().when(a).getName();
     Assert.assertEquals( "zhangsan" ,a.getName());
}
class A {
     public String getName(){
         return "zhangsan" ;
     }
}

重置 mock 。

?
1
2
3
4
5
6
7
8
9
10
@Test
public void reset_mock(){
     List list = mock(List. class );
     Mockito. when(list.size()).thenReturn( 10 );
     list.add( 1 );
     Assert.assertEquals( 10 ,list.size());
     //重置mock，清除所有的互动和预设
     Mockito.reset(list);
     Assert.assertEquals( 0 ,list.size());
}

@Mock 注解 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
public class MockitoTest {
     @Mock
     private List mockList;
     //必须在基类中添加初始化mock的代码，否则报错mock的对象为NULL
     public MockitoTest(){
         MockitoAnnotations.initMocks( this );
     }
     @Test
     public void AnnoTest() {
             mockList.add( 1 );
         Mockito.verify(mockList).add( 1 );
     }
}

指定测试类使用运行器：MockitoJUnitRunner 。

?
1
2
3
4
5
6
7
8
9
10
@RunWith (MockitoJUnitRunner. class )
public class MockitoTest2 {
     @Mock
     private List mockList;
     @Test
     public void shorthand(){
         mockList.add( 1 );
         Mockito.verify(mockList).add( 1 );
     }
}

@MockBean

使用 @MockBean 可以解决单元测试中的一些依赖问题，示例如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@RunWith (SpringRunner. class )
@SpringBootTest
public class ServiceWithMockBeanTest {
     @MockBean
     SampleDependencyA dependencyA;
     @Autowired
     SampleService sampleService;
     @Test
     public void testDependency() {
         when(dependencyA.getExternalValue(anyString())).thenReturn( "mock val: A" );
         assertEquals( "mock val: A" , sampleService.foo());
     }
}

@MockBean 只能 mock 本地的代码——或者说是自己写的代码，对于储存在库中而且又是以 Bean 的形式装配到代码中的类无能为力.

@SpyBean 解决了 SpringBoot 的单元测试中 @MockBean 不能 mock 库中自动装配的 Bean 的局限（目前还没需求，有需要的自己查阅资料）.

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我.

原文链接：https://www.jianshu.com/p/ecbd7b5a2021 。

最后此篇关于SpringBoot 单元测试实战(Mockito,MockBean)的文章就讲到这里了,如果你想了解更多关于SpringBoot 单元测试实战(Mockito,MockBean)的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： 如何在Java中创建线程通信的四种方式你知道吗
文章推荐： 原神千门虚舟旁边的传送点怎么开？原神千门虚舟机关解锁攻略
文章推荐： 原神雷电将军巴尔圣遗物怎么搭配 原神雷电将军技能是什么
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com