Mockito的方法

本文概述

• Mockito嘲笑()方法
• Mockito when()方法
• Mockito verify()方法
• Mockito spy()方法
• Mockito reset()方法
• Mockito verifyNoMoreInteractions()方法
• Mockito verifyZeroInteractions()方法
• Mockito doThrow()方法
• Mockito doCallRealMethod()方法
• Mockito doAnswer()方法
• Mockito doNothing()方法
• Mockito doReturn()方法
• Mockito inOrder()方法
• Mockito ignoreStubs()方法
• Mockito times()方法
• Mockito never()方法
• Mockito atLeastOnce()方法
• Mockito atLeast()方法
• Mockito atMost()方法
• Mockito Calls()方法
• Mockito only()方法
• Mockito timeout()方法
• Mockito after()方法
• Mockito validateMockitoUsage()方法
• Mockito withSettings()方法

Mockito框架提供了用于测试Java应用程序的各种方法, 例如mock(), verify(), when()等。使用这些预定义的方法使测试非常容易。

Mockito方法的简要说明如下：

Mockito嘲笑()方法

它用于创建给定类或接口的模拟对象。 Mockito包含五个带有不同参数的模拟方法。当我们不给模拟分配任何东西时, 它们将返回默认值。所有这五个方法都具有模拟对象的相同功能。

以下是具有不同参数的嘲笑()方法：

• Class的mock()方法：用于创建具体类或接口的模拟对象。它以类或接口名称作为参数。
  语法：<T>模拟(Class <T> classToMock)
• 带答案的mock()方法：用于创建具有特定过程的类或接口的模拟对象。它是一种高级的模拟方法, 可在使用旧系统时使用。它使用Answer作为参数以及类或接口名称。答案是对预先配置的模拟答案的枚举。
  语法：<T>模拟(Class <T> classToMock, 回答defaultAnswer)
• 带有MockSettings的mock()方法：用于创建具有某些非标准设置的模拟对象。它将MockSettings以及类或接口名称作为附加设置参数。 MockSettings允许使用其他设置来创建模拟对象。
  语法：<T>模拟(Class <T> classToMock, MockSettings模拟设置)
• 具有ReturnValues的mock()方法：它允许创建给定类或接口的模拟对象。现在, 已弃用该方法, 因为ReturnValues已替换为Answer。
  语法：<T>模拟(Class <T> classToMock, ReturnValues returnValues)
• 带字符串的mock()方法：用于通过指定模拟名称来创建模拟对象。在调试中, 命名模拟对象可能会有所帮助, 而使用大型和复杂的代码则是一个不好的选择。
  语法：<T>模拟(Class <T> classToMock, 字符串名称)

以下代码段显示了如何使用嘲笑()方法：

ToDoService doService = mock(ToDoService.class);

Mockito when()方法

它启用存根方法。当我们想模拟调用特定方法时返回特定值时, 应使用它。简单来说, “当调用XYZ()方法时, 然后返回ABC。”通常在有某些条件要执行时使用。

语法：<T> when(T methodCall)

以下代码段显示了如何使用when()方法：

when(mock.someCode ()).thenReturn(5);

在上面的代码中, thenReturn()通常与when()方法一起使用。

Mockito verify()方法

verify()方法用于检查是否调用了某些指定的方法。简单来说, 它可以验证一次测试中发生的某些行为。在测试代​​码的底部使用它来确保调用定义的方法。

Mockito框架通过模拟对象的参数跟踪所有方法调用。模拟之后, 我们可以使用verify()方法验证是否满足定义的条件。这种测试有时称为行为测试。它检查是否使用正确的参数调用了方法, 而不是检查方法调用的结果。

verify()方法还用于测试调用次数。因此, 我们可以使用times方法, 至少一次方法以及最多一个模拟方法的方法来测试确切的调用次数。

Mockito类中提供了两种类型的verify()方法, 如下所示：

• verify()方法：验证一次发生的某些行为。
  语法：<T> verify(T模拟)
• 带有VerificationMode的verify()方法：它验证某些行为至少发生一次, 确切次数发生或从未发生。
  语法：<T> verify(T模拟, VerificationMode模式)

Mockito spy()方法

Mockito提供了一种部分模拟对象的方法, 称为间谍方法。使用间谍方法时, 存在一个真实对象, 并为该真实对象创建了间谍或存根。如果我们不使用间谍对方法进行存根, 它将调用实际的方法行为。 spy()方法的主要功能是它覆盖了真实对象的特定方法。 spy()方法的功能之一是它验证某个方法的调用。

