JUnit与Mockito：测试Spring Boot中抽象类的CSV读取逻辑

public abstract class CsvService<T extends CsvBean> {

    // 核心读取方法，依赖抽象方法获取文件名、列映射和数据处理逻辑
    public List<T> readFromCsv(Class<T> type, CsvToBeanFilter filter) {
        List<T> data = new ArrayList<>();
        try {
            // 资源获取，依赖 getFileName()
            Resource resource = new ClassPathResource("data/" + getFileName());
            Reader reader = new FileReader(resource.getFile());

            ColumnPositionMappingStrategy<T> strategy = new ColumnPositionMappingStrategy<>();
            strategy.setType(type);
            strategy.setColumnMapping(getColumns()); // 依赖 getColumns()

            CsvToBean<T> csvToBean = new CsvToBeanBuilder<T>(reader)
                    .withFilter(filter)
                    .withMappingStrategy(strategy) // 添加映射策略
                    .build();

            data = getData(csvToBean); // 依赖 getData()
            reader.close();
        } catch (IOException ex) {
            // 错误处理
            log.error(FILE_READ_ERROR, ex);
            ex.printStackTrace();
        }
        return data;
    }

    protected abstract String getFileName();
    protected abstract String[] getColumns();
    protected abstract List<T> getData(CsvToBean<T> csvToBean);
}

@Service
public class AirportService extends CsvService<Airport> {
    @Override
    protected String getFileName() {
        return "airports.csv"; // 返回真实文件名
    }

    @Override
    protected String[] getColumns() {
        return new String[]{"id", "code", "name"}; // 假设的列名
    }

    @Override
    protected List<Airport> getData(CsvToBean<Airport> csvToBean) {
        List<Airport> airports = new ArrayList<>();
        for (Airport bean : csvToBean) {
            Airport airport = new Airport(bean.getId(), bean.getCode(), bean.getName());
            airports.add(airport);
        }
        return airports;
    }
}

@ExtendWith(MockitoExtension.class)
class CsvServiceTest {

    private CsvService<Airport> service; // 使用具体类型

    // 模拟 CsvToBean 和 CsvToBeanFilter 以控制数据流
    @Mock
    private CsvToBean<Airport> csvToBean;
    @Mock
    private CsvToBeanFilter filter;

    @BeforeEach
    void setup() {
        service = new AirportService(); // 直接实例化具体服务
    }

    @Test
    void testReadFromCsvWithMockedData() {
        // 模拟 CsvToBean 的行为，使其返回预设数据
        Airport airport = new Airport(101, "DK", "Copenhagen Airport");
        when(filter.allowLine((String[]) any())).thenReturn(true);
        when(csvToBean.iterator())
            .thenReturn(new ArrayIterator<>(new Airport[]{airport}));

        // 问题：此处调用 readFromCsv 仍然会尝试读取实际的 "airports.csv"
        List<Airport> result = service.readFromCsv(Airport.class, filter);

        // 断言
        assertNotNull(result);
        assertFalse(result.isEmpty());
        assertEquals(1, result.size());
        assertEquals(101, result.get(0).getId());
    }
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.io.ClassPathResource; // 确保导入
import org.springframework.core.io.Resource; // 确保导入

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader; // 用于模拟文件内容
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;

// 假设 CsvBean 和 Airport 类的定义
// class CsvBean { /* ... */ }
// class Airport extends CsvBean { /* ... */ }

@ExtendWith(MockitoExtension.class)
class CsvServiceSpyTest {

    private AirportService serviceSpy; // 使用具体类型，并标记为spy

    @Mock
    private CsvToBean<Airport> csvToBeanMock; // 模拟 CsvToBean
    @Mock
    private CsvToBeanFilter filterMock; // 模拟 CsvToBeanFilter

    @BeforeEach
    void setup() {
        // 创建 AirportService 的 Spy 对象
        serviceSpy = Mockito.spy(new AirportService());
    }

    @Test
    void testReadFromCsvWithSpy() throws IOException {
        // 模拟 getFileName() 方法，使其返回一个不存在的文件名，
        // 或者更进一步，模拟文件读取逻辑（见注意事项）
        // 为了本例，我们让它返回一个虚拟文件名，但后续会通过模拟 Resource 来控制
        doReturn("mock_file.csv").when(serviceSpy).getFileName();

        // 模拟 getColumns() 方法，如果 readFromCsv 依赖它
        doReturn(new String[]{"id", "code", "name"}).when(serviceSpy).getColumns();

        // 模拟 getData() 方法，使其直接返回预设数据，跳过 CsvToBean 的实际迭代
        List<Airport> expectedAirports = new ArrayList<>();
        expectedAirports.add(new Airport(101, "DK", "Copenhagen Airport"));
        doReturn(expectedAirports).when(serviceSpy).getData(any(CsvToBean.class));

        // 调用 readFromCsv 方法
        List<Airport> result = serviceSpy.readFromCsv(Airport.class, filterMock);

        // 断言
        assertNotNull(result);
        assertFalse(result.isEmpty());
        assertEquals(1, result.size());
        assertEquals(101, result.get(0).getId());
        assertEquals("DK", result.get(0).getCode());
        assertEquals("Copenhagen Airport", result.get(0).getName());
    }
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import com.opencsv.bean.CsvToBean;
import com.opencsv.bean.CsvToBeanBuilder;
import com.opencsv.bean.ColumnPositionMappingStrategy;
import com.opencsv.bean.CsvToBeanFilter;

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

// 假设 CsvBean 和 Airport 类的定义
// class CsvBean { /* ... */ }
// class Airport extends CsvBean { /* ... */ }

@ExtendWith(MockitoExtension.class)
class CsvServiceSubclassTest {

