单元测试：Mockito测试框架中的方法详解

这里写目录标题

第一章、模拟对象

1.1）①mock()方法：

用于创建给定类或接口的模拟对象，创建对象的另一种方式就是直接用@Mock/InjectMocks注解来创建模拟对象，第三章有介绍。

注意：无法mock final类和final方法，静态方法和静态对象，私有方法。

importjava.util.List;importstaticorg.mockito.Mockito.*;publicclassMockitoMockMethodExample{publicvoidtestMultipleMocks(){// 使用 Mockito.mock() 方法创建多个模拟对象List<String> mockList1 =mock(List.class);List<String> mockList2 =mock(List.class);// 设置第一个模拟对象的预期行为when(mockList1.size()).thenReturn(5);// 设置第二个模拟对象的预期行为when(mockList2.size()).thenReturn(10);// 断言模拟对象的行为符合预期assert(mockList1.size()==5);assert(mockList2.size()==10);}}

1.2）②spy()方法：

用于部分模拟对象，可以对真实对象的特定方法进行覆盖。它保留了真实对象的部分行为。Spy对象既可以模拟方法的返回值，也可以保留方法的实际行为。

示例中：spy() 方法创建了一个 ArrayList 对象的部分模拟，然后使用 when().thenReturn() 方法对 size() 方法进行了模拟。最后，调用部分模拟对象的真实方法时，模拟的方法返回了预期的值。

importstaticorg.mockito.Mockito.*;// 示例：创建一个部分模拟的对象List<String> list =newArrayList<>();List<String> listSpy =spy(list);// 示例：模拟部分方法when(listSpy.size()).thenReturn(10);// 示例：调用部分模拟对象的真实方法
listSpy.add("one");System.out.println(listSpy.size());// 输出 10，因为 size() 方法被模拟为返回 10

第二章、模拟对象行为

2.1）模拟方法调用

①when()方法

用于指定模拟对象的方法调用，并设置相应的操作，例如返回值、异常等。
when()：此方法需要一个方法调用作为参数（通常是模拟对象的一个方法）。它会记录下这个方法调用，并允许你接下来定义这个方法调用的行为。

when(service.方法名(参数))

2.2）模拟返回值

②thenReturn(要返回的值)

thenReturn(T value)，这个方法需要你想要返回的值作为参数。当 when() 中指定的方法被调用时，模拟对象将返回这个值。

当使用模拟对象(用@Mock注释)，选择thenReturn模拟有返回值（非void）的方法

如果使用监视对象(用@Spy注释)，when(…) thenReturn(…)在返回指定值之前会进行实际方法调用。就需要处理这个方法可能抛出的异常。所以有异常的方法一般不使用thenReturn

when(service.方法名(参数)).thenReturn(要返回的值)

示例：

publicclassMockitoExample{@TestvoidtestWhenThenReturn(){// 创建模拟对象List mockedList =Mockito.mock(List.class);// 定义当调用mockedList.get(0)时返回"first"Mockito.when(mockedList.get(0)).thenReturn("first");// 使用模拟对象System.out.println(mockedList.get(0));// 输出 "first"System.out.println(mockedList.get(1));// 输出 null，因为我们没有定义get(1)的行为}}

③doReturn()

当使用模拟对象(用@Mock注释)，选择thenReturn模拟无返回值（void）的方法

如果使用监视对象(用@Spy注释)，doReturn(…) when(…)不会真正调用该方法。这意味着即使被调用的真实方法抛出异常，也不会影响测试。所以doReturn() 方法通常用于对部分模拟对象（spy）进行方法模。

doReturn(10).when(listSpy).size();

示例：

importstaticorg.mockito.Mockito.*;// 示例：创建一个部分模拟的对象List<String> list =newArrayList<>();List<String> listSpy =spy(list);// 示例：使用doReturn方法模拟部分方法doReturn(10).when(listSpy).size();// 示例：调用部分模拟对象的真实方法
listSpy.add("one");System.out.println(listSpy.size());// 输出 10，因为 size() 方法被模拟为返回 10

2.3）模拟并替换原方法的行为

④thenAnswer()

如果在方法调用中需要固定的返回值，则应使用thenReturn()。 如果需要执行某些操作或替换原方法的行为，则应使用thenAnswer()

如下示例：在调用getCurrentTime方法时作用是获取当前的日期和时间。我想使用Instant.now().toEpochMilli();方法替换getCurrentTime方法的内部代码逻辑。

则需要先
1、实现接口org.mockito.stubbing.Answer的类的对象。
2、在方法answer（…）内部自定义行为。
3、我们从模拟对象中调用模拟方法getCurrentTime时，实际上是执行answer中的代码逻辑。

importorg.junit.Test;importorg.mockito.Mockito;importorg.mockito.invocation.InvocationOnMock;importorg.mockito.stubbing.Answer;importjava.time.Instant;publicclassTimeServiceTest{@TestpublicvoidtestGetCurrentTime(){// 创建TimeService类的模拟对象TimeService timeService =Mockito.mock(TimeService.class);// 创建一个 Answer 对象，实现 answer 方法来返回当前系统时间Answer<Long> answer =newAnswer<Long>(){publicLonganswer(InvocationOnMock invocation)throwsThrowable{returnInstant.now().toEpochMilli();}};// 使用 thenAnswer() 指定模拟对象的方法返回当前系统时间Mockito.when(timeService.getCurrentTime()).thenAnswer(answer);// 调用模拟对象的方法，实际执行的是answer中的代码逻辑long currentTime = timeService.getCurrentTime();// 验证方法是否被调用Mockito.verify(timeService).getCurrentTime();// 进行进一步的断言}}

我们可以也使用Java 8 lambda功能来实现answer方法。

publicclassTimeServiceTest{@TestpublicvoidtestGetCurrentTime(){// 创建TimeService类的模拟对象TimeService timeService =Mockito.mock(TimeService.class);// 创建一个 Answer 对象，实现 answer 方法来返回当前系统时间Answer<Long> answer =newAnswer<Long>(){publicLonganswer(InvocationOnMock invocation)throwsThrowable{returnInstant.now().toEpochMilli();}};// 使用 thenAnswer() 指定模拟对象的方法返回当前系统时间Mockito.when(timeService.getCurrentTime()).thenAnswer(answer);// 调用模拟对象的方法，实际执行的是answer中的代码逻辑long currentTime = timeService.getCurrentTime();// 验证方法是否被调用Mockito.verify(timeService).getCurrentTime();// 进行进一步的断言}}

⑤doAnswer

更适用于对 void 方法进行模拟。你可以使用 doAnswer 来执行额外的操作，比如触发回调、记录日志等，因为 void 方法本身没有返回值。
创建一个 Answer 对象，实现 answer 方法来指定特定的操作或返回值，

示例中：通过Mockito的模拟，我们成功地替换了原来calculate方法的实际行为

doAnswer(answer).when(service).方法(Mockito.anyInt(),Mockito.anyInt());

示例：

// 假设有一个名为Service的类，其中包含一个方法publicclassService{publicintcalculate(int a,int b){// 一些复杂的计算return a + b;}}// 在测试中，使用Mockito来模拟Service类的行为importorg.mockito.Mockito;importorg.mockito.invocation.InvocationOnMock;importorg.mockito.stubbing.Answer;publicclassServiceTest{@TestpublicvoidtestCalculate(){// 创建Service类的模拟对象Service service =Mockito.mock(Service.class);// 创建一个 Answer 对象，实现 answer 方法来指定特定的操作或返回值Answer<Integer> answer =newAnswer<Integer>(){publicIntegeranswer(InvocationOnMock invocation)throwsThrowable{int a = invocation.getArgument(0);int b = invocation.getArgument(1);// 在 answer 方法中执行特定的操作或返回特定的值return a * b;}};//doAnswer表示当calculate方法被调用时，执行特定的操作   Mockito.doAnswer(answer).when(service).calculate(Mockito.anyInt(),Mockito.anyInt());// 调用模拟对象的方法//当调用service.calculate(2, 3)时，实际执行的是2 * 3，结果为6int result = service.calculate(2,3);// 验证方法是否被调用，并且返回了预期的值Mockito.verify(service).calculate(2,3);assertEquals(6, result);}}

2.4）部分模拟时是否调用真实方法

⑥thenCallRealMethod()

用于部分模拟对象（spy）时，当调用指定方法时，实际调用对象的真实方法而不是模拟方法。特别是当需要部分模拟对象并且希望某些方法执行真实逻辑时。

when(service.方法名(参数)).thenCallRealMethod()

示例：

// 假设有一个名为UserService的类publicclassUserService{publicStringprocess(String input){// 实际的方法逻辑return"Processed: "+ input;}}// 创建UserService的部分模拟对象UserService userService =Mockito.spy(UserService.class);// 当调用process方法时，执行实际的方法逻辑Mockito.when(userService.process("input")).thenCallRealMethod();// 调用部分模拟对象的方法String result = userService.process("input");// 输出结果，将会是"Processed: input"，因为实际的方法逻辑被执行了System.out.println(result);

⑦doCallRealMethod()

用于部分模拟对象（spy）时，用于调用真实对象的实际方法，而不是模拟方法的行为。这在部分模拟对象（spy）中特别有用，因为它允许部分模拟对象调用其真实的方法，而不是模拟方法的行为。

doCallRealMethod().when(someObject).someMethod();

示例：

// 创建一个部分模拟对象SomeClass someObject =mock(SomeClass.class);doCallRealMethod().when(someObject).someMethod();// 调用真实方法
someObject.someMethod();

2.5）模拟抛出异常

⑧thenThrow()

thenThrow 适用于有出参的方法，thenThrow方法指定了在调用该方法时抛出指定的异常，而 thenThrow() 方法更适合在特定条件下抛出异常。

when(mockedList.get(0)).thenThrow(newRuntimeException())

示例：这里是RuntimeException

when(service.方法名(参数)).thenThrow(newRuntimeException());

示例：

importstaticorg.mockito.Mockito.*;publicclassExampleTest{@TestpublicvoidtestMethod(){// 创建被mock的对象SomeClass mockObj =mock(SomeClass.class);// 设置当调用mockObj.method时抛出异常when(mockObj.method(anyString())).thenThrow(newRuntimeException("Something went wrong"));// 调用被mock的方法这里会抛出异常
        mockObj.method("test");}}

⑨doThrow()

doThrow 适用于 没有出参的方法，在测试中模拟抛出异常的情况。doThrow() 方法更适合在调用特定方法时强制抛出异常

doThrow(newRuntimeException()).when(mockedList).get(0)

示例：

importstaticorg.mockito.Mockito.*;// 创建mock对象List<String> mockedList =mock(List.class);// 指定当调用mockedList的get()方法时抛出异常doThrow(newRuntimeException()).when(mockedList).get(0);// 调用被测方法
mockedList.get(0);// 这里会抛出指定的异常

2.6）模拟构造函数和静态方法

⑩模拟构造函数MockedConstruction

在单元测试中，当需要在测试中模拟某个类的实例时，使用MockedConstruction可以模拟构造函数的行为，如果没有模拟构造函数，那么在使用new关键字创建对象时，会执行实际的构造函数

作用：当需要在测试中模拟第三方库的对象时，可以使用MockedConstruction来模拟构造函数，而不实际调用第三方库的构造函数，从而避免对外部资源的依赖。

importorg.junit.jupiter.api.Test;importorg.mockito.MockedConstruction;importorg.mockito.Mockito;publicclassExampleTest{@TestvoidtestWithMockedConstruction(){//模拟构造函数行为try(MockedConstruction<MyClass> mocked =Mockito.mockConstruction(MyClass.class)){//模拟完以后再创建对象，此时执行的就是模拟的构造函数，而不是实际的MyClass myClass =newMyClass();//调用get方法Mockito.when(myClass.getName()).thenReturn("mocked value");// 在这里使用myClass进行测试}}}

⑩①模拟静态方法：MockedStatic

MockedStatic是Mockito框架中的一个类，用于模拟静态方法的行为。通过使用MockedStatic，您可以模拟静态方法的返回值，以及验证静态方法的调用次数。

importorg.mockito.MockedStatic;importorg.mockito.Mockito;publicclassExample{publicvoidexampleMethod(){//YourClassWithStaticMethod是包含静态方法的类try(MockedStatic<YourClassWithStaticMethod> mockedStatic =Mockito.mockStatic
        (YourClassWithStaticMethod.class)){
        
mockedStatic.when(YourClassWithStaticMethod::staticMethod("param1")).thenReturn("someValue");// 调用静态方法YourClassWithStaticMethod.staticMethod("param1");// 验证静态方法是否被调用过
mockedStatic.verify(YourClassWithStaticMethod::staticMethod("param1"));}}}

2.7）其他方法

使void方法什么也不做doNothing()

doNothing() 方法的作用是用于设置模拟对象的 void 方法不执行任何操作。因为 mock 对象中，void 函数就是什么都不做，所以该方法更适合 spy 对象。

Mockito.doNothing().when(service).方法名(参数)

示例1：

staticclassExampleClass{publicvoidhello(){System.out.println("吃过了");}}/publicclassMockDemo{@Testpublicvoidtest(){ExampleClass exampleClass =spy(newExampleClass());ExampleClass.hello();//打印吃过了// 通过doNothein让方法什么都不做doNothing().when(exampleClass ).hello();
        exampleClass.hello();// 什么都不输出}}

示例2：这是复制的国外一个博主的代码

List list =newLinkedList();List spy =spy(list);//let's make clear() do nothing doNothing().when(spy).clear(); 
spy.add("one");//clear() does nothing, so the list still contains "one" 
spy.clear();

重置模拟对象状态reset()方法：

用于重置模拟对象的状态或者将对象恢复到初始状态

importorg.junit.Test;importorg.mockito.Mockito;// 创建一个模拟对象List<String> mockedList =Mockito.mock(List.class);// 对模拟对象进行方法调用
mockedList.add("one");System.out.println(mockedList.size());// 输出 1// 重置模拟对象的状态Mockito.reset(mockedList);// 再次对模拟对象进行方法调用System.out.println(mockedList.size());// 输出 0，因为模拟对象的状态已被重置

第三章、模拟对象行为验证

3.1）验证调用次数

①verify()方法：

用于验证模拟对象的指定方法是否被调用。可以进一步验证方法的调用次数和参数。

importorg.junit.jupiter.api.Test;importorg.mockito.Mockito;importjava.util.List;publicclassMockitoExample{@TestvoidtestMock(){// 创建模拟对象List mockedList =Mockito.mock(List.class);// 使用模拟对象
        mockedList.add("one");Mockito.verify(mockedList).add("one");// 验证模拟对象的某些行为是否发生过Mockito.verify(mockedList,Mockito.times(1)).add("one");}}

②verify(object, Mockito.times(2))方法

是一个 Mockito 框架中的验证方法，用于验证某个行为在模拟对象上被调用了几次。times() 方法需要一个整数参数，代表你期望的调用次数。然后，将返回一个 VerificationMode 实例，这个实例可以和 verify() 方法一起使用，来检查某个操作是否被执行了指定次数。

下述代码；Mockito.times(2) 指的是，我们期望 add() 方法在模拟对象 mockedList 上被调用了两次。如果 add() 方法的实际调用次数不匹配我们的期望（例如，它只被调用了一次，或者三次），那么代码会抛出一个 MockitoAssertionError 异常。

publicclassMockitoExample{@TestvoidtestTimes(){// 创建模拟对象List mockedList =Mockito.mock(List.class);// 模拟方法调用
        mockedList.add("one");
        mockedList.add("one");// 验证该方法是否被调用了两次Mockito.verify(mockedList,Mockito.times(2)).add("one");}}

下述代码：不会抛出异常因为add了两次，与预期相符

importjava.util.List;importstaticorg.mockito.Mockito.*;publicclassMockitoTimesExample{publicvoidtestMethodInvocation(){// 创建模拟对象List<String> mockList =mock(List.class);// 调用模拟对象的方法
        mockList.add("item1");
        mockList.add("item2");// 验证方法调用次数verify(mockList,times(2)).add(anyString());}}

3.2）验证是否发生交互

③verifyNoMoreInteractions()方法：

verifyNoMoreInteractions() 方法用于验证mock对象在特定交互之后是否没有发生任何其他交互。它确保在测试中，mock对象在预期的交互之后没有进行多余交互。

多余交互指的是对于被mock的对象，测试代码中发生了未被预期的方法调用。这可能是因为测试代码中的某些逻辑导致了额外的方法调用。

importorg.junit.Test;importorg.mockito.Mockito;publicclassProcessorTest{@TestpublicvoidprocessTest(){// 创建 MyService 的 mock 对象MyService myMockService =Mockito.mock(MyService.class);// 创建 MyProcessor 对象，并传入 mock 对象MyProcessor myProcessor =newMyProcessor(myMockService);// 调用 MyProcessor 的 process() 和 process2() 方法
      myProcessor.process();
      myProcessor.process2();// 验证 mock 对象的交互Mockito.verify(myMockService).doSomething();Mockito.verify(myMockService).doSomething2();// 确保没有更多的交互发生Mockito.verifyNoMoreInteractions(myMockService);}}

④verifyZeroInteractions()方法：

用于验证模拟对象上是否没有发生任何交互。它确保在测试中，mock对象没有与任何其他对象进行交互。关注的是整个测试过程中是否有任何交互。

importstaticorg.mockito.Mockito.*;// 创建mock对象List<String> mockedList =mock(List.class);// 调用被测方法
mockedList.clear();// 验证是否发生了交互verify(mockedList).clear();verifyNoMoreInteractions(mockedList);// 确保没有其他交互

第四章、Assert结果断言

4.1）验证结果

①验证是否相等：Equals

assertEquals(expected, actual)：验证两个对象是否相等。
assertNotEquals(unexpected, actual)：验证两个对象是否不相等。

示例：验证 Calculator.add(3, 5) 的结果是否等于 8。如果不相等，测试用例将会失败，并输出指定的失败信息。

importstaticorg.junit.jupiter.api.Assertions.assertEquals;@TestvoidtestAddition(){int result =Calculator.add(3,5);assertEquals(8, result,"The addition result should be 8");}

assertArrayEquals(expectedArray, resultArray)：验证两个数组是否相等。
assertArrayEquals(expecteds, actuals, delta)：验证两个浮点数数组是否相等，可以指定误差范围。

示例：验证 expectedArray 和 resultArray 是否相等。如果两个数组不相等，测试用例将会失败，并输出指定的失败信息。

importstaticorg.junit.jupiter.api.Assertions.assertArrayEquals;@TestvoidtestArrayEquality(){int[] expectedArray ={1,2,3};int[] resultArray ={1,2,3};assertArrayEquals(expectedArray, resultArray,"The arrays should be equal");}

②验证结果真假

assertTrue(): 期待结果为true
assertFalse(): 期待结果为false

示例：验证 number 是否大于 0。如果条件不满足，测试用例将会失败，并输出指定的失败信息。

importstaticorg.junit.jupiter.api.Assertions.assertTrue;@TestvoidtestIsPositive(){int number =10;assertTrue(number >0,"The number should be positive");}

③验证结果是否为null

assertNull(object)：期待结果为空。
assertNotNull(object): 期待结果为非空

示例：验证 obj 是否为空。如果对象不为空，测试用例将会失败，并输出指定的失败信息。

importstaticorg.junit.jupiter.api.Assertions.assertNull;@TestvoidtestObjectNull(){Object obj =null;assertNull(obj,"对象应为空");}

④验证对象引用

assertSame(object1, object2)：验证两个对象引用是否指向同一个对象。
assertNotSame(object1, object2)：验证两个对象引用是否不指向同一个对象。

示例：验证 obj1 和 obj2 是否引用同一个对象。如果两个对象引用不同的对象，测试用例将会失败，并输出指定的失败信息。

importstaticorg.junit.jupiter.api.Assertions.assertSame;@TestvoidtestObjectReference(){Object obj1 =newObject();Object obj2 = obj1;assertSame(obj1, obj2,"两个对象应该引用同一个对象");}

⑤验证是否满足指定条件

assertThat(actual, matcher)：使用Matcher对象验证实际值是否满足指定条件。
assertThat 方法接受两个参数：实际值和Matcher对象。Matcher对象定义了对实际值的特定条件，例如包含特定子串、大于某个值等。通过使用Matcher对象，可以实现更加灵活和具体的断言验证。
示例1：

importstaticorg.hamcrest.MatcherAssert.assertThat;importstaticorg.hamcrest.Matchers.*;// 示例：验证字符串是否包含指定子串String actual ="Hello World";Matcher<String> containsString =containsString("Hello");assertThat(actual, containsString);

示例2：

// 示例：验证数字是否大于指定值int actualNumber =10;Matcher<Integer> greaterThan =greaterThan(5);assertThat(actualNumber, greaterThan);

4.2）使结果直接失败

⑥使测试用例失败：fail()

直接使测试用例失败，可用于标记测试用例未通过的情况。

importstaticorg.junit.jupiter.api.Assertions.fail;@TestvoidtestSomething(){// 执行一些测试逻辑// 如果满足特定条件，则强制测试失败if(conditionIsMet){fail("Test 测试 失败 because xxxx");}}