commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bay...@apache.org
Subject svn commit: r1158110 - /commons/proper/dbutils/trunk/src/test/org/apache/commons/dbutils/QueryRunnerTest.java
Date Tue, 16 Aug 2011 05:51:38 GMT
Author: bayard
Date: Tue Aug 16 05:51:37 2011
New Revision: 1158110

URL: http://svn.apache.org/viewvc?rev=1158110&view=rev
Log:
Applying William Speirs' patch to move QueryRunnerTest to Mockito (DBUTILS-78)

Modified:
    commons/proper/dbutils/trunk/src/test/org/apache/commons/dbutils/QueryRunnerTest.java

Modified: commons/proper/dbutils/trunk/src/test/org/apache/commons/dbutils/QueryRunnerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/dbutils/trunk/src/test/org/apache/commons/dbutils/QueryRunnerTest.java?rev=1158110&r1=1158109&r2=1158110&view=diff
==============================================================================
--- commons/proper/dbutils/trunk/src/test/org/apache/commons/dbutils/QueryRunnerTest.java
(original)
+++ commons/proper/dbutils/trunk/src/test/org/apache/commons/dbutils/QueryRunnerTest.java
Tue Aug 16 05:51:37 2011
@@ -16,203 +16,476 @@
  */
 package org.apache.commons.dbutils;
 
-import java.beans.IndexedPropertyDescriptor;
-import java.beans.PropertyDescriptor;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.sql.Connection;
 import java.sql.ParameterMetaData;
 import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.SQLException;
-import java.sql.Types;
-import java.util.Arrays;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.RunnableFuture;
+
+import javax.sql.DataSource;
 
-import junit.framework.TestCase;
+import org.apache.commons.dbutils.handlers.ArrayHandler;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
 
