SpringBoot 單元測試詳解（Mockito、MockBean）

一個測試方法主要包括三部分：

1）setup

2）執行操作

3）驗證結果

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 在所有測試方法后執行一次，一般在其中寫上銷毀和釋放資源的代碼。

// 注意這兩個都是靜態方法
@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 文件需要添加的依賴：

<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

示例：

• 驗證行為是否發生

//模擬創建一個List對象
List<Integer> mock =  Mockito.mock(List.class);
//調用mock對象的方法
mock.add(1);
mock.clear();
//驗證方法是否執行
Mockito.verify(mock).add(1);
Mockito.verify(mock).clear();

　　

• 多次觸發返回不同值

//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);

　　

• 模擬拋出異常

@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是等價的

  @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";
          }
      }
  }

　　

• 參數匹配

@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 類型的值 等等。

@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來對比

Comparator comparator = mock(Comparator.class); comparator.compare("nihao","hello"); //如果你使用了參數匹配，那么所有的參數都必須通過matchers來匹配 Mockito.verify(comparator).compare(Mockito.anyString(),Mockito.eq("hello")); //下面的為無效的參數匹配使用 //verify(comparator).compare(anyString(),"hello"); 

• 自定義參數匹配

@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; } } 

• 預期回調接口生成期望值

@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]; } } 等價於：(也可使用匿名內部類實現) @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)); } 

• 預期回調接口生成期望值（直接執行）

@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 "小於三"; } } } 

• 修改對未預設的調用返回默認期望（指定返回值）

//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監控真實對象,設置真實對象行為

    @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)); } 

• 不做任何返回

@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; } } 

• 調用真實的方法

@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

    @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 注解

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

@RunWith(MockitoJUnitRunner.class) public class MockitoTest2 { @Mock private List mockList; @Test public void shorthand(){ mockList.add(1); Mockito.verify(mockList).add(1); } } 

@MockBean

使用 @MockBean 可以解決單元測試中的一些依賴問題，示例如下：

@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.cnblogs.com/Ming8006/p/6297333.html#c3
https://www.vogella.com/tutorials/Mockito/article.html

 

轉至：https://www.jianshu.com/p/ecbd7b5a2021