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

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

     }

}

// 注意这两个都是静态方法

@BeforeClass

public static void test(){

}

@AfterClass

public static void test(){

}

< dependency >

     < groupId >org.springframework.boot</ groupId >

     < artifactId >spring-boot-starter-test</ artifactId >

     < scope >test</ scope >

</ dependency >

//模拟创建一个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();

   }

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

         }

     }

}

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

     }

}

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

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

     }

}

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

}

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

     }

}

@RunWith (MockitoJUnitRunner. class )

public class MockitoTest2 {

     @Mock

     private List mockList;

     @Test

     public void shorthand(){

         mockList.add( 1 );

         Mockito.verify(mockList).add( 1 );

     }

}

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

     }

}