Mockito - 如何避免将数据插入数据库？

Question

How can we write mockito for the below code? It's been written in normal JDBC. I need to create a mock of all this code having main method (which is driving all the logic of updating the data).

I am really need help in mocking the avoid inserting the actual data. Could someone please guide me ?

public class PaytPaytmBilling { 
    private static Category logger = Category.getInstance(PaytPaytmBilling.class);
    private static InputStream inputS = XY.class.getResourceAsStream("/paytm.properties");

    private static final INSERT_QUERY = "INSERT STATEMENT";


    private static void insertPaytPaytmBilling(ArrayList allPaytPaytmBill) throws Exception{

        conn = getConnection(userId, passwd, prop.getProperty("databaseURL"));

        String childSql = buildInsertPaytPaytmBillSql();

        PreparedStatement pStatement =  conn.prepareStatement(childSql);

        for (int i=0; i<allPaytPaytmBill.size(); i++){
            PaytPaytmBill PaytmBill = (PaytPaytmBill) allPaytPaytmBill.get(i);

            pStatement.setString(1, PaytmBill.getXX());
            pStatement.setString(2, PaytmBill.getYY());
            pStatement.setString(3, PaytmBill.getAA());
            pStatement.setLong(4, PaytmBill.getBB());
            pStatement.setLong(5, PaytmBill.getCC));            
            pStatement.setString(6, PaytmBill.getDD());
            pStatement.setInt(7, PaytmBill.getEE());
            pStatement.setInt(8, PaytmBill.getFF());
            pStatement.setString(9, "");
            pStatement.setString(10, "");
            pStatement.execute();       
        }   
        pStatement.close();
        conn.close();
    }

    private static void getDbConn() throws Exception {
        // Here get DB connection
    }


    public static void main(String[] args) throws Exception
    {
        ArrayList allPaytPaytmBill = new ArrayList();
        XY.init();
        getDbConn();
        // This query reads data from other tables and creates the data..
        String qmrString = qmr.buildQmrSql();

        allPaytPaytmBill = qmr.getAllMemberData(qmrString);

        insertPaytPaytmBilling(allPaytPaytmBill);
    }   
}

Mockito Test class:

@RunWith(MockitoJUnitRunner.class)
public class PaytmBillingTest {
    private static Category logger = Category.getInstance(PaytmBillingTest.class);

    @Mock
    private DataSource ds;

    @Mock
    private Connection c;

    @Mock
    private PreparedStatement stmt;

    @Mock
    private ResultSet rs;

    private ArrayList<PaytmBill> allPaytmBill;

    @Before
    public void before() {
        allPaytmBill = new ArrayList<>();
        PaytmBill PaytmBill = new PaytmBill();
        PaytmBill.setAA("1182"); 
        PaytmBill.setBB("5122");
        PaytmBill.setCC("201807");
        PaytmBill.setDD(0L);
        PaytmBill.setEE(100);
        PaytmBill.setFF(0);
        PaytmBill.setGG(0);
        PaytmBill.setHH("A");
        PaytmBill.setII(null);
        PaytmBill.setJJ(null);

        allPaytmBill.add(PaytmBill);
    }

    @Test
    public void testPaytmBilling() {    
        PaytmBilling PaytmBilling = new PaytmBilling();

    }
}

Answer 1

First of all, it looks like you are not showing use the real code. For example you added private static void getDbConn() but the code calls conn = getConnection(...) , the variable conn is not declared anywhere, etc. This makes it harder to really help with your issue.

Looking at your unit test, you want to mock instances of certain classes used by PaytPaytmBilling, like DataSource, Connection and PreparedStatement. These are called 'dependencies'.

In order to do that, you need to change PaytPaytmBilling so that these dependencies are 'injected' (see Dependency Injection ). This means they are provided to PaytPaytmBilling via the constructor or a setter (or with some frameworks just by adding an annotation on the field).

