Mockito Spy与依赖注入：解决测试中方法未调用模拟值的问题

本文探讨了在使用Mockito的spy功能对类方法进行部分模拟时，模拟值未生效的常见问题。核心原因在于生产代码直接实例化了被测试对象，导致测试中创建的spy实例未能被使用。文章详细阐述了通过依赖注入（Dependency Injection）这一设计模式来解决此问题的方法，并提供了具体的代码示例和注意事项，旨在帮助开发者更有效地进行单元测试。

问题分析：Mockito Spy与直接实例化冲突

在使用Mockito进行单元测试时，spy功能允许我们对真实对象进行部分模拟，即可以调用真实方法，也可以对特定方法进行桩（stubbing）。然而，一个常见的陷阱是，当生产代码（即被测试的方法）内部直接创建了它所依赖的对象实例时，测试中对该依赖对象创建的spy或mock实例将无法生效。

考虑以下场景：

原始生产代码片段：

public class MyService {
    public double calculatePrice() {
        GetOptionBidPrice getOptionBidPrice = new GetOptionBidPrice(...); // 问题所在：直接实例化
        double bidPrice = getOptionBidPrice.getBidPrice();
        // ... 其他业务逻辑使用 bidPrice
        return bidPrice * 1.1; // 示例计算
    }
}

public class GetOptionBidPrice {
    // ... 构造函数及其他字段
    public double getBidPrice() {
        // 真实业务逻辑，可能涉及网络请求或复杂计算
        return 0.0; // 假设默认返回0
    }
}

对应的测试代码尝试：

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MyServiceTest {

    @Test
    void testCalculatePriceWithSpy() {
        // 尝试对 GetOptionBidPrice 进行 spy
        GetOptionBidPrice spyGetOptionBidPrice = spy(GetOptionBidPrice.class);
        doReturn(100.0).when(spyGetOptionBidPrice).getBidPrice(); // 桩化 getBidPrice 方法

        // 创建 MyService 实例并调用
        MyService myService = new MyService();
        double result = myService.calculatePrice(); // 在这里，内部仍然创建了新的 GetOptionBidPrice 实例

        // 预期结果是基于桩化的 100.0，但实际可能基于 GetOptionBidPrice 的真实返回值 0.0
        // assertEquals(110.0, result); // 期望值
    }
}

在这个例子中，尽管我们在测试中创建了spyGetOptionBidPrice并对其getBidPrice()方法进行了桩化，但MyService类的calculatePrice()方法内部通过new GetOptionBidPrice(...)创建了一个全新的GetOptionBidPrice实例。这个新实例与测试中创建的spy实例是完全独立的，因此calculatePrice()方法调用的是真实实例的getBidPrice()方法，而非spy实例上被桩化的方法，导致模拟值100.0并未生效，而是得到了真实方法返回的0.0。

解决方案：引入依赖注入

解决上述问题的核心思想是，不要让被测试类（MyService）在内部直接创建其依赖（GetOptionBidPrice）的实例。相反，应该通过某种方式将依赖对象“注入”到被测试类中。这种设计模式被称为依赖注入 (Dependency Injection, DI)。

通过依赖注入，我们可以在生产代码中注入真实的依赖对象，而在测试代码中注入spy或mock对象，从而实现对依赖行为的控制。

重构后的生产代码：

public class MyService {
    private final GetOptionBidPrice getOptionBidPrice; // 将依赖声明为成员变量

    // 通过构造函数注入依赖
    public MyService(GetOptionBidPrice getOptionBidPrice) {
        this.getOptionBidPrice = getOptionBidPrice;
    }

    public double calculatePrice() {
        double bidPrice = getOptionBidPrice.getBidPrice(); // 调用注入的依赖实例
        // ... 其他业务逻辑使用 bidPrice
        return bidPrice * 1.1;
    }
}

// GetOptionBidPrice 类保持不变
public class GetOptionBidPrice {
    // ... 构造函数及其他字段
    public double getBidPrice() {
        return 0.0;
    }
}

重构后的测试代码：

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MyServiceTest {

    @Test
    void testCalculatePriceWithInjectedSpy() {
        // 创建并桩化 spy 实例
        GetOptionBidPrice spyGetOptionBidPrice = spy(GetOptionBidPrice.class);
        doReturn(100.0).when(spyGetOptionBidPrice).getBidPrice();

        // 将 spy 实例注入到 MyService 中
        MyService myService = new MyService(spyGetOptionBidPrice);
        double result = myService.calculatePrice();

        // 现在，calculatePrice 会调用注入的 spy 实例的 getBidPrice() 方法
        assertEquals(110.0, result, "计算结果应基于桩化的 bidPrice");
        // 验证 getBidPrice 方法是否被调用
        Mockito.verify(spyGetOptionBidPrice).getBidPrice();
    }

    // 生产代码中如何使用 MyService
    public static void main(String[] args) {
        // 在生产环境中，注入真实的 GetOptionBidPrice 实例
        GetOptionBidPrice realGetOptionBidPrice = new GetOptionBidPrice(/* 真实参数 */);
        MyService realMyService = new MyService(realGetOptionBidPrice);
        double productionResult = realMyService.calculatePrice();
        System.out.println("生产环境计算结果: " + productionResult);
    }
}

通过构造函数注入（这是最常见的依赖注入方式之一），MyService不再负责创建GetOptionBidPrice的实例，而是由外部提供。在测试中，我们提供了spy实例；在生产环境中，我们则提供真实的实例。这样，测试就能够完全控制MyService所依赖的GetOptionBidPrice的行为。

注意事项与总结

1. 依赖注入的重要性： 依赖注入不仅解决了测试中的模拟问题，更是现代软件设计中的一个核心原则。它提高了代码的模块化、可测试性、可维护性和扩展性。当一个类需要依赖其他类时，优先考虑通过构造函数、Setter方法或接口注入这些依赖，而不是在类内部直接创建。
2. spy与mock的选择：
   • mock： 通常用于完全模拟一个接口或类，其所有方法默认不执行真实逻辑，需要明确桩化。适用于测试单元与外部完全隔离的场景。
   • spy： 用于对真实对象进行部分模拟，未桩化的方法会执行真实逻辑。适用于需要测试真实对象大部分功能，仅对少数难以测试或耗时的方法进行控制的场景。
   • 本案例中使用spy是合适的，因为我们希望GetOptionBidPrice的大部分行为保持不变，只对getBidPrice()方法进行桩化。
3. 测试的粒度： 单元测试应该关注单个单元（通常是一个类或一个方法）的行为，并将其依赖项隔离。通过模拟或间谍化依赖项，我们可以确保测试的焦点仅限于被测试单元本身，避免外部因素干扰测试结果。
4. 避免在被测试方法内部创建依赖： 这是一个通用的反模式，它使得单元测试变得困难。如果一个方法内部创建了复杂的依赖对象，那么这个方法就很难被单独测试，因为它与它创建的依赖项紧密耦合。
5. 验证行为： 在使用spy或mock后，除了验证返回值，还应使用Mockito.verify()来验证被模拟对象上的方法是否被正确调用，以及调用的次数和参数是否符合预期。

通过采纳依赖注入模式，并理解Mockito spy的工作原理，开发者可以构建出更健壮、更易于测试的应用程序。

以上是Mockito Spy与依赖注入：解决测试中方法未调用模拟值的问题的详细内容。更多信息请关注PHP中文网其他相关文章！