Mockito类中提供两种类型的spy()方法：

• spy()方法：它创建真实对象的间谍。间谍方法将调用真实方法, 除非将其存根。例如, 在处理遗留代码时, 我们应该谨慎并偶尔使用真正的间谍。
  语法：<T> spy(T对象)
• 带类的spy()方法：它基于类而不是对象创建一个间谍对象。 spy(T object)方法对于监视抽象类特别有用, 因为它们无法实例化。
  语法：<T> spy(Class <T> classToSpy)

以下代码段显示了如何使用spy()方法：

List spyArrayList = spy(ArrayList.class);

Mockito reset()方法

Mockito reset()方法用于重置模拟。它主要用于处理容器注入的模拟。通常, reset()方法会导致冗长的代码和不良的测试。最好创建新的模拟而不是使用reset()方法。这就是为什么reset()方法很少在测试中使用的原因。

reset()方法的签名为：

public static <T> void reset(T ... mocks) {
        MOCKITO_CORE.reset(mocks);
    }

Mockito verifyNoMoreInteractions()方法

它用于检查任何给定的模拟是否具有未验证的交互。我们可以在验证所有模拟之后使用此方法, 以确保在模拟上没有其他任何调用。它还会检测在测试方法之前发生的未经验证的调用, 例如在setup(), @ Before方法或构造函数中。这是一种可选方法, 我们不需要在每次测试中都使用它。

verifyNoMoreInteractions()方法的签名为：

public static void verifyNoMoreInteractions(Object... mocks) {
        MOCKITO_CORE.verifyNoMoreInteractions(mocks);
    }

Mockito verifyZeroInteractions()方法

它验证在给定的模拟上没有发生任何交互。它还检测在测试方法之前发生的调用, 例如在setup(), @ Before方法或构造函数中。

verifyZeroInteractions()方法的签名为：

public static void verifyZeroInteractions(Object... mocks) {
        MOCKITO_CORE.verifyNoMoreInteractions(mocks);
    }

Mockito doThrow()方法

用于存根void方法以引发异常时使用。它为每个方法调用创建一个新的异常实例。 Mockito类中有两种类型的doThrow()方法, 它们具有不同的参数, 如下所示：

• 具有Throwable的doThrow()方法：当我们想对一个带异常的void方法进行存根时, 使用此方法。语法：doThrow(ThrowabletoBeThrown)
  doThrow()方法的签名是：

public static Stubber doThrow(Throwable toBeThrown) {
       return MOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown));
    }

• 带类的doThrow()方法：当我们想要对void方法进行存根以引发指定类的异常时, 使用此方法。
  语法：doThrow(Class <？extended Throwable> toBeThrown)
  doThrow()方法的签名是：

public static Stubber doThrow(Class<? extends Throwable> toBeThrown) {
        return MOCKITO_CORE.doAnswer(new ThrowsExceptionClass(toBeThrown));
    }

Mockito doCallRealMethod()方法

当我们要调用方法的实际实现时使用它。换句话说, 它用于创建对象的部分模拟。它在极少数情况下使用, 例如调用真实方法。它类似于spy()方法, 唯一的区别是它会导致复杂的代码。

doCallRealMethod()方法的签名为：

public static Stubber doCallRealMethod() {
        return MOCKITO_CORE.doAnswer(new CallsRealMethods());
    }

Mockito doAnswer()方法

当我们想对具有通用Answer类型的void方法进行存根时, 可以使用它。 doAnswer()方法的签名为：

public static Stubber doAnswer(Answer answer) {
        return MOCKITO_CORE.doAnswer(answer);
    }

Mockito doNothing()方法

它用于将void方法设置为不执行任何操作。在极少数情况下使用doNothing()方法。默认情况下, 模拟实例上的void方法不执行任何操作, 即不执行任何任务。

doNothing()方法的签名是：

public static Stubber doNothing() {
        return MOCKITO_CORE.doAnswer(new DoesNothing());
    }

Mockito doReturn()方法

它在无法使用Mockito.when(object)的极少数情况下使用。始终建议使用Mockito.when(object)方法进行存根, 因为与doReturn()方法相比, 它是参数类型安全的, 并且更具可读性。

doReturn()方法的签名为：

public static Stubber doReturn(Object toBeReturned) {
        return MOCKITO_CORE.doAnswer(new Returns(toBeReturned));
 }

