Mock ResultSet with Mockito

Question

How to mock the resultset?

In the test class trying to mock the resultset as below but, when trying to test getting error as UnnecessaryStubbingException at statements :

voObj.setDept(rs.getString(2)); 

and

voObj.setDeptDesc(rs.getString(3));

Any suggessions on how to mock the resultset?

public class Example { 
    public static void main(String[] s) {
        method1();
        method2();
        ..........
    }

    private Employee method1(String str) {
                Connection conn           =  getConnection();   
        PreparedStatement pstmt   = null;
        .........
        pstmt = conn.prepareStatement(strQuery.toString());
        rs  = pstmt.executeQuery();
        int ilCounter   = 0; 
        int maxId   = method2(loc); //some DB calls here with select

        if(null != rs) {            
            while(rs.next()) { 
                ilCounter++;
                ObjVoBean voObj = new ObjVoBean();
                voObj.setLoc(rs.getString(1));
                voObj.setDept(rs.getString(2));
                voObj.setDeptDesc(rs.getString(3));
            }
            .................
        }
       }

   private Employee method2(String str1) {
                Connection connOHM      = getConnection();  
        PreparedStatement pstmt     = null;
        .........
       //some DB call with select ...
   }
}

public class ExampleTest { 
   @InjectMocks
   Example example;

   @Mock
   private Connection c;

   @Mock
   private PreparedStatement preStmt;
    .....

   @Before
   public void setUp() {
        ........
   }

   @Test
   public void testMethod1() throws SQLException {
        ResultSet resultSetMock = Mockito.mock(ResultSet.class);
        when(resultSetMock.getString(1)).thenReturn("1111");
        when(resultSetMock.getString(2)).thenReturn("2222");
        when(resultSetMock.getString(3)).thenReturn("dept desc");

        when(c.prepareStatement(any(String.class))).thenReturn(preStmt);
        when(resultSetMock.next()).thenReturn(true).thenReturn(false); 
        doReturn(resultSetMock).when(preStmt).executeQuery();

        example.method1("1111");            
        assertTrue(true);
   }
}

Answer 1

To be able to mock the ResultSet you should mock all objects that allow to create it that is Connection that creates the PreparedStatement, that itself creates the ResultSet. Mocking the Connection will work in the tested code only if you provide a way to set the connection from the client code.

Here conn that is the Connection should be first injected as a dependency in your test fixture :

pstmt = conn.prepareStatement(strQuery.toString());

Generally you create a Connection such as :

conn = DriverManager.getConnection(DB_URL,USER,PASS);

or via a DataSource such as :

conn = ds.getConnection();

So you should abstract this part into an interface or a not final class and define an implementation that do this processing. In this way you can mock the part that creates a Connection. And so you can mock the whole chain : Connection-PreparedStatement-ResultSet.

---

Personally I would avoid this way because mocking too many things is often not the right choice.
In your case, what you need is mocking the ResultSet to test the post processing after loading the ResultSet :

while(rs.next()) { 
     ilCounter++;
     ObjVoBean voObj = new ObjVoBean();
     voObj.setLoc(rs.getString(1));
     voObj.setDept(rs.getString(2));
     voObj.setDeptDesc(rs.getString(3));
}

So as alternative you could move all code performed before in a method of specific class handling the persistence part. In this way you just need to mock this dependency and this method. You don't need to worry about Connection and any JDBC detail.

EmployeeDAO employeeDAO; // dependency to mock

// constructor with dependency
public Example(EmployeeDAO employeeDAO){
  this.employeeDAO = employeeDAO;
}

private Employee method1(String str) {
   ResultSet resultSet = employeeDAO.load(str);

    if(null != rs) {            
        while(rs.next()) { 
            ilCounter++;
            ObjVoBean voObj = new ObjVoBean();
            voObj.setLoc(rs.getString(1));
            voObj.setDept(rs.getString(2));
            voObj.setDeptDesc(rs.getString(3));
        }
        .................
    }
   }

Of couse the DAO components also have to be unitary tested.
Bu as said earlier, asserting that a Connection is created or that it returns a PreparedStatement does not bring value. While testing that your queries perform what you expect from them is much more interesting in terms of functional coverage.
In this case, you want to test it against an in-memory DB such as H2 because unit tests are not integration tests and unit tests have to be fast executed.
To write DAO/Repository tests, Dbunit and DbSetup are good candidates because they provide facilities to setup the DB before each test (mainly injecting data and clearing data).

Answer 2

This is a mock Result Set I ripped off of GitHub

/*
* Distributed under the terms of the MIT License.
* Copyright (c) 2009, Marcelo Criscuolo.
*/

