同一类内方法间调用时，验证目标方法参数正确性的测试方案

嘿，针对你给出的ClassSample代码场景——要验证MethodA处理完objectA后，传给MethodB的参数是否符合预期，我整理了几个实用的单元测试方案，都是日常开发里常用的：

方案1：用Mockito Spy监视方法调用参数 #

Mockito的Spy可以帮你“盯紧”真实对象的方法调用，这样就能轻松捕获MethodB被调用时的参数，再和你预期的结果对比。

假设你用JUnit + Mockito做测试，代码大概是这样：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import static org.mockito.Mockito.verify;
import static org.junit.Assert.*;

@RunWith(MockitoJUnitRunner.class)
public class ClassSampleTest {

    @Spy
    @InjectMocks
    private ClassSample classSample;

    @Test
    public void testMethodAPassesCorrectObjectToMethodB() {
        // 先执行MethodA
        classSample.MethodA();

        // 先根据业务逻辑，创建一个你预期的objectA实例
        ObjectA expectedObject = new ObjectA();
        expectedObject.setSomeProperty("expectedValue"); // 比如设置处理后的预期属性值

        // 验证MethodB确实被调用，而且传入的参数和预期一致
        verify(classSample).MethodB(expectedObject);
    }
}

这里要注意：如果ObjectA没重写equals()方法，Mockito默认会用对象引用对比，这时候要么给ObjectA补上equals()和hashCode()，要么用ArgumentCaptor来捕获参数后逐个属性验证，比如这样：

import org.mockito.ArgumentCaptor;

// 其他导入同上

@Test
public void testMethodAPassesCorrectObjectToMethodB() {
    classSample.MethodA();

    // 创建参数捕获器
    ArgumentCaptor<ObjectA> objectACaptor = ArgumentCaptor.forClass(ObjectA.class);
    // 捕获MethodB的调用参数
    verify(classSample).MethodB(objectACaptor.capture());

    // 取出实际传入的参数，逐个验证属性
    ObjectA actualObject = objectACaptor.getValue();
    assertEquals("expectedValue", actualObject.getSomeProperty());
    // 其他需要验证的属性也可以在这里加
}

方案2：小幅度重构代码，让测试更顺手 #

如果不想用Mock框架，也可以通过简单重构来提升代码的可测试性：

• 把MethodB的访问权限改成protected（如果测试类和被测类在同一个包下，甚至不用改），这样测试类可以直接调用它，或者创建子类重写MethodB来捕获参数；
• 更推荐的方式是把MethodB的逻辑抽成一个单独的依赖类，比如ObjectAService，然后通过构造注入的方式传入，这样测试时就能Mock这个服务类，轻松验证调用参数。

重构后的代码示例：

public class ClassSample {
    private final ObjectAService objectAService;

    // 通过构造注入依赖
    public ClassSample(ObjectAService objectAService) {
        this.objectAService = objectAService;
    }

    public void MethodA() {
        var objectA = new ObjectA();
        // 处理objectA的逻辑
        objectAService.processObjectA(objectA); // 原来的MethodB逻辑移到这里
    }
}

// 定义一个接口，方便Mock
public interface ObjectAService {
    void processObjectA(ObjectA objectA);
}

这样测试起来就简单多了，直接MockObjectAService，验证processObjectA的调用参数就行，还顺便符合了单一职责原则，一举两得~

方案3：间接验证——通过MethodA的返回值判断 #

看你的代码里MethodA是返回MethodB的结果？如果MethodB有返回值，那你也可以通过调用MethodA后对比返回值，间接验证参数是否正确——毕竟返回值是基于传入的objectA生成的，只要返回值符合预期，基本就能说明参数传递没问题。

比如MethodB返回处理后的结果：

@Test
public void testMethodAReturnsCorrectValue() {
    String result = classSample.MethodA();
    assertEquals("expectedResult", result);
}

这种方式属于黑盒测试，适合不需要关心内部调用细节，只关注最终结果的场景。

内容的提问来源于stack exchange，提问作者Kritsanai Lerlertvanich