Mockito inOrder()方法

它用于创建允许以特定顺序验证模拟的对象。按顺序进行的验证更加灵活, 因为我们不必验证所有交互。我们只需要验证那些对测试感兴趣的交互(按顺序)。我们还可以使用inOrder()方法来创建一个inOrder对象, 该对象传递与顺序验证相关的模拟。

Mockito.inOrder()方法的签名为：

public static InOrder inOrder(Object... mocks) {
        return MOCKITO_CORE.inOrder(mocks);
 }

Mockito ignoreStubs()方法

它用于忽略给定模拟的存根方法进行验证。与verifyNoMoreInteractions()或inorder()方法一起使用时非常有用。它还有助于避免存根呼叫的冗余验证。

ignoreStubs()方法的签名为：

public static Object[] ignoreStubs(Object... mocks) {
        return MOCKITO_CORE.ignoreStubs(mocks);
 }

Mockito times()方法

它用于验证方法调用的准确次数, 这意味着它声明了方法被调用的次数。 times()方法的签名为：

public static VerificationMode times(int wantedNumberOfInvocations) {
        return VerificationModeFactory.times(wantedNumberOfInvocations);
 }

Mockito never()方法

它用于验证没有发生交互。 never()方法的签名为：

public static VerificationMode never() {
        return times(0);
 }

Mockito atLeastOnce()方法

它用于至少一次验证调用, 这意味着该方法应至少调用一次。

atLeastOnce()方法的签名为：

public static VerificationMode atLeastOnce() {
        return VerificationModeFactory.atLeastOnce();
 }

Mockito atLeast()方法

它用于验证调用至少x次。例如, 给定atLeast(3)表示该方法将至少调用3次。

atLeast()方法的签名为：

public static VerificationMode atLeast(int minNumberOfInvocations) {
        return VerificationModeFactory.atLeast(minNumberOfInvocations);
 }

Mockito atMost()方法

它用于最多验证x次调用。例如, 给定atMost(3)表示该方法最多将调用3次。

atMost()方法的签名为：

public static VerificationMode atMost(int maxNumberOfInvocations) {
        return VerificationModeFactory.atMost(maxNumberOfInvocations);
 }

Mockito Calls()方法

它允许顺序进行非贪婪验证。它只能与inOrder()验证方法一起使用。例如, inOrder.verify(mock, calls(3))。xyzMethod(” …”);

call()方法的签名为：

public static VerificationMode calls( int wantedNumberOfInvocations ){
        return VerificationModeFactory.calls( wantedNumberOfInvocations );
 }

Mockito only()方法

它检查给定的方法是否是唯一调用的方法。 only()方法的签名是：

public static VerificationMode only() {
    	return VerificationModeFactory.only();
 }

Mockito timeout()方法

它允许Mockito执行超时验证。它指示验证为特定交互等待特定时间段, 而不是立即失败。对于在现有情况下进行测试可能很有用。

timeout()方法不同于after()方法, 因为after()方法将等待整个周期, 除非声明了最终结果, 而timeout()方法将在验证通过后立即停止。它很少在测试中使用。

timeout()方法的签名为：

public static VerificationWithTimeout timeout(long millis) {
        return new Timeout(millis, VerificationModeFactory.times(1));
 }

Mockito after()方法

它允许Mockito在给定的时间内进行验证。我们已经讨论过after()方法与timeout()方法不同。

after()方法的签名是：

public static VerificationAfterDelay after(long millis) {
        return new After(millis, VerificationModeFactory.times(1));
 }

Mockito validateMockitoUsage()方法

它用于显式验证框架状态以检测Mockito框架的无效使用。这是Mockito的一项可选功能, 因为它可以一直验证使用情况。内置运行器(MockitoJUnitRunner)和规则(MockitoRule)都在每个测试方法之后调用validateMockitoUsage()方法。

validateMockitoUsage()方法的签名为：

public static void validateMockitoUsage() {
        MOCKITO_CORE.validateMockitoUsage();
 }

Mockito withSettings()方法

它用于创建具有其他模拟设置的模拟。在测试中应偶尔使用它。可以使用简单的模拟来创建简单的测试, 而不是使用withSettings()方法。使用MockSettings的主要原因是

• 通过使用MockSetting, 我们可以在需要时轻松添加其他模拟设置。
• 它结合了不同的模拟设置而不会弄乱代码。

withSettings()方法的签名为：

public static MockSettings withSettings() {
        return new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS);
 }