-public class QueryRunnerTest extends TestCase {
+public class QueryRunnerTest {
     QueryRunner runner;
-    PreparedStatement stmt;
+	ArrayHandler handler;
+    
+    @Mock DataSource dataSource;
+    @Mock Connection conn;
+    @Mock PreparedStatement stmt;
+    @Mock ParameterMetaData meta;
+    @Mock ResultSet results;
+    
+    @Before
+    public void setUp() throws Exception {
+		MockitoAnnotations.initMocks(this);	// init the mocks
+
+		when(dataSource.getConnection()).thenReturn(conn);
+		when(conn.prepareStatement(any(String.class))).thenReturn(stmt);
+		when(stmt.getParameterMetaData()).thenReturn(meta);
+		when(stmt.getResultSet()).thenReturn(results);
+		when(stmt.executeQuery()).thenReturn(results);
+		when(results.next()).thenReturn(false);
+
+		 handler = new ArrayHandler();
+		 runner = new QueryRunner(dataSource);
+    }
+    
+    //
+    // Batch test cases
+    //
+    
+    private void callGoodBatch(Connection conn, Object[][] params) throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	int[] ret = runner.batch(conn, "select * from blah where ? = ?", params);
+
+    	verify(stmt, times(2)).addBatch();
+    	verify(stmt, times(1)).executeBatch();
+    	verify(stmt, times(1)).close();	// make sure we closed the statement
+    	verify(conn, times(0)).close();	// make sure we closed the connection
+    }
+    
+    private void callGoodBatch(Object[][] params) throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	int[] ret = runner.batch("select * from blah where ? = ?", params);
+
+    	verify(stmt, times(2)).addBatch();
+    	verify(stmt, times(1)).executeBatch();
+    	verify(stmt, times(1)).close();	// make sure we closed the statement
+    	verify(conn, times(1)).close();	// make sure we closed the connection
+    }
+
+    @Test
+    public void testGoodBatch() throws Exception {
+    	String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } };
+    	
+    	callGoodBatch(params);
+    }
+    
+    @Test
+    public void testGoodBatchPmdTrue() throws Exception {
+    	runner = new QueryRunner(dataSource, true);
+    	String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } };
+    	
+    	callGoodBatch(params);
+    }
+    
+    @Test
+    public void testGoodBatchDefaultConstructor() throws Exception {
+    	runner = new QueryRunner();
+    	String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } };
+    	
+    	callGoodBatch(conn, params);
+    }
+
+    @Test
+    public void testNullParamsBatch() throws Exception {
+    	String[][] params = new String[][] { { null, "unit" }, { "test", null } };
+    	
+    	callGoodBatch(params);
+    }
+    
+
+
+    // helper method for calling batch when an exception is expected
+    private void callBatchWithException(String sql, Object[][] params) throws Exception {
+    	int[] ret = null;
+    	boolean caught = false;
+    	
+    	try {
+    		ret = runner.batch(sql, params);
+
+    		verify(stmt, times(2)).addBatch();
+        	verify(stmt, times(1)).executeBatch();
+        	verify(stmt, times(1)).close();	// make sure the statement is closed
+        	verify(conn, times(1)).close();	// make sure the connection is closed
+    	} catch(SQLException e) {
+    		caught = true;
+    	}
+    	
+    	if(!caught)
+    		fail("Exception never thrown, but expected");
+    }
+
+    @Test
+    public void testTooFewParamsBatch() throws Exception {
+    	String[][] params = new String[][] { { "unit" }, { "test" } };
+    	
+    	callBatchWithException("select * from blah where ? = ?", params);
+    }
+
+    @Test
+    public void testTooManyParamsBatch() throws Exception {
+    	String[][] params = new String[][] { { "unit", "unit", "unit" }, { "test", "test", "test"
} };
+    	
+    	callBatchWithException("select * from blah where ? = ?", params);
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullConnectionBatch() throws Exception {
+    	String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } };
+    	
+    	when(meta.getParameterCount()).thenReturn(2);
+    	when(dataSource.getConnection()).thenReturn(null);
+    	
+    	runner.batch("select * from blah where ? = ?", params);
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullSqlBatch() throws Exception {
+    	String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } };
+    	
+    	when(meta.getParameterCount()).thenReturn(2);
+    	
+    	runner.batch(null, params);
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullParamsArgBatch() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	
+    	runner.batch("select * from blah where ? = ?", null);
+    }
+
+    @Test
+    public void testAddBatchException() throws Exception {
+    	String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } };
+    	
+    	doThrow(new SQLException()).when(stmt).addBatch();
+    	
+    	callBatchWithException("select * from blah where ? = ?", params);
+    }
+
+    @Test
+    public void testExecuteBatchException() throws Exception {
+    	String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } };
+    	
+    	doThrow(new SQLException()).when(stmt).executeBatch();
+    	
+    	callBatchWithException("select * from blah where ? = ?", params);
+    }
+
+    
+    //
+    // Query test cases
+    //
+    private void callGoodQuery(Connection conn) throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	Object[] ret = runner.query(conn, "select * from blah where ? = ?", handler, "unit",
"test");
+
+    	verify(stmt, times(1)).executeQuery();
+    	verify(results, times(1)).close();
+    	verify(stmt, times(1)).close();	// make sure we closed the statement
+    	verify(conn, times(0)).close();	// make sure we closed the connection
+
+    	// call the other variation of query
+    	when(meta.getParameterCount()).thenReturn(0);
+    	ret = runner.query(conn, "select * from blah", handler);
+
+    	verify(stmt, times(2)).executeQuery();
+    	verify(results, times(2)).close();
+    	verify(stmt, times(2)).close();	// make sure we closed the statement
+    	verify(conn, times(0)).close();	// make sure we closed the connection
+    }
+    
+    private void callGoodQuery() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	Object[] ret = runner.query("select * from blah where ? = ?", handler, "unit", "test");
+
+    	verify(stmt, times(1)).executeQuery();
+    	verify(results, times(1)).close();
+    	verify(stmt, times(1)).close();	// make sure we closed the statement
+    	verify(conn, times(1)).close();	// make sure we closed the connection
+
+    	// call the other variation of query
+    	when(meta.getParameterCount()).thenReturn(0);
+    	ret = runner.query("select * from blah", handler);
+
+    	verify(stmt, times(2)).executeQuery();
+    	verify(results, times(2)).close();
+    	verify(stmt, times(2)).close();	// make sure we closed the statement
+    	verify(conn, times(2)).close();	// make sure we closed the connection
+    }
+    
+    @Test
+    public void testGoodQuery() throws Exception {
+    	callGoodQuery();
+    }
+    
+    @Test
+    public void testGoodQueryPmdTrue() throws Exception {
+    	runner = new QueryRunner(true);
+    	callGoodQuery(conn);
+    }
+    
+    @Test
+    public void testGoodQueryDefaultConstructor() throws Exception {
+    	runner = new QueryRunner();
+    	callGoodQuery(conn);
+    }
+    
+
+    // helper method for calling batch when an exception is expected
+    private void callQueryWithException(Object... params) throws Exception {
+    	Object[] ret = null;
+    	boolean caught = false;
+    	
+    	try {
+        	when(meta.getParameterCount()).thenReturn(2);
+    		ret = runner.query("select * from blah where ? = ?", handler, params);
+
+    		verify(stmt, never()).close();	// make sure the statement is still open
+        	verify(stmt, times(1)).executeQuery();
+        	verify(results, times(1)).close();
+        	verify(stmt, times(1)).close();	// make sure we closed the statement
+        	verify(conn, times(1)).close();	// make sure we closed the connection
+    	} catch(SQLException e) {
+    		caught = true;
+    	}
+    	
+    	if(!caught)
+    		fail("Exception never thrown, but expected");
+    }
+
+    @Test
+    public void testNoParamsQuery() throws Exception {
+    	callQueryWithException();
+    }
+    
+    @Test
+    public void testTooFewParamsQuery() throws Exception {
+    	callQueryWithException("unit");
+    }
+
+    @Test
+    public void testTooManyParamsQuery() throws Exception {
+    	callQueryWithException("unit", "test", "fail");
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullConnectionQuery() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	when(dataSource.getConnection()).thenReturn(null);
+    	
+    	runner.query("select * from blah where ? = ?", handler, "unit", "test");
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullSqlQuery() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	
+    	runner.query(null, handler);
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullHandlerQuery() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	
+    	runner.query("select * from blah where ? = ?", null);
+    }
+
+    @Test
+    public void testExecuteQueryException() throws Exception {
+    	doThrow(new SQLException()).when(stmt).executeQuery();
+    	
+    	callQueryWithException(handler, "unit", "test");
+    }
+
+
+    //
+    // Update test cases
+    //
+    private void callGoodUpdate(Connection conn) throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	Integer ret = runner.update(conn, "update blah set ? = ?", "unit", "test");
+
+    	verify(stmt, times(1)).executeUpdate();
+    	verify(stmt, times(1)).close();	// make sure we closed the statement
+    	verify(conn, times(0)).close();	// make sure we closed the connection
+
+    	// call the other variation
+    	when(meta.getParameterCount()).thenReturn(0);
+    	ret = runner.update(conn, "update blah set unit = test");
+
+    	verify(stmt, times(2)).executeUpdate();
+    	verify(stmt, times(2)).close();	// make sure we closed the statement
+    	verify(conn, times(0)).close();	// make sure we closed the connection
+
+    	// call the other variation
+    	when(meta.getParameterCount()).thenReturn(1);
+    	ret = runner.update(conn, "update blah set unit = ?", "test");
+
+    	verify(stmt, times(3)).executeUpdate();
+    	verify(stmt, times(3)).close();	// make sure we closed the statement
+    	verify(conn, times(0)).close();	// make sure we closed the connection
+    }
     
