JUnit测试：如何Mock通过new初始化类的方法调用及多层依赖？

我来帮你拆解这两个测试痛点，结合你的代码场景，给你具体的实现方案：

挑战1：Mock CertClient内部的HTTP调用，避免覆盖率损失 #

直接Mock整个CertClient确实会丢掉它的代码覆盖率，我们可以通过**局部Mock（Spy）**来解决这个问题，只Mock掉HTTP相关的逻辑，保留其他代码的真实执行：

步骤1：小幅度重构CertClient #

把创建HTTPConnection的逻辑抽成一个protected方法（方便测试时重写），不要动原有业务逻辑：

class CertClient {
    private SSLContext sslContext;
    CertClient(SSLContext sslContext) {
        this.sslContext = sslContext;
    }

    public void enrollCertificate(EnrollmentRequest enrollmentRequest) {
        // 原有代码不变
    }

    private byte[] executeRequest(final URL url, final Vice2Request request, final String httpMethod) {
        // 替换原有的Connection创建逻辑，调用新抽的方法
        HTTPConnection connection = getHttpConnection(url);
        // 原有业务逻辑不变
        connection.writeOutputStream();
        return getCertificateAsBytes(connection);
    }

    // 新增：抽离Connection创建逻辑，改为protected
    protected HTTPConnection getHttpConnection(URL url) throws IOException {
        // 原有的Connection创建代码，比如：
        return (HTTPConnection) url.openConnection();
    }

    // 其他原有方法不变
}

步骤2：使用Spy局部Mock CertClient #

测试时创建CertClient的Spy实例，只MockgetHttpConnection方法返回我们预设的Mock连接，其他方法保持真实执行：

// 创建Mock的HTTPConnection和输入流
HTTPConnection mockConn = Mockito.mock(HTTPConnection.class);
InputStream mockInStream = Mockito.mock(InputStream.class);

// 预设Mock连接的行为：返回模拟的证书字节
byte[] mockCertBytes = "mock-valid-cert".getBytes();
when(mockConn.getInputStream()).thenReturn(mockInStream);
doAnswer(invocation -> {
    byte[] buffer = invocation.getArgument(0);
    System.arraycopy(mockCertBytes, 0, buffer, 0, mockCertBytes.length);
    return mockCertBytes.length;
}).when(mockInStream).read(any(byte[].class));

// 创建CertClient的Spy实例，保留真实逻辑，只替换Connection获取
CertClient spyClient = Mockito.spy(new CertClient(mock(SSLContext.class)));
doReturn(mockConn).when(spyClient, "getHttpConnection", any(URL.class));

这样既拦截了真实的HTTP调用，又能执行CertClient里的业务代码，不会损失覆盖率。

挑战2：Mock两层依赖（Service→Client→HttpConnection）+ 解决PowerMockito.whenNew无效问题 #

你之前whenNew无效的核心原因是没给测试类加正确的@PrepareForTest注解，PowerMockito需要提前准备包含new操作的类（也就是MyService，因为它里面实例化了CertClient）。

方案1：用PowerMockito拦截new操作（适合不想大改MyService的场景） #

测试类需要添加必要的PowerMock注解，然后指定拦截CertClient的实例化：

@RunWith(PowerMockRunner.class)
// 必须包含创建CertClient的类（MyService），以及静态方法所在的SystemUtil
@PrepareForTest({MyService.class, SystemUtil.class})
public class MyServiceTest {

    @Mock
    private HTTPConnection mockHttpConnection;
    @Mock
    private InputStream mockInputStream;

    private MyService someCaller;

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
        someCaller = new MyService();

        // 预设HTTP连接的返回结果
        byte[] mockCertBytes = "mock-cert-data".getBytes();
        when(mockHttpConnection.getInputStream()).thenReturn(mockInputStream);
        doAnswer(invocation -> {
            byte[] buffer = invocation.getArgument(0);
            System.arraycopy(mockCertBytes, 0, buffer, 0, mockCertBytes.length);
            return mockCertBytes.length;
        }).when(mockInputStream).read(any(byte[].class));
    }

    @Test
    public void provisionKeyStoreTest() throws Exception {
        // 模拟静态方法
        PowerMockito.mockStatic(SystemUtil.class);
        when(SystemUtil.isStoreProvEnabled()).thenReturn(true);

        // 创建CertClient的Spy实例
        CertClient spyCertClient = Mockito.spy(new CertClient(mock(SSLContext.class)));
        doReturn(mockHttpConnection).when(spyCertClient, "getHttpConnection", any(URL.class));

        // 拦截MyService里new CertClient的操作，返回Spy实例
        PowerMockito.whenNew(CertClient.class).withAnyArguments().thenReturn(spyCertClient);

        // 执行测试
        someCaller.provisionTenant();

        // 验证关键调用
        verify(spyCertClient).enrollCertificate(any(EnrollmentRequest.class));
        verify(mockHttpConnection).writeOutputStream();
    }
}

方案2：重构MyService，避免依赖PowerMock（更优雅的长期方案） #

把generateCertificateClient私有方法改成protected，测试时通过子类重写来注入Spy的CertClient，完全不用PowerMock：

// 修改MyService的方法权限
class MyService {
    public void provisionTenant() {
        Client client = generateCertificateClient(someParams);
        client.enrollCertificate(enrollmentRequest);
    }

    // 把private改成protected，允许测试类重写
    protected CertClient generateCertificateClient(SomeParams params) {
        return new CertClient(createSslContext(), endpoint);
    }

    // 其他原有方法不变
}

测试时创建MyService的子类，重写方法注入Spy：

public class MyServiceTest {
    // 省略Mock初始化代码...

    @Test
    public void provisionKeyStoreTest() throws Exception {
        // 模拟静态方法
        PowerMockito.mockStatic(SystemUtil.class);
        when(SystemUtil.isStoreProvEnabled()).thenReturn(true);

        // 创建CertClient的Spy实例
        CertClient spyCertClient = Mockito.spy(new CertClient(mock(SSLContext.class)));
        doReturn(mockHttpConnection).when(spyCertClient, "getHttpConnection", any(URL.class));

        // 创建MyService的子类，重写方法返回Spy实例
        MyService someCaller = new MyService() {
            @Override
            protected CertClient generateCertificateClient(SomeParams params) {
                return spyCertClient;
            }
        };

        // 执行测试
        someCaller.provisionTenant();

        // 验证调用
        verify(spyCertClient).enrollCertificate(any(EnrollmentRequest.class));
    }
}

这种方式更符合测试最佳实践，减少对PowerMock这类工具的依赖，代码也更易维护。

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