如何编写JUnit测试用例验证无返回Mock对象的方法（禁改代码、不用PowerMock）

由于无法修改业务代码、不能使用PowerMock，且私有方法不改变入参状态，我们可以从观测方法内部行为痕迹和验证关键对象状态两个方向入手，以下是具体实现方案：

一、验证Matcher的属性设置逻辑 #

方法内部创建了Matcher实例并设置了ID=1和Travel="Air"，我们可以通过以下两种方式验证：

1. 基于字节码增强捕获Matcher实例 #

使用ByteBuddy这类字节码工具，拦截buildCriteria方法的返回值，记录生成的Matcher对象，后续断言其属性：

@Test
public void testMatcherProperties() throws Exception {
    // 1. 准备测试入参
    Booker booker = new Booker();
    Product product = new Product();

    // 2. 用ByteBuddy拦截buildCriteria方法，记录返回的Matcher
    AtomicReference<Matcher> matcherRef = new AtomicReference<>();
    Class<?> enhancedClass = new ByteBuddy()
        .subclass(YourTargetClass.class)
        .method(named("buildCriteria"))
        .intercept(MethodDelegation.to(new Object() {
            @RuntimeType
            public Matcher intercept(@Origin Method method, @AllArguments Object[] args) throws Exception {
                // 调用原方法获取Matcher
                Matcher matcher = (Matcher) method.invoke(super, args);
                // 记录实例
                matcherRef.set(matcher);
                return matcher;
            }
        }))
        .make()
        .load(getClass().getClassLoader())
        .getLoaded();

    // 3. 创建增强后的实例并调用Calculator方法
    YourTargetClass target = enhancedClass.getDeclaredConstructor().newInstance();
    target.Calculator(booker, product);

    // 4. 断言Matcher的属性
    Matcher capturedMatcher = matcherRef.get();
    assertEquals(1, capturedMatcher.getID());
    assertEquals("Air", capturedMatcher.getTravel());
}

2. 复现buildCriteria逻辑推导Matcher状态 #

如果buildCriteria的逻辑相对简单且可复现（比如仅根据product的固定属性生成Matcher），可以手动模拟该方法的逻辑，生成预期的Matcher实例，再对比设置后的状态：

@Test
public void testMatcherPropertiesByLogic() {
    Booker booker = new Booker();
    Product product = new Product();

    // 1. 手动模拟buildCriteria的逻辑，生成初始Matcher
    Matcher expectedMatcher = new Matcher();
    // 这里复现buildCriteria中对Matcher的初始化逻辑，比如：
    // expectedMatcher.setXXX(product.getXXX());

    // 2. 模拟方法内的设置操作
    expectedMatcher.setID(1);
    expectedMatcher.setTravel("Air");

    // 3. 若能通过其他途径获取实际Matcher实例，直接对比属性
    // 注：此方案适用于buildCriteria逻辑透明、可完全复现的场景
}

二、验证populate方法的调用情况 #

针对populate私有方法的调用验证，可根据实际场景选择以下方案：

1. 日志验证（若populate有日志输出） #

如果populate方法内部有打印业务日志（如LOG.info("Populating booker and product")），可以使用日志测试工具捕获日志，验证调用时机：

@Test
public void testPopulateInvocation() {
    // 1. 初始化日志Appender
    ListAppender<ILoggingEvent> appender = new ListAppender<>();
    appender.start();
    LoggerFactory.getLogger(YourTargetClass.class).addAppender(appender);

    Booker booker = new Booker();
    Product product = new Product();

    // 2. 当product不为null时，调用Calculator
    YourTargetClass target = new YourTargetClass();
    target.Calculator(booker, product);

    // 3. 断言日志包含populate相关内容
    boolean hasPopulateLog = appender.list.stream()
        .anyMatch(event -> event.getMessage().contains("Populating"));
    assertTrue(hasPopulateLog);

    // 4. 当product为null时，验证populate未被调用
    appender.list.clear();
    target.Calculator(booker, null);
    assertFalse(appender.list.stream().anyMatch(event -> event.getMessage().contains("Populating")));
}

2. 字节码增强统计方法调用次数 #

使用ByteBuddy为populate方法添加调用计数逻辑，通过计数验证方法是否被调用：

@Test
public void testPopulateInvocationCount() throws Exception {
    // 1. 准备测试入参
    Booker booker = new Booker();
    Product product = new Product();

    // 2. 用ByteBuddy增强populate方法，添加调用计数
    AtomicInteger invokeCount = new AtomicInteger(0);
    Class<?> enhancedClass = new ByteBuddy()
        .subclass(YourTargetClass.class)
        .method(named("populate").withParameters(Booker.class, Product.class))
        .intercept(MethodDelegation.to(new Object() {
            @RuntimeType
            public void intercept(@Origin Method method, @AllArguments Object[] args) throws Exception {
                invokeCount.incrementAndGet();
                // 调用原方法
                method.invoke(super, args);
            }
        }))
        .make()
        .load(getClass().getClassLoader())
        .getLoaded();

    // 3. 测试product不为null的情况
    YourTargetClass target = enhancedClass.getDeclaredConstructor().newInstance();
    target.Calculator(booker, product);
    assertEquals(1, invokeCount.get());

    // 4. 测试product为null的情况
    invokeCount.set(0);
    target.Calculator(booker, null);
    assertEquals(0, invokeCount.get());
}

3. 验证populate内部依赖调用（若有公共依赖） #

如果populate方法内部调用了某个公共依赖的方法（比如booker.updateInfo(product)），可以mock该依赖对象，验证其方法是否被调用：

@Test
public void testPopulateInternalCall() {
    // 1. Mock公共依赖（假设Booker是可mock的类）
    Booker mockBooker = Mockito.mock(Booker.class);
    Product product = new Product();

    // 2. 调用目标方法
    YourTargetClass target = new YourTargetClass();
    target.Calculator(mockBooker, product);

    // 3. 验证依赖方法是否被调用
    Mockito.verify(mockBooker).updateInfo(product);

    // 4. 测试product为null的情况
    Mockito.clearInvocations(mockBooker);
    target.Calculator(mockBooker, null);
    Mockito.verify(mockBooker, Mockito.never()).updateInfo(Mockito.any());
}

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