    private CsvService<Airport> service;

    // 模拟 CsvToBean 和 CsvToBeanFilter
    @Mock
    private CsvToBeanFilter filterMock;

    @BeforeEach
    void setup() {
        // 创建 AirportService 的匿名子类，并重写 getFileName()
        service = new AirportService() {
            @Override
            protected String getFileName() {
                // 返回一个虚拟文件名，但实际不会被 ClassPathResource 使用，
                // 因为我们将在 readFromCsv 中注入一个模拟的 Reader
                return "mocked_airport_data.csv";
            }

            // 确保其他抽象方法也有合理的默认实现或被测试逻辑覆盖
            @Override
            protected String[] getColumns() {
                return new String[]{"id", "code", "name"};
            }

            @Override
            protected List<Airport> getData(CsvToBean<Airport> csvToBean) {
                // 这个方法在测试中仍然会被调用，所以我们需要确保 csvToBean 的迭代器被模拟
                List<Airport> airports = new ArrayList<>();
                for (Airport bean : csvToBean) {
                    airports.add(new Airport(bean.getId(), bean.getCode(), bean.getName()));
                }
                return airports;
            }
        };
    }

    @Test
    void testReadFromCsvWithTestSubclass() throws IOException {
        // 模拟 CsvToBean 的行为，使其返回预设数据
        Airport airport = new Airport(101, "DK", "Copenhagen Airport");

        // 我们可以直接模拟 CsvToBean 的迭代器，或者模拟 CsvToBeanBuilder 返回的 CsvToBean
        // 由于 CsvToBean 是在 readFromCsv 内部创建的，我们不能直接 @Mock CsvToBean
        // 需要模拟 CsvToBeanBuilder 的行为，或者通过反射注入 Reader

        // 为了简化，我们假设 CsvService 的 readFromCsv 方法能够被改造，
        // 允许注入 Reader 或 Resource，或者我们直接模拟了 getData。
        // 在不修改 CsvService 的情况下，直接模拟 getData 是更直接的方式。

        // 由于 CsvToBean 是在 readFromCsv 内部构建的，我们无法直接注入模拟的 CsvToBean。
        // 但我们可以模拟 getData 方法的返回值，以控制最终数据。
        // 注意：这种方式会跳过 CsvToBean 的实际解析过程，只测试 readFromCsv 调用 getData 的逻辑。

        // 更好的做法是，如果 readFromCsv 内部创建了 CsvToBean，
        // 我们可以模拟 CsvToBean 的依赖（如 Reader），或者直接模拟 getData。

        // 假设我们修改 CsvService 允许注入 Reader 或 Resource
        // 或者我们继续使用 Spy 的方式来模拟内部方法。
        // 如果不修改 CsvService，那么只能通过模拟 getData 来控制数据。

        // 重新审视原始问题，核心是 mock getFileName() 从而不读文件。
        // readFromCsv 内部创建 CsvToBean，并调用 getData。
        // 如果要测试 CsvToBean 的构建和 ColumnPositionMappingStrategy 的设置，
        // 那么需要模拟 Reader。

        // 假设 CsvService 改造为可接受 Reader，或者我们直接模拟 getData
        // 为了保持对原始问题的直接回答，我们聚焦在 getFileName() 的模拟。
        // 如果要完全避免文件IO，我们需要模拟 Resource.getFile() 和 FileReader 构造函数。
        // 这是一个更复杂的场景，通常需要 PowerMock 或对代码进行重构以注入这些依赖。

        // 回到最初的测试，我们模拟了 CsvToBean 的迭代器。
        // 如果要让 CsvToBeanBuilder 使用模拟的 Reader，
        // readFromCsv 方法需要能够接受一个 Reader 参数，或者通过反射注入。
        // 鉴于现有代码，最直接的方式是模拟 getData，或者使用 Spy。

        // 考虑到原始问题和答案，更直接的是模拟 getData，或者模拟 getFileName()。
        // 让我们修正这个测试，使其能运行，并且避免文件IO。
        // 最直接的方式是模拟 getData()，就像 Solution 1 中的 Spy 例子一样。

        // 模拟 getData 方法的返回值，以避免实际的文件读取和 CsvToBean 的迭代
        List<Airport> expectedAirports = new ArrayList<>();
        expectedAirports.add(new Airport(101, "DK", "Copenhagen Airport"));

        // 注意：这里我们无法直接对 `service` 实例的 `getData` 进行 `doReturn`，
        // 因为它不是 Mockito 的 mock 或 spy 对象。
        // 如果要模拟 `getData`，`service` 本身也需要是 spy 对象。
        // 因此，对于此解决方案，我们假设 `getData` 的逻辑是简单的，
        // 并且我们通过模拟 `CsvToBean` 的迭代器来控制它。

        // 重新思考：如果 `service` 是一个匿名子类实例，
        // 它的 `getData` 方法会调用 `csvToBean` 的迭代器。
        // 所以我们只需要模拟 `csvToBean` 的迭代器即可。
        // 问题在于 `readFromCsv` 内部的 `new CsvToBeanBuilder(reader).build()`
        // 这会创建一个新的 `CsvToBean` 实例，而不是我们 `mock` 的 `csvToBeanMock`。

        // 结论：对于这种内部创建依赖的情况，直接使用 Spy 模拟 `getData` 或 `getFileName`
        // 是最简单和最有效的，因为它可以控制内部行为。
        // 如果坚持使用匿名子类，那么 `readFromCsv` 必须能够注入 `Reader` 或 `CsvToBean`。

        // 如果不修改 CsvService，且不使用 Spy，那么测试会很困难。
        // 假设 CsvService 的 readFromCsv 方法可以被修改为接受 Reader 参数进行测试。
        // 或者我们直接测试 getData 方法本身，而不是 readFromCsv。

        // 为了与原始问题和答案保持一致，我们应聚焦在 getFileName 的模拟。
        // 如果要避免文件IO，同时测试 readFromCsv 的大部分逻辑，
        // 最直接的是通过 Spy 模拟 getFileName 和 getData。
        // 或者，通过匿名子类，我们可以在 `readFromCsv` 内部注入一个 `StringReader`。

        // 改造 CsvService 以支持测试注入 Reader
        // 这需要修改 CsvService，使其有一个接受 Reader 的重载方法，或者在测试中通过反射注入。
        // 鉴于原始问题，我们不修改 CsvService。

        // 最直接的解决方案是 Spy。
        // 如果要用匿名子类，那么就必须让 readFromCsv 的内部 Reader 也是可控的。
        // 这是一个更深层次的测试问题。

        // 让我们回到原始答案的意图：
        // 1. Spy AirportService 并模拟 getFileName()。
        // 2. 创建一个 AirportService 的子类，重写 getFileName()。
        // 这两种方法都主要解决 getFileName() 的问题。

        // 如果我们使用匿名子类，并希望测试 readFromCsv 的完整流程，
        // 我们需要模拟 `ClassPathResource` 和 `FileReader`。这超出了 Mockito 的直接能力。
        // 或者，我们让 `getFileName` 返回一个指向真实但小的测试文件的路径。
        // 这又回到了读取真实文件，只是文件很小。

        // 最佳实践：将文件读取逻辑封装在另一个可注入的接口中。
        // 但如果不能修改代码，那么 Spy 是最好的选择。

        // 让我们重新组织 Solution 2，使其更符合实际可操作性，
        // 并且仍然避免实际文件读取，同时不修改 CsvService。
        // 这种情况下，我们必须模拟 `getData` 方法，否则 `FileReader` 会抛异常。

        // 因此，Solution 2 的代码应该更像 Solution 1，
        // 但不是使用 Spy，而是让匿名子类直接提供数据。

        // --- 修正 Solution 2 的代码 ---
        service = new AirportService() {
            @Override
            protected String getFileName() {
                // 返回一个虚拟文件名，但我们不会真的去读取它
                return "mocked_file.csv";
            }

            @Override
            protected String[] getColumns() {
                return new String[]{"id", "code", "name"};
            }

            @Override
            protected List<Airport> getData(CsvToBean<Airport> csvToBean) {
                // 在测试子类中直接提供模拟数据，避免实际的 CsvToBean 迭代和文件读取
                List<Airport> mockedAirports = new ArrayList<>();
                mockedAirports.add(new Airport(101, "DK", "Copenhagen Airport"));
                return mockedAirports;
            }
        };

        // 此时，filterMock 仍然可以被模拟，但它的 allowLine 方法可能不会被调用，
        // 因为我们已经模拟了 getData()。这取决于 readFromCsv 的调用顺序。
        // 如果 readFromCsv 在调用 getData 之前使用了 filter，那么 filterMock 仍然有用。

        // 调用 readFromCsv 方法
        List<Airport> result = service.readFromCsv(Airport.class, filterMock);

        // 断言
        assertNotNull(result);
        assertFalse(result.isEmpty());
        assertEquals(1, result.size());
        assertEquals(101, result.get(0).getId());
        assertEquals("DK", result.get(0).getCode());
        assertEquals("Copenhagen Airport", result.get(0).getName());
    }
}