package commondb.mock;

import java.io.InputStream;
import java.io.Reader;
import java.io.StringReader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.NClob;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Statement;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

import org.apache.commons.lang.StringUtils;


public class MockResultSet implements ResultSet {
    static final String INVALID_COLUMN_NAME = "invalid column name";
    static final String INVALID_COLUMN_INDEX = "invalid column index";
        static final DateFormat DATE_ISO_8601 = new SimpleDateFormat("yyyy-MM-dd");
    private List<String[]> rowset = new ArrayList<String[]>();
    private int cursor = -1;
    private Map<String, Integer> columnMap = new HashMap<String, Integer>();
    private CSVLineSplitter splitter = new CSVLineSplitter();

    public MockResultSet() {
    }

    /**
     * ResultSet rs = new MockResultSet(
     *     "ID,NAME,CITY",
     *     "3,John,New York",
     *     "4,Bill,Sydney"
     * );
     *
     * @param str headers and rows that form the CSV data
     */
    public MockResultSet(String... str) throws SQLException {
        loadCSV(new StringReader(StringUtils.join(str, "\n")));
    }
    
    /**
     * @param in source from where the CSV data will be read
     * 
     * @throws SQLException any exception will be wrapped
     * on SQLException, so that it is not necessary to
     * add additional catches to client code.
     */
    public MockResultSet(Readable in) throws SQLException {
        loadCSV(in);
    }
    
    public void loadCSV(Readable in) throws SQLException {
        final Scanner sc = new Scanner(in);
        
        if (!sc.hasNextLine()) {
            sc.close();
            throw new SQLException("empty data source");
        }

        
        // load column headers
        String line = sc.nextLine();
        int index = 1;
        for (String column : splitter.split(line)) {
            columnMap.put(column, index);
            index++;
        }
        
        
        // load data
        while (sc.hasNextLine()) {
            line = sc.nextLine();
            
            String[] row = splitter.split(line);
            rowset.add(row);
        }
        
        sc.close();
    }
    
    @Override
    public boolean absolute(int row) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void afterLast() throws SQLException {
        cursor = rowset.size();
    }

    @Override
    public void beforeFirst() throws SQLException {
        cursor = -1;
    }

    @Override
    public void cancelRowUpdates() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void clearWarnings() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void close() throws SQLException {
        // noop
    }

