Java中复杂嵌套函数调用的Mocking策略

int var = func1(func2(obj.func3()));

// 假设 obj 是一个被 Mockito 模拟的对象
// 例如：MyObject obj = mock(MyObject.class);
when(obj.func3()).thenReturn(5); // 让 obj.func3() 返回 5

// 假设 func2 是一个被 Mockito 模拟的方法或静态方法
// 如果 func2 是某个类的方法：MyService service = mock(MyService.class);
// when(service.func2(anyInt())).thenReturn(50); // 让 service.func2() 返回 50

// 如果 func2 是静态方法或独立函数，需要 PowerMock 或其他特殊处理
// 但在一般 Mockito 场景下，我们通常模拟的是实例方法。
// 假设 func2 是一个独立的服务类的方法
MyService myService = mock(MyService.class);
when(myService.func2(anyInt())).thenReturn(50); // 让 myService.func2(任何整数) 返回 50

// 假设 func1 是被测试类中的方法，我们不模拟它
// 假设被测试类为 TargetClass
TargetClass target = new TargetClass(myService, obj); // 注入模拟的依赖

// 执行被测试的方法，其中包含 int var = target.func1(myService.func2(obj.func3()));
int var = target.doSomethingWithNestedCall(); // 假设这个方法包含了上述嵌套调用

// 验证 var 的值
assertEquals(expectedVarValue, var); // 期望 var 的值是 func1(50) 的结果

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

// 模拟的 Obj 类
class MyObject {
    public int func3() {
        System.out.println("MyObject.func3() called (real)");
        return 3; // 实际值，但会被mock覆盖
    }
}

// 模拟的 Service 类，包含 func2
class MyService {
    public int func2(int input) {
        System.out.println("MyService.func2() called (real) with: " + input);
        return input * 10; // 实际逻辑，但会被mock覆盖
    }
}

// 被测试的类，包含 func1 和嵌套调用
class TargetClass {
    private MyService myService;
    private MyObject myObject;

    public TargetClass(MyService myService, MyObject myObject) {
        this.myService = myService;
        this.myObject = myObject;
    }

    // 包含嵌套调用的方法
    public int processNestedCall() {
        // int var = func1(func2(obj.func3()));
        int func3Result = myObject.func3(); // 最内层调用
        int func2Result = myService.func2(func3Result); // 中间层调用
        int var = func1(func2Result); // 最外层调用
        return var;
    }

    // func1 方法，作为被测试类的一部分
    private int func1(int input) {
        System.out.println("TargetClass.func1() called (real) with: " + input);
        return input + 50; // 假设的业务逻辑
    }
}

public class NestedFunctionMockingTest {

    @Test
    void testNestedFunctionCallMocking() {
        // 1. 模拟依赖对象
        MyObject mockMyObject = mock(MyObject.class);
        MyService mockMyService = mock(MyService.class);

        // 2. 设置模拟行为：从最内层开始
        // 模拟 obj.func3() 返回 5
        when(mockMyObject.func3()).thenReturn(5);

        // 模拟 func2(anyInt()) 返回 50
        // 这里使用 anyInt() 是为了让 mockMyService.func2() 无论接收到什么整数都返回 50
        when(mockMyService.func2(anyInt())).thenReturn(50);

        // 3. 实例化被测试类，并注入模拟的依赖
        TargetClass targetClass = new TargetClass(mockMyService, mockMyObject);

        // 4. 执行被测试的方法
        int resultVar = targetClass.processNestedCall();

        // 5. 验证结果
        // 预期：
        // mockMyObject.func3() -> 5
        // mockMyService.func2(5) -> 50 (因为我们设置了 anyInt() 返回 50)
        // targetClass.func1(50) -> 50 + 50 = 100
        assertEquals(100, resultVar);

        // 6. 验证模拟方法是否被调用（可选，但推荐）
        verify(mockMyObject).func3();
        verify(mockMyService).func2(5); // 验证 func2 确实被 5 调用了
    }
}