Java 调试模式下Mockito数据源测试失败

为什么当我在调试模式下运行单元测试时，在代码行中使用断点，单元测试失败了

而（rs.next（））{

它将在第一次迭代后退出循环，尽管测试中有指令

Mockito.when（mockResultSet.next（））。然后返回（true、true、false）；

此单元测试在正常模式下运行时工作正常

注意：我使用的是Intellij，testNG

课程

public class ProjectDao {
private static Logger LOG = LogManager.getLogger(ProjectDao.class);
private DataSource dataSource;

private int id;
private String name;

// For Testing
public ProjectDao(DataSource dataSource) {
    this.dataSource = dataSource;
}

public ProjectDao() {
    dataSource = Database.getDataSource();
}
public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}
public List<Project> getProjects() throws Exception {
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;

    String SQL = "SELECT project.id, project.name FROM cicd.project";
    List<Project> projects = new ArrayList<>();
    try {
        conn = dataSource.getConnection();
        ps = conn.prepareStatement(SQL);
        rs = ps.executeQuery();



        while (rs.next()) {
            Project p = new Project();
            p.setId(rs.getInt("id"));
            p.setName(rs.getString("name"));

            projects.add(p);
        }

        LOG.debug("found: " + projects);
        return projects;

    } catch (SQLException e) {
        LOG.error("Error: " + e.getMessage());
        e.printStackTrace();
    } finally {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                LOG.error("Error closing resultset: " + e.getMessage());
                e.printStackTrace();
            }
        }
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                LOG.error("Error closing PreparedStatement: " + e.getMessage());
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                LOG.error("Error closing connection: " + e.getMessage());
                e.printStackTrace();
            }
        }
    }
    return projects;
}

@PrepareForTest(ProjectDao.class)
public class ProjectDaoTests {
private static Logger LOG = LogManager.getLogger(ProjectDaoTests.class);

List<Project> projects;
Project projectA = new Project();
Project projectB = new Project();

@Mock
DataSource mockDataSource;

@Mock
Connection mockConn;

@Mock
PreparedStatement mockPreparedStmnt;

@Mock
ResultSet mockResultSet;

@BeforeTest(groups = "ut")
public void initMocks() throws IOException, SQLException {
    MockitoAnnotations.initMocks(this);


    when(mockDataSource.getConnection()).thenReturn(mockConn);
    when(mockDataSource.getConnection(anyString(), anyString())).thenReturn(mockConn);
    doNothing().when(mockConn).commit();
    when(mockConn.prepareStatement(anyString())).thenReturn(mockPreparedStmnt);
    when(mockPreparedStmnt.executeQuery()).thenReturn(mockResultSet);

    projects = new ArrayList<>();
} 

@Test(groups = "ut")
public void testProjects() throws Exception {
    projectA.setId(1);
    projectA.setName("projectA");
    projectB.setId(2);
    projectB.setName("projectB");
    projects.add(projectA);
    projects.add(projectB);

    Mockito.when(mockResultSet.next()).thenReturn(true, true, false);

    Mockito.when(mockResultSet.getInt("id")).thenReturn(projectA.getId(), projectB.getId());
    Mockito.when(mockResultSet.getString("name")).thenReturn(projectA.getName(), projectB.getName());

    ProjectDao projectDao = new ProjectDao(mockDataSource);
    List<Project> projectsList = projectDao.getProjects();

    Assert.assertEquals(projectsList.size(), 2);
    Assert.assertEquals(projectsList.get(0).getId(), projectA.getId());
    Assert.assertEquals(projectsList.get(0).getName(), projectA.getName());
    Assert.assertEquals(projectsList.get(1).getId(), projectB.getId());
    Assert.assertEquals(projectsList.get(1).getName(), projectB.getName());
}

公共类ProjectDao{
私有静态记录器LOG=LogManager.getLogger（ProjectDao.class）；
私有数据源；
私有int-id；
私有字符串名称；
//用于测试
公共项目DAO（数据源数据源）{
this.dataSource=数据源；
}
公共工程{
dataSource=Database.getDataSource（）；
}
公共int getId（）{
返回id；
}
公共无效集合id（内部id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
public List getProjects（）引发异常{
连接conn=null；
PreparedStatement ps=null；
结果集rs=null；
String SQL=“从cicd.project中选择project.id、project.name”；
列表项目=新建ArrayList（）；
试一试{
conn=dataSource.getConnection（）；
ps=连接准备状态（SQL）；
rs=ps.executeQuery（）；
while（rs.next（））{
项目p=新项目（）；
p、 setId（rs.getInt（“id”）；
p、 setName（rs.getString（“name”）；
增加（p）；
}
LOG.debug（“发现：+项目”）；
返回项目；
}捕获（SQLE异常）{
LOG.error（“错误：+e.getMessage（））；
e、 printStackTrace（）；
}最后{
如果（rs！=null）{
试一试{
rs.close（）；
}捕获（SQLE异常）{
错误（“错误关闭结果集：+e.getMessage（））；
e、 printStackTrace（）；
}
}
如果（ps！=null）{
试一试{
ps.close（）；
}捕获（SQLE异常）{
LOG.error（“关闭PreparedStatement时出错：”+e.getMessage（））；
e、 printStackTrace（）；
}
}
如果（conn！=null）{
试一试{
康涅狄格州关闭（）；
}捕获（SQLE异常）{
LOG.error（“关闭连接时出错：+e.getMessage（））；
e、 printStackTrace（）；
}
}
}
返回项目；
}

测试类

public class ProjectDao {
private static Logger LOG = LogManager.getLogger(ProjectDao.class);
private DataSource dataSource;

private int id;
private String name;

// For Testing
public ProjectDao(DataSource dataSource) {
    this.dataSource = dataSource;
}

public ProjectDao() {
    dataSource = Database.getDataSource();
}
public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}
public List<Project> getProjects() throws Exception {
    Connection conn = null;
    PreparedStatement ps = null;
    ResultSet rs = null;

    String SQL = "SELECT project.id, project.name FROM cicd.project";
    List<Project> projects = new ArrayList<>();
    try {
        conn = dataSource.getConnection();
        ps = conn.prepareStatement(SQL);
        rs = ps.executeQuery();



        while (rs.next()) {
            Project p = new Project();
            p.setId(rs.getInt("id"));
            p.setName(rs.getString("name"));

            projects.add(p);
        }

        LOG.debug("found: " + projects);
        return projects;

    } catch (SQLException e) {
        LOG.error("Error: " + e.getMessage());
        e.printStackTrace();
    } finally {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                LOG.error("Error closing resultset: " + e.getMessage());
                e.printStackTrace();
            }
        }
        if (ps != null) {
            try {
                ps.close();
            } catch (SQLException e) {
                LOG.error("Error closing PreparedStatement: " + e.getMessage());
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                LOG.error("Error closing connection: " + e.getMessage());
                e.printStackTrace();
            }
        }
    }
    return projects;
}