-    static final Method getParameterCount, getParameterType, getParameterMetaData;
-    static {
-        try {
-            getParameterCount = ParameterMetaData.class.getMethod("getParameterCount", new
Class[0]);
-            getParameterType = ParameterMetaData.class.getMethod("getParameterType", new
Class[]{int.class});
-            getParameterMetaData = PreparedStatement.class.getMethod("getParameterMetaData",
new Class[0]);
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
-    }
-    
-    @Override
-    public void setUp() {
-        runner = new QueryRunner();
-        stmt = fakePreparedStatement();
-    }
-    
-    public void testFillStatementWithNull() throws Exception {
-        stmt = fakeFillablePreparedStatement(false, new int[] {Types.VARCHAR, Types.BIGINT});
-        runner.fillStatement(stmt, new Object[] { null, null }); 
-    }
-    
-    public void testFillStatementWithNullOracle() throws Exception {
-        stmt = fakeFillablePreparedStatement(true, new int[] {Types.VARCHAR, Types.BIGINT});
-        runner.fillStatement(stmt, new Object[] { null, null });
-    }
-
-    private PreparedStatement fakeFillablePreparedStatement(final boolean simulateOracle,
final int[] types) throws NoSuchMethodException {
-        // prepare a mock ParameterMetaData and a mock PreparedStatement to return the PMD
-        final ParameterMetaData pmd = mockParameterMetaData(simulateOracle,types);
-        InvocationHandler stmtHandler = new InvocationHandler() {
-            public Object invoke(Object proxy, Method method, Object[] args)
-                    throws Throwable {
-                if (getParameterMetaData.equals(method)) {
-                    return pmd;
-                }
-                return null;
-            }
-        };
-        return ProxyFactory.instance().createPreparedStatement(stmtHandler);
-    }
-
-    private ParameterMetaData mockParameterMetaData(final boolean simulateOracle, final int[]
types) {
-        InvocationHandler pmdHandler = new InvocationHandler() {
-            public Object invoke(Object proxy, Method method, Object[] args)
-                    throws Throwable {
-                if (getParameterCount.equals(method)) {
-                    return Integer.valueOf(types.length);
-                }
-                if (getParameterType.equals(method)) {
-                    if (simulateOracle) throw new SQLException("Oracle fails when you call
getParameterType");
-                    int arg = ((Integer)args[0]).intValue();
-                    return Integer.valueOf(types[arg-1]);
-                }
-                return null;
-            }
-        };
-        
-        return (ParameterMetaData) Proxy.newProxyInstance(
-                pmdHandler.getClass().getClassLoader(),
-                new Class[] {ParameterMetaData.class},
-                pmdHandler);
-    }
-    
-    public void testFillStatementWithBean() throws SQLException {
-        TestBean tb = new TestBean();
-        tb.setOne("uno");
-        tb.setTwo("dos");
-        tb.setThree("tres");
-        NoOpFillStatement fakeQueryRunner = new NoOpFillStatement();
-        fakeQueryRunner.fillStatementWithBean(stmt, tb, new String[] {"three", "two", "one"});
-        String[] expected = new String[] {"tres", "dos", "uno"};
-        assertArrayEquals("Statement filled with incorrect parameters", expected, fakeQueryRunner.params);
-    }
-
-    private PreparedStatement fakePreparedStatement() {
-        InvocationHandler noOpHandler = new InvocationHandler() {
-            public Object invoke(Object proxy, Method method, Object[] args)
-                    throws Throwable {
-                return null;
-            }
-        };
-        PreparedStatement stmt = ProxyFactory.instance().createPreparedStatement(noOpHandler);
-        return stmt;
-    }
-    
-    public void testFillStatementWithBeanErrorNoReadMethod() throws Exception {
-        TestBean tb = new TestBean();
-        PropertyDescriptor noReadMethod = new PropertyDescriptor("one", TestBean.class, null,
"setOne");
-        
-        PropertyDescriptor properties[] = new PropertyDescriptor[] { noReadMethod };
-        try {
-            runner.fillStatementWithBean(stmt, tb, properties);
-            fail("Expected RuntimeException: tried to use a property with no read method");
-        } catch (RuntimeException expected) {}
-    }
-    
-    public void testFillStatementWithBeanErrorBadReadMethod() throws Exception {
-        PropertyDescriptor badReadMethod = new IndexedPropertyDescriptor("indexed", getClass(),
null, null, "getIndexed", null) {
-            @Override
-            public synchronized Method getReadMethod() {
-                return super.getIndexedReadMethod();
-            }
-        };
-        PropertyDescriptor properties[] = new PropertyDescriptor[] { badReadMethod };
-        try {
-            runner.fillStatementWithBean(stmt, this, properties);
-            fail("Expected RuntimeException: tried to use a property with no no-arg read
method");
-        } catch (RuntimeException expected) {}
-    }
-    
-    public void testFillStatementWithBeanErrorReadMethodThrows() throws Exception {
-        PropertyDescriptor badReadMethod = new PropertyDescriptor("throwsException", getClass(),
"getThrowsException", null);
-        PropertyDescriptor properties[] = new PropertyDescriptor[] { badReadMethod };
-        try {
-            runner.fillStatementWithBean(stmt, this, properties);
-            fail("Expected RuntimeException: tried to call a method that throws");
-        } catch (RuntimeException expected) {}
-    }
-    
-    public void testFillStatementWithBeanErrorReadMethodPrivate() throws Exception {
-        getPrivate();
-        PropertyDescriptor badReadMethod = new BadPrivatePropertyDescriptor();
-        PropertyDescriptor properties[] = new PropertyDescriptor[] { badReadMethod };
-        try {
-            runner.fillStatementWithBean(stmt, this, properties);
-            fail("Expected RuntimeException: tried to call a private method");
-        } catch (RuntimeException expected) {}
-    }
-    
-    class BadPrivatePropertyDescriptor extends PropertyDescriptor {
-        Method getPrivate;
-        BadPrivatePropertyDescriptor() throws Exception {
-            super("throwsException", QueryRunnerTest.class, "getThrowsException", null);
-            getPrivate = QueryRunnerTest.class.getDeclaredMethod("getPrivate", new Class[0]);
-        }
-        
-        @Override
-        public synchronized Method getReadMethod() {
-            if (getPrivate == null) return super.getReadMethod();
-            return getPrivate;
-        }
-    }
-    
-    public void testRethrowNullMessage() {
-        // DBUTILS-40
-        SQLException sqe = new SQLException((String)null);
-        QueryRunner qr = new QueryRunner();
-        try {
-            qr.rethrow(sqe, "foo", new Object[] {"bar"});
-            fail("rethrow didn't throw");
-        } catch (SQLException expected) {}
-    }
-    
-    // indexed bean property
-    public String getIndexed(int index) {
-        return null;
-    }
-    
-    public String getThrowsException() {
-        throw new RuntimeException("this getter always throws an exception");
-    }
-    
-    private String getPrivate() {
-        return null;
-    }
-    
-    private void assertArrayEquals(String message, Object[] expected, Object[] actual) {
-        assertEquals(message, Arrays.asList(expected).toString(), Arrays.asList(actual).toString());
-        assertEquals(message, expected.length, actual.length);
-    }
-    
-    
-    private class NoOpFillStatement extends QueryRunner {
-        Object[] params;
-        @Override
-        public void fillStatement(PreparedStatement stmt, Object... params)
-                throws SQLException {
-            this.params = params;
-        }
+    private void callGoodUpdate() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	Integer ret = runner.update("update blah set ? = ?", "unit", "test");
+
+    	verify(stmt, times(1)).executeUpdate();
+    	verify(stmt, times(1)).close();	// make sure we closed the statement
+    	verify(conn, times(1)).close();	// make sure we closed the connection
+
+    	// call the other variation
+    	when(meta.getParameterCount()).thenReturn(0);
+    	ret = runner.update("update blah set unit = test");
+
+    	verify(stmt, times(2)).executeUpdate();
+    	verify(stmt, times(2)).close();	// make sure we closed the statement
+    	verify(conn, times(2)).close();	// make sure we closed the connection
+
+    	// call the other variation
+    	when(meta.getParameterCount()).thenReturn(1);
+    	ret = runner.update("update blah set unit = ?", "test");
+
+    	verify(stmt, times(3)).executeUpdate();
+    	verify(stmt, times(3)).close();	// make sure we closed the statement
+    	verify(conn, times(3)).close();	// make sure we closed the connection
+    }
+    
+    @Test
+    public void testGoodUpdate() throws Exception {
+    	callGoodUpdate();
+    }
+    
+    @Test
+    public void testGoodUpdatePmdTrue() throws Exception {
+    	runner = new QueryRunner(true);
+    	callGoodUpdate(conn);
+    }
+
+    @Test
+    public void testGoodUpdateDefaultConstructor() throws Exception {
+    	runner = new QueryRunner();
+    	callGoodUpdate(conn);
+    }
+
+    // helper method for calling batch when an exception is expected
+    private void callUpdateWithException(Object... params) throws Exception {
+    	Integer ret = null;
+    	boolean caught = false;
+    	
+    	try {
+    		when(meta.getParameterCount()).thenReturn(2);
+    		ret = runner.update("select * from blah where ? = ?", params);
+
+        	verify(stmt, times(1)).executeUpdate();
+        	verify(stmt, times(1)).close();	// make sure we closed the statement
+        	verify(conn, times(1)).close();	// make sure we closed the connection
+    	} catch(SQLException e) {
+    		caught = true;
+    	}
+    	
+    	if(!caught)
+    		fail("Exception never thrown, but expected");
+    }
+
+    @Test
+    public void testNoParamsUpdate() throws Exception {
+    	callUpdateWithException();
     }
 
+    @Test
+    public void testTooFewParamsUpdate() throws Exception {
+    	callUpdateWithException("unit");
+    }
+
+    @Test
+    public void testTooManyParamsUpdate() throws Exception {
+    	callUpdateWithException("unit", "test", "fail");
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullConnectionUpdate() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	when(dataSource.getConnection()).thenReturn(null);
+    	
+    	runner.update("select * from blah where ? = ?", "unit", "test");
+    }
+
+    @Test(expected=SQLException.class)
+    public void testNullSqlUpdate() throws Exception {
+    	when(meta.getParameterCount()).thenReturn(2);
+    	
+    	runner.update(null);
+    }
+
+    @Test
+    public void testExecuteUpdateException() throws Exception {
+    	doThrow(new SQLException()).when(stmt).executeUpdate();
+    	
+    	callUpdateWithException("unit", "test");
+    }
+    
+    //
+    // Random tests
+    //
+    class MyBean {
+    	private int a;
+    	private double b;
+    	private String c;
+    	
+		public int getA() {	return a; }
+		public void setA(int a) { this.a = a; }
+		public double getB() { return b; }
+		public void setB(double b) { this.b = b; }
+		public String getC() { return c; }
+		public void setC(String c) { this.c = c; }
+    }
+    
+    @Test
+    public void testFillStatementWithBean() throws Exception {
+    	MyBean bean = new MyBean();
+    	when(meta.getParameterCount()).thenReturn(3);
+    	runner.fillStatementWithBean(stmt, bean, new String[] { "a", "b", "c" });
+    }
+    
+    @Test(expected=NullPointerException.class)
+    public void testFillStatementWithBeanNullNames() throws Exception {
+    	MyBean bean = new MyBean();
+    	when(meta.getParameterCount()).thenReturn(3);
+    	runner.fillStatementWithBean(stmt, bean, new String[] { "a", "b", null });
+    }
+    
+    @Test(expected=SQLException.class)
+    public void testBadPrepareConnection() throws Exception {
+    	runner = new QueryRunner();
+    	runner.update("update blah set unit = test");
+    }
 }



Mime
View raw message