In the current code, the dependencies are obtained by PaytPaytmBilling itself (eg by calling a static method, or creating a new instance) and they cannot be mocked (except via some black magic mocking frameworks which I don't advise you to get into right now).

To write good unit tests, you need to write (or refactor) the code to be testable, which means dependencies are injected, not obtained internally in the class. Also avoid static methods and data (constants are ok), they don't play nice with dependency injection and testable code.

So for example the DataSource could be injected via the constructor like this:

public class PaytPaytmBilling { 

    private static final String CHILD_SQL = "SELECT bladiebla...";

    private DataSource dataSource;        

    public PaytPaytmBilling(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void insertPaytPaytmBilling(List<PaytmBill> allPaytPaytmBill) {
        // keeping the example simple here.
        // don't use String literals for the parameters below but read 
        // them from Properties (which you can mock for the unit test)
        Connection conn = dataSource.getConnection("userId", "passwd", "url");
        PreparedStatement pStatement = conn.prepareStatement(CHILD_SQL);
        for (int i=0; i<allPaytPaytmBill.size(); i++){
            PaytPaytmBill PaytmBill = (PaytPaytmBill) allPaytPaytmBill.get(i);
            pStatement.setString(1, PaytmBill.getXX());
            pStatement.setString(2, PaytmBill.getYY());
            pStatement.setString(3, PaytmBill.getAA());
            // ...
            pStatement.execute();       
        }               
        pStatement.close();
        conn.close();
    }

If you re-write the code like above, you could test it like this:

@RunWith(MockitoJUnitRunner.class)
public class PaytmBillingTest {

    // this will cause Mockito to automatically create an instance 
    // and inject any mocks needed
    @InjectMocks
    private PaytmBilling instanceUnderTest;

    @Mock
    private DataSource dataSource;

    // connection is not directly injected. It is obtained by calling 
    // the injected dataSource
    @Mock
    private Connection connection;

    // preparedStatement is not directly injected. It is obtained by
    // calling the connection, which was obtained by calling the 
    // injected dataSource
    @Mock
    private PreparedStatement preparedStatement;

    private List<PaytmBill> allPaytmBill;

    @Before
    public void before() {
        allPaytmBill = new ArrayList<>();
        PaytmBill paytmBill = new PaytmBill();
        paytmBill.setAA("1182"); 
        paytmBill.setBB("5122");
        paytmBill.setCC("201807");
        paytmBill.setDD(0L);
        paytmBill.setEE(100);
        paytmBill.setFF(0);
        paytmBill.setGG(0);
        paytmBill.setHH("A");
        paytmBill.setII(null);
        paytmBill.setJJ(null);

        allPaytmBill.add(PaytmBill);
    }

    @Test
    public void testPaytmBilling() {    
        // given
        when(dataSource.getConnection(anyString(), anyString(), anyString())).thenReturn(connection);
        when(connection.prepareStatement(anyString())).thenReturn(preparedStatement);

        // when
        instanceUnderTest.insertPaytPaytmBilling(allPaytPaytmBill);

       // then
       verify(pStatement).setString(1, paytmBill.getXX());
       verify(pStatement).setString(2, paytmBill.getYY());
       verify(pStatement).setString(3, paytmBill.getAA());
       // ...
       verify(pStatement).execute();
       verify(pStatement).close();
       verify(connection).close();
    }

Unrelated suggestion regarding your code: It's better to close resources in a finally block, or using try-with resources . In you current code resources will not be closed if an exception occurs whilst processing on the resources:

Connection conn = dataSource.getConnection("userId", "passwd", "url");
PreparedStatement pStatement = conn.prepareStatement(childSql);
try {
    // processing steps
}
finally {
    pStatement.close();
    conn.close();
}

Or try-with-resources:

try (Connection conn = dataSource.getConnection("userId", "passwd", "url"),
     PreparedStatement pStatement = conn.prepareStatement(childSql)) {

    // processing steps
}

Since Connection and PreparedStatement implement the AutoCloseable interface they will be closed automatically when the try block ends. This is possible since Java 7.