如何在不使用PowerMockito和whenNew的情况下编写FileInputStream的Mockito测试用例

核心问题在于你当前的代码可能直接在方法内部new FileInputStream，导致Mockito无法拦截这个实例化操作，只能触发真实的文件读取，进而抛出FileNotFoundException。下面是无需PowerMockito、无需本地文件的可行方案：

1. 重构代码：抽象流创建逻辑 #

先把创建FileInputStream的逻辑抽成一个可依赖的接口，避免在业务方法里直接硬编码实例化：

// 定义流提供接口
public interface FileStreamProvider {
    InputStream getFileInputStream(String filePath) throws IOException;
}

// 生产环境的实现类
public class DefaultFileStreamProvider implements FileStreamProvider {
    @Override
    public InputStream getFileInputStream(String filePath) throws IOException {
        return new FileInputStream(filePath);
    }
}

2. 修改被测类，依赖注入接口 #

把原来的业务类改成通过构造方法注入上述接口，用它来获取输入流，而不是直接new：

public class FileProcessor {
    private final FileStreamProvider streamProvider;

    // 构造注入，测试时传入mock对象
    public FileProcessor(FileStreamProvider streamProvider) {
        this.streamProvider = streamProvider;
    }

    // 你的业务方法，现在通过provider获取流
    public String processServerFile(String serverFilePath) throws IOException {
        try (InputStream inputStream = streamProvider.getFileInputStream(serverFilePath)) {
            // 这里是你原本对FileInputStream的操作逻辑，比如读取内容
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            return reader.readLine();
        }
    }
}

3. 编写Mockito测试用例 #

现在可以直接mockFileStreamProvider，让它返回模拟的InputStream（比如用ByteArrayInputStream模拟文件内容），完全脱离真实文件系统：

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
public class FileProcessorTest {
    @Mock
    private FileStreamProvider mockStreamProvider;

    @InjectMocks
    private FileProcessor fileProcessor;

    @Test
    public void processServerFile_returnsContentSuccessfully() throws IOException {
        // 模拟文件内容
        String mockContent = "Mocked server file content";
        InputStream mockStream = new ByteArrayInputStream(mockContent.getBytes());

        // 配置mock：当传入指定服务器路径时，返回模拟流
        String testServerPath = "/server/storage/file.txt";
        when(mockStreamProvider.getFileInputStream(testServerPath)).thenReturn(mockStream);

        // 执行测试
        String result = fileProcessor.processServerFile(testServerPath);

        // 验证结果
        assertEquals(mockContent, result);
    }

    @Test
    public void processServerFile_throwsIOExceptionWhenFileNotFound() throws IOException {
        String invalidPath = "/server/invalid/path.txt";
        // 模拟文件不存在的异常
        when(mockStreamProvider.getFileInputStream(invalidPath)).thenThrow(new IOException("File not found on server"));

        // 验证异常抛出
        IOException exception = assertThrows(IOException.class, () -> {
            fileProcessor.processServerFile(invalidPath);
        });
        assertEquals("File not found on server", exception.getMessage());
    }
}

关键说明 #

• 这种方式通过依赖解耦避免了直接操作文件系统，完全符合Mockito的测试场景。
• 如果无法重构原有代码（比如遗留系统），那没有PowerMockito的情况下几乎无法解决——因为Mockito无法拦截方法内部的new操作，必然会触发真实的文件读取导致异常。所以重构解耦是唯一可行的路径。

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