    @Override
    public void deleteRow() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public int findColumn(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean first() throws SQLException {
        if (rowset.size() > 0) {
            cursor = 0;
            return true;
        }
        
        return false;
    }

    @Override
    public Array getArray(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Array getArray(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public InputStream getAsciiStream(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public InputStream getAsciiStream(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    @Deprecated
    public BigDecimal getBigDecimal(int columnIndex, int scale)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    @Deprecated
    public BigDecimal getBigDecimal(String columnLabel, int scale)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public InputStream getBinaryStream(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public InputStream getBinaryStream(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Blob getBlob(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Blob getBlob(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean getBoolean(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean getBoolean(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public byte getByte(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public byte getByte(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public byte[] getBytes(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public byte[] getBytes(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Reader getCharacterStream(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Reader getCharacterStream(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Clob getClob(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Clob getClob(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public int getConcurrency() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public String getCursorName() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
        /**
         * Dates are expected to be formatted as yyyy-MM-dd.
         * See http://en.wikipedia.org/wiki/ISO_8601#Calendar_dates
         */
    public Date getDate(int columnIndex) throws SQLException {
        try {
            String value = getValue(columnIndex);
            Date date = null;
            if ( (value != null) && (value.trim().length() >= 0)) {
                date = new Date(DATE_ISO_8601.parse(value).getTime());
            }
            
            return date;
        } catch (Exception e) {
            throw new SQLException(e);
        }
    }

    @Override
    public Date getDate(String columnLabel) throws SQLException {
        return getDate(getColumnIndex(columnLabel));
    }

    @Override
    public Date getDate(int columnIndex, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Date getDate(String columnLabel, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public double getDouble(int columnIndex) throws SQLException {
        try {
            String value = getValue(columnIndex);
            if ( (value == null) || (value.trim().length() == 0)) {
                value = "0";
            }
            
            value = value.replace(',', '.');
            
            return Double.parseDouble(value);
        } catch (Exception e) {
            throw new SQLException(e);
        }
    }

    @Override
    public double getDouble(String columnLabel) throws SQLException {
        return getDouble(getColumnIndex(columnLabel));
    }

    @Override
    public int getFetchDirection() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public int getFetchSize() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public float getFloat(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public float getFloat(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public int getHoldability() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public int getInt(int columnIndex) throws SQLException {
        try {
            String value = getValue(columnIndex);
            if ( (value == null) || (value.trim().length() == 0)) {
                value = "0";
            }

            return Integer.parseInt(value);
        } catch (Exception e) {
            throw new SQLException(e);
        }
    }

    @Override
    public int getInt(String columnLabel) throws SQLException {
        return getInt(getColumnIndex(columnLabel));
    }

    @Override
    public long getLong(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public long getLong(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public ResultSetMetaData getMetaData() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Reader getNCharacterStream(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Reader getNCharacterStream(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public NClob getNClob(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public NClob getNClob(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public String getNString(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public String getNString(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Object getObject(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Object getObject(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Object getObject(int columnIndex, Map<String, Class<?>> map)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Object getObject(String columnLabel, Map<String, Class<?>> map)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Ref getRef(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Ref getRef(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public int getRow() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public RowId getRowId(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public RowId getRowId(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public SQLXML getSQLXML(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public SQLXML getSQLXML(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public short getShort(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public short getShort(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Statement getStatement() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public String getString(int columnIndex) throws SQLException {
        return getValue(columnIndex);
    }

    private String getValue(int columnIndex) throws SQLException {
        if ( (cursor < 0) || (cursor >= rowset.size()) ) {
            throw new SQLException("cursor not pointing to a valid row");
        }
        
        String[] row = rowset.get(cursor);
        if ( (columnIndex < 0) || (columnIndex > row.length) ) {
            throw new SQLException(INVALID_COLUMN_INDEX);
        }
        
        return row[columnIndex - 1];
    }

    @Override
    public String getString(String columnLabel) throws SQLException {
        return getString(getColumnIndex(columnLabel));
    }

    private Integer getColumnIndex(String columnLabel) throws SQLException {
        Integer index = columnMap.get(columnLabel);
        if (index == null) {
            throw new SQLException(INVALID_COLUMN_NAME);
        }
        return index;
    }

    @Override
    public Time getTime(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Time getTime(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Time getTime(int columnIndex, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Time getTime(String columnLabel, Calendar cal) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Timestamp getTimestamp(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Timestamp getTimestamp(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Timestamp getTimestamp(int columnIndex, Calendar cal)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public Timestamp getTimestamp(String columnLabel, Calendar cal)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public int getType() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public URL getURL(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public URL getURL(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    @Deprecated
    public InputStream getUnicodeStream(int columnIndex) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    @Deprecated
    public InputStream getUnicodeStream(String columnLabel) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public SQLWarning getWarnings() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void insertRow() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean isAfterLast() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean isBeforeFirst() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean isClosed() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean isFirst() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean isLast() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean last() throws SQLException {
        if (rowset.size() > 0) {
            cursor = rowset.size() - 1;
            return true;
        }
        
        return false;
    }

    @Override
    public void moveToCurrentRow() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void moveToInsertRow() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean next() throws SQLException {
        
        final boolean hasNext = (cursor + 1) < rowset.size();
        if (hasNext) {
            cursor++;
        }
        
        return hasNext;
    }

    @Override
    public boolean previous() throws SQLException {
        cursor--;
        
        if (cursor < -1) { 
            cursor = -1; // one row before the first is the limit
        }
        
        final boolean beforeFirst = (cursor < 0);       
        return !beforeFirst;
    }

    @Override
    public void refreshRow() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean relative(int rows) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean rowDeleted() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean rowInserted() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public boolean rowUpdated() throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void setFetchDirection(int direction) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void setFetchSize(int rows) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateArray(int columnIndex, Array x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateArray(String columnLabel, Array x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateAsciiStream(int columnIndex, InputStream x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateAsciiStream(String columnLabel, InputStream x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateAsciiStream(int columnIndex, InputStream x, int length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateAsciiStream(String columnLabel, InputStream x, int length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateAsciiStream(int columnIndex, InputStream x, long length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateAsciiStream(String columnLabel, InputStream x, long length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBigDecimal(int columnIndex, BigDecimal x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBigDecimal(String columnLabel, BigDecimal x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBinaryStream(int columnIndex, InputStream x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBinaryStream(String columnLabel, InputStream x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBinaryStream(int columnIndex, InputStream x, int length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBinaryStream(String columnLabel, InputStream x, int length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBinaryStream(int columnIndex, InputStream x, long length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBinaryStream(String columnLabel, InputStream x,
            long length) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBlob(int columnIndex, Blob x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBlob(String columnLabel, Blob x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBlob(int columnIndex, InputStream inputStream)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBlob(String columnLabel, InputStream inputStream)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBlob(int columnIndex, InputStream inputStream, long length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBlob(String columnLabel, InputStream inputStream,
            long length) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBoolean(int columnIndex, boolean x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBoolean(String columnLabel, boolean x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateByte(int columnIndex, byte x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateByte(String columnLabel, byte x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBytes(int columnIndex, byte[] x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateBytes(String columnLabel, byte[] x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateCharacterStream(int columnIndex, Reader x)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateCharacterStream(String columnLabel, Reader reader)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateCharacterStream(int columnIndex, Reader x, int length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateCharacterStream(String columnLabel, Reader reader,
            int length) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateCharacterStream(int columnIndex, Reader x, long length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateCharacterStream(String columnLabel, Reader reader,
            long length) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateClob(int columnIndex, Clob x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateClob(String columnLabel, Clob x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateClob(int columnIndex, Reader reader) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateClob(String columnLabel, Reader reader)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateClob(int columnIndex, Reader reader, long length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateClob(String columnLabel, Reader reader, long length)
            throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateDate(int columnIndex, Date x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateDate(String columnLabel, Date x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateDouble(int columnIndex, double x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    @Override
    public void updateDouble(String columnLabel, double x) throws SQLException {
        throw new UnsupportedOperationException("to be implemented");
    }

    

    

    

}

Answer 3

I also wanted to be able to mock a ResultSet with multiple rows and found various answers online but none of them seemed to meet my needs.

In my case I have a class method (SUT) that iterates through a(n) (unknown) number of rows and perform some logic on them (in production runtime). I am trying to ensure that the correct objects that get built from these rows are returned. At test time I know the exact number of rows I am going to examine.

My solution was to @InjectMocks into my my repo class which takes a "factory" connection class that provides the connection via the repo constructor. This is what I did:

import static org.mockito.Mockito.*;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.SomeStuff.MyRepository;
import com.SomeStuff.MyConnectionFactory;
import com.SomeStuff.Widget;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.*;
import static org.junit.jupiter.api.Assertions.*;
import java.util.List;
import lombok.SneakyThrows;
import org.junit.jupiter.api.Test;

public class MyClass {
    @InjectMocks
    private MyRepository myRepository;

    @Mock
    private MyConnectionFactory mcf;

    @Mock
    private Connection c;

    @Mock
    private PreparedStatement stmt;

    @Mock
    private ResultSet rs;

    // snipped code below, more to follow
}

then I added a @BeforeEeach to my setup method and inside there comes the secret sauce. In my case I know my code in the SUT wants to iterate through 9 fake rows and I also know that in a couple of cases it only need to work with two rows if they meet certain characteristics.

public class MyClass {        
        // snipped the previous stuff above
    
        MockitoAnnotations.openMocks(this);
    
        when(mcf.getConnection()).thenReturn(c);
        when(c.prepareStatement(any(String.class))).thenReturn(stmt);

        when(rs.next())
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(true)
            .thenReturn(false);
    
        when(rs.getInt("person_id"))
            .thenReturn(10001)
            .thenReturn(10001)
            .thenReturn(10001)
            .thenReturn(10001)
            .thenReturn(10001)
            .thenReturn(10002)
            .thenReturn(10002)
            .thenReturn(10002)
            .thenReturn(10002);
    
        when(rs.getString("first_name"))
            .thenReturn("John")
            .thenReturn("Dave");
    
        when(rs.getString("last_name"))
            .thenReturn("Doe")
            .thenReturn("Smith");
    
        when(rs.getString("key_value"))
            .thenReturn("Yes")
            .thenReturn("")
            .thenReturn("8005551212")
            .thenReturn("Hello,")
            .thenReturn("No")
            .thenReturn("")
            .thenReturn("")
            .thenReturn("World!")
            .thenReturn("No");
    
        when(stmt.executeQuery()).thenReturn(rs);
    }

Take note that in the above code there is an additional .thenReturn(false) for next or it will never be false. This will cause an infiinte loop if you are while-ing through the rows.

Also notice that in my case my SUT only calls into first_name and last_name twice (as mentioned above, due to other criteria in the rows) so I call thenReturn on it twice (or else there would be 8 calls to it and that won't suit my needs.

Finally I test it like this:

public class MyClass {
// Everything snipped above

    @Test
    @SneakyThrows
    public void getPeople_correct_number_of_Person_is_retrieved() {
        List<Person> people = myRepository.getPeople();
        assertEquals(1, people.size());
    }
}

In my case above I expect one Person to be returned where the 9 rows actually represented characteristics for two people.