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

第一章、模拟对象

1.1）①mock()方法：

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

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

import java.util.List;
import static org.mockito.Mockito.*;

public class MockitoMockMethodExample {

    public void testMultipleMocks() {
        // 使用 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() 方法进行了模拟。最后，调用部分模拟对象的真实方法时，模拟的方法返回了预期的值。

import static org.mockito.Mockito.*;

// 示例：创建一个部分模拟的对象
List<String> list = new ArrayList<>();
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(要返回的值)

示例：

public class MockitoExample {
    @Test
    void testWhenThenReturn() {
        // 创建模拟对象
        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();

示例：

import static org.mockito.Mockito.*;

// 示例：创建一个部分模拟的对象
List<String> list = new ArrayList<>();
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中的代码逻辑。

import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import java.time.Instant;

public class TimeServiceTest {
    @Test
    public void testGetCurrentTime() {
        // 创建TimeService类的模拟对象
        TimeService timeService = Mockito.mock(TimeService.class);

        // 创建一个 Answer 对象，实现 answer 方法来返回当前系统时间
        Answer<Long> answer = new Answer<Long>() {
            public Long answer(InvocationOnMock invocation) throws Throwable {
                return Instant.now().toEpochMilli();
            }
        };

        // 使用 thenAnswer() 指定模拟对象的方法返回当前系统时间
Mockito.when(timeService.getCurrentTime()).thenAnswer(answer);

        // 调用模拟对象的方法，实际执行的是answer中的代码逻辑
        long currentTime = timeService.getCurrentTime();

        // 验证方法是否被调用
        Mockito.verify(timeService).getCurrentTime();
        // 进行进一步的断言
    }
}

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

public class TimeServiceTest {
    @Test
    public void testGetCurrentTime() {
        // 创建TimeService类的模拟对象
        TimeService timeService = Mockito.mock(TimeService.class);

        // 创建一个 Answer 对象，实现 answer 方法来返回当前系统时间
        Answer<Long> answer = new Answer<Long>() {
            public Long answer(InvocationOnMock invocation) throws Throwable {
                return Instant.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的类，其中包含一个方法
public class Service {
    public int calculate(int a, int b) {
        // 一些复杂的计算
        return a + b;
    }
}

// 在测试中，使用Mockito来模拟Service类的行为
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

public class ServiceTest {
    @Test
    public void testCalculate() {
        // 创建Service类的模拟对象
        Service service = Mockito.mock(Service.class);
        
        // 创建一个 Answer 对象，实现 answer 方法来指定特定的操作或返回值
        Answer<Integer> answer = new Answer<Integer>() {
            public Integer answer(InvocationOnMock invocation) throws Throwable {
                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，结果为6
        int result = service.calculate(2, 3);
        
        // 验证方法是否被调用，并且返回了预期的值
        Mockito.verify(service).calculate(2, 3);
        assertEquals(6, result);
    }
}

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

⑥thenCallRealMethod()

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

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

示例：

// 假设有一个名为UserService的类
public class UserService {
    public String process(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(new RuntimeException())

示例：这里是RuntimeException

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

示例：

import static org.mockito.Mockito.*;

public class ExampleTest {
    @Test
    public void testMethod() {
        // 创建被mock的对象
        SomeClass mockObj = mock(SomeClass.class);
        
        // 设置当调用mockObj.method时抛出异常
        when(mockObj.method(anyString())).thenThrow(new RuntimeException("Something went wrong"));
        
        // 调用被mock的方法这里会抛出异常
        mockObj.method("test");
    }
}

⑨doThrow()

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

doThrow(new RuntimeException()).when(mockedList).get(0)

示例：

import static org.mockito.Mockito.*;

// 创建mock对象
List<String> mockedList = mock(List.class);

// 指定当调用mockedList的get()方法时抛出异常
doThrow(new RuntimeException()).when(mockedList).get(0);

// 调用被测方法
mockedList.get(0); // 这里会抛出指定的异常

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

⑩模拟构造函数MockedConstruction

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

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

import org.junit.jupiter.api.Test;
import org.mockito.MockedConstruction;
import org.mockito.Mockito;

public class ExampleTest {

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

⑩①模拟静态方法：MockedStatic

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

import org.mockito.MockedStatic;
import org.mockito.Mockito;

public class Example {
    public void exampleMethod() {
    //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：

    static class ExampleClass {
        public void hello() {
            System.out.println("吃过了");
        }
    }
/
public class MockDemo {
    @Test
    public void test() {
        ExampleClass exampleClass = spy(new ExampleClass ());
        ExampleClass .hello();  //打印吃过了
        // 通过doNothein让方法什么都不做
        doNothing().when(exampleClass ).hello();
        exampleClass.hello(); // 什么都不输出
    }
}

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

List list = new LinkedList(); 
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()方法：

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

import org.junit.Test;
import org.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()方法：

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

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

import java.util.List;

public class MockitoExample {
    @Test
    void testMock() {
        // 创建模拟对象
        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 异常。

public class MockitoExample {
    @Test
    void testTimes() {
        // 创建模拟对象
        List mockedList = Mockito.mock(List.class);

        // 模拟方法调用
        mockedList.add("one");
        mockedList.add("one");

        // 验证该方法是否被调用了两次
        Mockito.verify(mockedList, Mockito.times(2)).add("one");
    }
}

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

import java.util.List;
import static org.mockito.Mockito.*;

public class MockitoTimesExample {

    public void testMethodInvocation() {
        // 创建模拟对象
        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的对象，测试代码中发生了未被预期的方法调用。这可能是因为测试代码中的某些逻辑导致了额外的方法调用。

import org.junit.Test;
import org.mockito.Mockito;

public class ProcessorTest {
  @Test
  public void processTest() {
      // 创建 MyService 的 mock 对象
      MyService myMockService = Mockito.mock(MyService.class);
      
      // 创建 MyProcessor 对象，并传入 mock 对象
      MyProcessor myProcessor = new MyProcessor(myMockService);
      
      // 调用 MyProcessor 的 process() 和 process2() 方法
      myProcessor.process();
      myProcessor.process2();

      // 验证 mock 对象的交互
      Mockito.verify(myMockService).doSomething();
      Mockito.verify(myMockService).doSomething2();

      // 确保没有更多的交互发生
      Mockito.verifyNoMoreInteractions(myMockService);
  }
}

④verifyZeroInteractions()方法：

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

import static org.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。如果不相等，测试用例将会失败，并输出指定的失败信息。

import static org.junit.jupiter.api.Assertions.assertEquals;

@Test
void testAddition() {
    int result = Calculator.add(3, 5);
    assertEquals(8, result, "The addition result should be 8");
}

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

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

import static org.junit.jupiter.api.Assertions.assertArrayEquals;

@Test
void testArrayEquality() {
    int[] expectedArray = {1, 2, 3};
    int[] resultArray = {1, 2, 3};
    assertArrayEquals(expectedArray, resultArray, "The arrays should be equal");
}

②验证结果真假

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

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

import static org.junit.jupiter.api.Assertions.assertTrue;

@Test
void testIsPositive() {
    int number = 10;
    assertTrue(number > 0, "The number should be positive");
}

③验证结果是否为null

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

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

import static org.junit.jupiter.api.Assertions.assertNull;

@Test
void testObjectNull() {
    Object obj = null;
    assertNull(obj, "对象应为空");
}

④验证对象引用

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

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

import static org.junit.jupiter.api.Assertions.assertSame;

@Test
void testObjectReference() {
    Object obj1 = new Object();
    Object obj2 = obj1;
    assertSame(obj1, obj2, "两个对象应该引用同一个对象");
}

⑤验证是否满足指定条件

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

import static org.hamcrest.MatcherAssert.assertThat;
import static org.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()

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

import static org.junit.jupiter.api.Assertions.fail;

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