@PrepareForTest(ProjectDao.class)
public class ProjectDaoTests {
private static Logger LOG = LogManager.getLogger(ProjectDaoTests.class);

List<Project> projects;
Project projectA = new Project();
Project projectB = new Project();

@Mock
DataSource mockDataSource;

@Mock
Connection mockConn;

@Mock
PreparedStatement mockPreparedStmnt;

@Mock
ResultSet mockResultSet;

@BeforeTest(groups = "ut")
public void initMocks() throws IOException, SQLException {
    MockitoAnnotations.initMocks(this);


    when(mockDataSource.getConnection()).thenReturn(mockConn);
    when(mockDataSource.getConnection(anyString(), anyString())).thenReturn(mockConn);
    doNothing().when(mockConn).commit();
    when(mockConn.prepareStatement(anyString())).thenReturn(mockPreparedStmnt);
    when(mockPreparedStmnt.executeQuery()).thenReturn(mockResultSet);

    projects = new ArrayList<>();
} 

@Test(groups = "ut")
public void testProjects() throws Exception {
    projectA.setId(1);
    projectA.setName("projectA");
    projectB.setId(2);
    projectB.setName("projectB");
    projects.add(projectA);
    projects.add(projectB);

    Mockito.when(mockResultSet.next()).thenReturn(true, true, false);

    Mockito.when(mockResultSet.getInt("id")).thenReturn(projectA.getId(), projectB.getId());
    Mockito.when(mockResultSet.getString("name")).thenReturn(projectA.getName(), projectB.getName());

    ProjectDao projectDao = new ProjectDao(mockDataSource);
    List<Project> projectsList = projectDao.getProjects();

    Assert.assertEquals(projectsList.size(), 2);
    Assert.assertEquals(projectsList.get(0).getId(), projectA.getId());
    Assert.assertEquals(projectsList.get(0).getName(), projectA.getName());
    Assert.assertEquals(projectsList.get(1).getId(), projectB.getId());
    Assert.assertEquals(projectsList.get(1).getName(), projectB.getName());
}

@PrepareForTest（ProjectDao.class）
公共类项目测试{
私有静态记录器LOG=LogManager.getLogger（ProjectDaoTests.class）；
列出项目清单；
项目A=新项目（）；
项目B=新项目（）；
@嘲弄
数据源模拟数据源；
@嘲弄
连接模拟接头；
@嘲弄
已准备好的报表mockPreparedStmnt；
@嘲弄
结果集模拟结果集；
@测试前（groups=“ut”）
public void initMocks（）引发IOException、SQLException{
initMocks（this）；
当（mockDataSource.getConnection（））。然后返回（mockConn）；
当（mockDataSource.getConnection（anyString（），anyString（））。然后返回（mockConn）；
doNothing（）.when（mockConn.commit（）；
when（mockConn.prepareStatement（anyString（））。然后返回（mockPreparedStmnt）；
当（mockPreparedStmnt.executeQuery（））。然后返回（mockResultSet）；
projects=newarraylist（）；
} 
@测试（组=“ut”）
public void testProjects（）引发异常{
projectA.setId（1）；
projectA.setName（“projectA”）；
项目b.setId（2）；
projectB.setName（“projectB”）；
项目。添加（项目A）；
项目。添加（项目B）；
Mockito.when（mockResultSet.next（））。然后返回（true、true、false）；
Mockito.when（mockResultSet.getInt（“id”））。然后返回（projectA.getId（），projectB.getId（））；
Mockito.when（mockResultSet.getString（“name”））。然后返回（projectA.getName（），projectB.getName（））；
ProjectDao ProjectDao=新的ProjectDao（mockDataSource）；
List projectsList=projectDao.getProjects（）；
Assert.assertEquals（projectsList.size（），2）；
Assert.assertEquals（projectsList.get（0.getId（），projectA.getId（））；
Assert.assertEquals（projectsList.get（0.getName（），projectA.getName（））；
Assert.assertEquals（projectsList.get（1.getId（），projectB.getId（））；
Assert.assertEquals（projectsList.get（1.getName（），projectB.getName（））；
}

您是否有机会在调试中评估

rs.next（）

，或者您的断点是否使用了

rs.next（）

上的条件？我只是在那里设置了一个断点，所以执行停止。然后我介入，但它只迭代一次。我还尝试模拟更多的迭代，如“.thenReturn”（真，真，真，真，真，假）5942。