You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2018/05/04 20:26:34 UTC
[2/2] commons-dbutils git commit: [DBUTILS-139] Update Java
requirement from version 6 to 7. Remove redundant specification of type
arguments.
[DBUTILS-139] Update Java requirement from version 6 to 7. Remove
redundant specification of type arguments.
Project: http://git-wip-us.apache.org/repos/asf/commons-dbutils/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-dbutils/commit/d484a72e
Tree: http://git-wip-us.apache.org/repos/asf/commons-dbutils/tree/d484a72e
Diff: http://git-wip-us.apache.org/repos/asf/commons-dbutils/diff/d484a72e
Branch: refs/heads/master
Commit: d484a72ebbb7153b8447fc0c1acc12ab537b1bc5
Parents: 1412385
Author: Gary Gregory <ga...@gmail.com>
Authored: Fri May 4 14:26:30 2018 -0600
Committer: Gary Gregory <ga...@gmail.com>
Committed: Fri May 4 14:26:30 2018 -0600
----------------------------------------------------------------------
.../dbutils/BaseResultSetHandlerTest.java | 4 +-
.../commons/dbutils/BeanProcessorTest.java | 2 +-
.../commons/dbutils/OutParameterTest.java | 4 +-
.../apache/commons/dbutils/QueryRunnerTest.java | 2072 +++++++++---------
.../dbutils/handlers/BeanHandlerTest.java | 4 +-
.../dbutils/handlers/BeanListHandlerTest.java | 4 +-
.../dbutils/handlers/BeanMapHandlerTest.java | 10 +-
.../dbutils/handlers/ColumnListHandlerTest.java | 8 +-
.../dbutils/handlers/KeyedHandlerTest.java | 8 +-
.../dbutils/handlers/ScalarHandlerTest.java | 8 +-
10 files changed, 1062 insertions(+), 1062 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java b/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java
index 569a591..e37422f 100644
--- a/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java
+++ b/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java
@@ -51,10 +51,10 @@ public final class BaseResultSetHandlerTest extends BaseTestCase {
@Override
protected Collection<Map<String, Object>> handle() throws SQLException {
- Collection<Map<String, Object>> result = new LinkedList<Map<String, Object>>();
+ Collection<Map<String, Object>> result = new LinkedList<>();
while (next()) {
- Map<String, Object> current = new HashMap<String, Object>();
+ Map<String, Object> current = new HashMap<>();
for (int i = 1; i <= getMetaData().getColumnCount(); i++) {
current.put(getMetaData().getColumnName(i), getObject(i));
http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java b/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java
index d73eca4..cb591a2 100644
--- a/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java
+++ b/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java
@@ -114,7 +114,7 @@ public class BeanProcessorTest extends BaseTestCase {
}
public void testMapColumnToPropertiesWithOverrides() throws Exception {
- Map<String, String> columnToPropertyOverrides = new HashMap<String, String>();
+ Map<String, String> columnToPropertyOverrides = new HashMap<>();
columnToPropertyOverrides.put("five", "four");
BeanProcessor beanProc = new BeanProcessor(columnToPropertyOverrides);
String[] columnNames = { "test", "test", "three", "five" };
http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/OutParameterTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils/OutParameterTest.java b/src/test/java/org/apache/commons/dbutils/OutParameterTest.java
index 967c6e6..657a555 100644
--- a/src/test/java/org/apache/commons/dbutils/OutParameterTest.java
+++ b/src/test/java/org/apache/commons/dbutils/OutParameterTest.java
@@ -42,7 +42,7 @@ public class OutParameterTest {
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); // init the mocks
- parameter = new OutParameter<Number>(Types.INTEGER, Number.class);
+ parameter = new OutParameter<>(Types.INTEGER, Number.class);
}
@Test
@@ -68,7 +68,7 @@ public class OutParameterTest {
@Test
public void testRegisterAlternateConstructor() throws Exception {
- parameter = new OutParameter<Number>(Types.INTEGER, Number.class, VALUE);
+ parameter = new OutParameter<>(Types.INTEGER, Number.class, VALUE);
parameter.register(stmt, INDEX);
verify(stmt, times(1)).registerOutParameter(INDEX, Types.INTEGER);
verify(stmt, times(1)).setObject(INDEX, VALUE);
http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java b/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java
index 7d60b0f..ec8778c 100644
--- a/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java
+++ b/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java
@@ -1,1036 +1,1036 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.dbutils;
-
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-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.CallableStatement;
-import java.sql.Connection;
-import java.sql.ParameterMetaData;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.ResultSetMetaData;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.sql.Types;
-import java.util.ArrayList;
-import java.util.List;
-
-import javax.sql.DataSource;
-
-import org.apache.commons.dbutils.handlers.ArrayHandler;
-import org.apache.commons.dbutils.handlers.ScalarHandler;
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-@SuppressWarnings("boxing") // test code
-public class QueryRunnerTest {
- QueryRunner runner;
- ArrayHandler handler;
-
- @Mock DataSource dataSource;
- @Mock Connection conn;
- @Mock PreparedStatement stmt;
- @Mock CallableStatement call;
- @Mock ParameterMetaData meta;
- @Mock ResultSet results;
- @Mock ResultSetMetaData resultsMeta;
-
- @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(conn.prepareCall(any(String.class))).thenReturn(call);
- when(call.getParameterMetaData()).thenReturn(meta);
- when(call.getResultSet()).thenReturn(results);
- when(call.getMoreResults()).thenReturn(false);
- 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);
- 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 do not close the connection, since QueryRunner.batch(Connection, String, Object[][]) does not close connections
- }
-
- private void callGoodBatch(Object[][] params) throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
- 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 {
- boolean caught = false;
-
- try {
- 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);
- 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 do not close the connection, since QueryRunner.query(Connection, String, ResultSetHandler<T>, Object...) does not close connections
-
- // call the other variation of query
- when(meta.getParameterCount()).thenReturn(0);
- 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 do not close the connection, see above
- }
-
- private void callGoodQuery() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
- 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);
- 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 {
- boolean caught = false;
-
- try {
- when(meta.getParameterCount()).thenReturn(2);
- 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);
- 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 do not close the connection, since QueryRunner.update(Connection, String, Object...) does not close connections
-
- // call the other variation
- when(meta.getParameterCount()).thenReturn(0);
- 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 do not close the connection, see above
-
- // call the other variation
- when(meta.getParameterCount()).thenReturn(1);
- 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 do not close the connection, see above
- }
-
- private void callGoodUpdate() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
- 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);
- 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);
- 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);
- }
-
- @Test
- public void testGoodInsert() throws Exception {
- results = mock(ResultSet.class);
-
- when(meta.getParameterCount()).thenReturn(2);
- when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt);
- when(stmt.getGeneratedKeys()).thenReturn(results);
- when(results.next()).thenReturn(true).thenReturn(false);
- when(results.getObject(1)).thenReturn(1L);
-
- Long generatedKey = runner.insert("INSERT INTO blah(col1, col2) VALUES(?,?)", new ScalarHandler<Long>(), "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
-
- Assert.assertEquals(1L, generatedKey.longValue());
- }
-
- @Test
- public void testGoodBatchInsert() throws Exception {
- results = mock(ResultSet.class);
- resultsMeta = mock(ResultSetMetaData.class);
-
- when(meta.getParameterCount()).thenReturn(2);
- when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt);
- when(stmt.getGeneratedKeys()).thenReturn(results);
- when(results.next()).thenReturn(true).thenReturn(true).thenReturn(false);
- when(results.getMetaData()).thenReturn(resultsMeta);
- when(resultsMeta.getColumnCount()).thenReturn(1);
-
- ResultSetHandler<List<Object>> handler = new ResultSetHandler<List<Object>>()
- {
- @Override
- public List<Object> handle(ResultSet rs) throws SQLException
- {
- List<Object> objects = new ArrayList<Object>();
- while (rs.next())
- {
- objects.add(new Object());
- }
- return objects;
- }
- };
-
- Object[][] params = new Object[2][2];
- params[0][0] = "Test";
- params[0][1] = "Blah";
- params[1][0] = "Test2";
- params[1][1] = "Blah2";
-
- List<Object> generatedKeys = runner.insertBatch("INSERT INTO blah(col1, col2) VALUES(?,?)", handler, 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
-
- Assert.assertEquals(2, generatedKeys.size());
- }
-
- // helper method for calling batch when an exception is expected
- private void callUpdateWithException(Object... params) throws Exception {
- boolean caught = false;
-
- try {
- when(meta.getParameterCount()).thenReturn(2);
- 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");
- }
-
- @Test
- public void testStatementConfiguration() throws Exception {
- StatementConfiguration stmtConfig = new StatementConfiguration(1, 2, 3, 4, 5);
- QueryRunner queryRunner = new QueryRunner(stmtConfig);
- queryRunner.prepareStatement(conn, "select 1");
-
- verify(stmt).setFetchDirection(eq(1));
- verify(stmt).setFetchSize(eq(2));
- verify(stmt).setMaxFieldSize(eq(3));
- verify(stmt).setMaxRows(eq(4));
- verify(stmt).setQueryTimeout(eq(5));
- }
-
- //
- // Execute tests
- //
- private void callGoodExecute(Connection conn) throws Exception {
- when(call.execute()).thenReturn(false);
- when(call.getUpdateCount()).thenReturn(3);
-
- when(meta.getParameterCount()).thenReturn(2);
- int result = runner.execute(conn, "{call my_proc(?, ?)}", "unit", "test");
-
- Assert.assertEquals(3, result);
-
- verify(call, times(1)).execute();
- verify(call, times(1)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // call the other variation of query
- when(meta.getParameterCount()).thenReturn(0);
- result = runner.execute(conn, "{call my_proc()}");
-
- Assert.assertEquals(3, result);
-
- verify(call, times(2)).execute();
- verify(call, times(2)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // Test single OUT parameter
- when(meta.getParameterCount()).thenReturn(1);
- when(call.getObject(1)).thenReturn(42);
- OutParameter<Integer> intParam =
- new OutParameter<Integer>(Types.INTEGER, Integer.class);
- result = runner.execute(conn, "{?= call my_proc()}", intParam);
-
- Assert.assertEquals(42, intParam.getValue().intValue());
- Assert.assertEquals(3, result);
-
- verify(call, times(3)).execute();
- verify(call, times(3)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // Test OUT parameters with IN parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(4242);
- intParam.setValue(null);
- result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "unit", "test");
-
- Assert.assertEquals(4242, intParam.getValue().intValue());
- Assert.assertEquals(3, result);
-
- verify(call, times(4)).execute();
- verify(call, times(4)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // Test INOUT parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(24);
- when(call.getObject(3)).thenReturn("out");
- intParam.setValue(null);
- OutParameter<String> stringParam =
- new OutParameter<String>(Types.VARCHAR, String.class, "in");
- result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "test", stringParam);
-
- Assert.assertEquals(24, intParam.getValue().intValue());
- Assert.assertEquals("out", stringParam.getValue());
- Assert.assertEquals(3, result);
-
- verify(call, times(5)).execute();
- verify(call, times(5)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
- }
-
- private void callGoodExecute() throws Exception {
- when(call.execute()).thenReturn(false);
- when(call.getUpdateCount()).thenReturn(3);
-
- when(meta.getParameterCount()).thenReturn(2);
- int result = runner.execute("{call my_proc(?, ?)}", "unit", "test");
-
- Assert.assertEquals(3, result);
-
- verify(call, times(1)).execute();
- verify(call, times(1)).close(); // make sure we closed the statement
- verify(conn, times(1)).close(); // make sure we do not close the connection
-
- // call the other variation of query
- when(meta.getParameterCount()).thenReturn(0);
- result = runner.execute("{call my_proc()}");
-
- Assert.assertEquals(3, result);
-
- verify(call, times(2)).execute();
- verify(call, times(2)).close(); // make sure we closed the statement
- verify(conn, times(2)).close(); // make sure we do not close the connection
-
- // Test single OUT parameter
- when(meta.getParameterCount()).thenReturn(1);
- when(call.getObject(1)).thenReturn(42);
- OutParameter<Integer> intParam =
- new OutParameter<Integer>(Types.INTEGER, Integer.class);
- result = runner.execute("{?= call my_proc()}", intParam);
-
- Assert.assertEquals(42, intParam.getValue().intValue());
- Assert.assertEquals(3, result);
-
- verify(call, times(3)).execute();
- verify(call, times(3)).close(); // make sure we closed the statement
- verify(conn, times(3)).close(); // make sure we do not close the connection
-
- // Test OUT parameters with IN parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(4242);
- intParam.setValue(null);
- result = runner.execute("{?= call my_proc(?, ?)}", intParam, "unit", "test");
-
- Assert.assertEquals(4242, intParam.getValue().intValue());
- Assert.assertEquals(3, result);
-
- verify(call, times(4)).execute();
- verify(call, times(4)).close(); // make sure we closed the statement
- verify(conn, times(4)).close(); // make sure we do not close the connection
-
- // Test INOUT parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(24);
- when(call.getObject(3)).thenReturn("out");
- intParam.setValue(null);
- OutParameter<String> stringParam =
- new OutParameter<String>(Types.VARCHAR, String.class, "in");
- result = runner.execute("{?= call my_proc(?, ?)}", intParam, "test", stringParam);
-
- Assert.assertEquals(24, intParam.getValue().intValue());
- Assert.assertEquals("out", stringParam.getValue());
- Assert.assertEquals(3, result);
-
- verify(call, times(5)).execute();
- verify(call, times(5)).close(); // make sure we closed the statement
- verify(conn, times(5)).close(); // make sure we do not close the connection
- }
-
- @Test
- public void testGoodExecute() throws Exception {
- callGoodExecute();
- }
-
- @Test
- public void testGoodExecutePmdTrue() throws Exception {
- runner = new QueryRunner(true);
- callGoodExecute(conn);
- }
-
- @Test
- public void testGoodExecuteDefaultConstructor() throws Exception {
- runner = new QueryRunner();
- callGoodExecute(conn);
- }
-
- // helper method for calling execute when an exception is expected
- private void callExecuteWithException(Object... params) throws Exception {
- boolean caught = false;
-
- try {
- when(call.execute()).thenReturn(false);
- when(meta.getParameterCount()).thenReturn(2);
- runner.query("{call my_proc(?, ?)}", handler, params);
-
- } catch(SQLException e) {
- caught = true;
- }
-
- if(!caught) {
- fail("Exception never thrown, but expected");
- }
- }
-
- @Test
- public void testNoParamsExecute() throws Exception {
- callExecuteWithException();
- }
-
- @Test
- public void testTooFewParamsExecute() throws Exception {
- callExecuteWithException("unit");
- }
-
- @Test
- public void testTooManyParamsExecute() throws Exception {
- callExecuteWithException("unit", "test", "fail");
- }
-
- @Test(expected=SQLException.class)
- public void testNullConnectionExecute() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
- when(dataSource.getConnection()).thenReturn(null);
-
- runner.execute("{call my_proc(?, ?)}", "unit", "test");
- }
-
- @Test(expected=SQLException.class)
- public void testNullSqlExecute() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
-
- runner.execute(null);
- }
-
- @Test(expected=SQLException.class)
- public void testNullHandlerExecute() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
-
- runner.execute("{call my_proc(?, ?)}");
- }
-
- @Test
- public void testExecuteException() throws Exception {
- doThrow(new SQLException()).when(stmt).execute();
-
- callExecuteWithException(handler, "unit", "test");
- }
-
- //
- // Execute with ResultSetHandler
- //
-
- @Test
- public void testExecuteWithMultipleResultSets() throws Exception {
- when(call.execute()).thenReturn(true);
- when(call.getMoreResults()).thenAnswer(new Answer<Boolean>()
- {
- int count = 1;
- @Override
- public Boolean answer(InvocationOnMock invocation)
- {
- return ++count <= 3;
- }
- });
- when(meta.getParameterCount()).thenReturn(0);
- List<Object[]> objects = runner.execute("{call my_proc()}", handler);
-
- Assert.assertEquals(3, objects.size());
- verify(call, times(1)).execute();
- verify(results, times(3)).close();
- verify(call, times(1)).close(); // make sure we closed the statement
- verify(conn, times(1)).close(); // make sure we close the connection
-
- }
-
- private void callGoodExecuteWithResultSet(Connection conn) throws Exception {
- when(call.execute()).thenReturn(true);
-
- when(meta.getParameterCount()).thenReturn(2);
- runner.execute(conn, "{call my_proc(?, ?)}", handler, "unit", "test");
-
- verify(call, times(1)).execute();
- verify(results, times(1)).close();
- verify(call, times(1)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // call the other variation of query
- when(meta.getParameterCount()).thenReturn(0);
- runner.execute(conn, "{call my_proc()}", handler);
-
- verify(call, times(2)).execute();
- verify(results, times(2)).close();
- verify(call, times(2)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // Test single OUT parameter
- when(meta.getParameterCount()).thenReturn(1);
- when(call.getObject(1)).thenReturn(42);
- OutParameter<Integer> intParam =
- new OutParameter<Integer>(Types.INTEGER, Integer.class);
- runner.execute(conn, "{?= call my_proc()}", handler, intParam);
-
- Assert.assertEquals(42, intParam.getValue().intValue());
-
- verify(call, times(3)).execute();
- verify(results, times(3)).close();
- verify(call, times(3)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // Test OUT parameters with IN parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(4242);
- intParam.setValue(null);
- runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "unit", "test");
-
- Assert.assertEquals(4242, intParam.getValue().intValue());
-
- verify(call, times(4)).execute();
- verify(results, times(4)).close();
- verify(call, times(4)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
-
- // Test INOUT parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(24);
- when(call.getObject(3)).thenReturn("out");
- intParam.setValue(null);
- OutParameter<String> stringParam =
- new OutParameter<String>(Types.VARCHAR, String.class, "in");
- runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam);
-
- Assert.assertEquals(24, intParam.getValue().intValue());
- Assert.assertEquals("out", stringParam.getValue());
-
- verify(call, times(5)).execute();
- verify(results, times(5)).close();
- verify(call, times(5)).close(); // make sure we closed the statement
- verify(conn, times(0)).close(); // make sure we do not close the connection
- }
-
- private void callGoodExecuteWithResultSet() throws Exception {
- when(call.execute()).thenReturn(true);
-
- when(meta.getParameterCount()).thenReturn(2);
- runner.execute("{call my_proc(?, ?)}", handler, "unit", "test");
-
- verify(call, times(1)).execute();
- verify(results, times(1)).close();
- verify(call, times(1)).close(); // make sure we closed the statement
- verify(conn, times(1)).close(); // make sure we do not close the connection
-
- // call the other variation of query
- when(meta.getParameterCount()).thenReturn(0);
- runner.execute("{call my_proc()}", handler);
-
- verify(call, times(2)).execute();
- verify(results, times(2)).close();
- verify(call, times(2)).close(); // make sure we closed the statement
- verify(conn, times(2)).close(); // make sure we do not close the connection
-
- // Test single OUT parameter
- when(meta.getParameterCount()).thenReturn(1);
- when(call.getObject(1)).thenReturn(42);
- OutParameter<Integer> intParam =
- new OutParameter<Integer>(Types.INTEGER, Integer.class);
- runner.execute("{?= call my_proc()}", handler, intParam);
-
- Assert.assertEquals(42, intParam.getValue().intValue());
-
- verify(call, times(3)).execute();
- verify(results, times(3)).close();
- verify(call, times(3)).close(); // make sure we closed the statement
- verify(conn, times(3)).close(); // make sure we do not close the connection
-
- // Test OUT parameters with IN parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(4242);
- intParam.setValue(null);
- runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "unit", "test");
-
- Assert.assertEquals(4242, intParam.getValue().intValue());
-
- verify(call, times(4)).execute();
- verify(results, times(4)).close();
- verify(call, times(4)).close(); // make sure we closed the statement
- verify(conn, times(4)).close(); // make sure we do not close the connection
-
- // Test INOUT parameters
- when(meta.getParameterCount()).thenReturn(3);
- when(call.getObject(1)).thenReturn(24);
- when(call.getObject(3)).thenReturn("out");
- intParam.setValue(null);
- OutParameter<String> stringParam =
- new OutParameter<String>(Types.VARCHAR, String.class, "in");
- runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam);
-
- Assert.assertEquals(24, intParam.getValue().intValue());
- Assert.assertEquals("out", stringParam.getValue());
-
- verify(call, times(5)).execute();
- verify(results, times(5)).close();
- verify(call, times(5)).close(); // make sure we closed the statement
- verify(conn, times(5)).close(); // make sure we do not close the connection
- }
-
- @Test
- public void testGoodExecuteWithResultSet() throws Exception {
- callGoodExecuteWithResultSet();
- }
-
- @Test
- public void testGoodExecuteWithResultSetPmdTrue() throws Exception {
- runner = new QueryRunner(true);
- callGoodExecuteWithResultSet(conn);
- }
-
- @Test
- public void testGoodExecuteWithResultSetDefaultConstructor() throws Exception {
- runner = new QueryRunner();
- callGoodExecuteWithResultSet(conn);
- }
-
- // helper method for calling execute when an exception is expected
- private void callExecuteWithResultSetWithException(Object... params) throws Exception {
- boolean caught = false;
-
- try {
- when(call.execute()).thenReturn(true);
- when(meta.getParameterCount()).thenReturn(2);
- runner.query("{call my_proc(?, ?)}", handler, params);
-
- } catch(SQLException e) {
- caught = true;
- }
-
- if(!caught) {
- fail("Exception never thrown, but expected");
- }
- }
-
- @Test
- public void testNoParamsExecuteWithResultSet() throws Exception {
- callExecuteWithResultSetWithException();
- }
-
- @Test
- public void testTooFewParamsExecuteWithResultSet() throws Exception {
- callExecuteWithResultSetWithException("unit");
- }
-
- @Test
- public void testTooManyParamsExecuteWithResultSet() throws Exception {
- callExecuteWithResultSetWithException("unit", "test", "fail");
- }
-
- @Test(expected=SQLException.class)
- public void testNullConnectionExecuteWithResultSet() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
- when(dataSource.getConnection()).thenReturn(null);
-
- runner.execute("{call my_proc(?, ?)}", handler, "unit", "test");
- }
-
- @Test(expected=SQLException.class)
- public void testNullSqlExecuteWithResultSet() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
-
- runner.execute(null, handler);
- }
-
- @Test(expected=SQLException.class)
- public void testNullHandlerExecuteWithResultSet() throws Exception {
- when(meta.getParameterCount()).thenReturn(2);
-
- runner.execute("{call my_proc(?, ?)}", (ResultSetHandler)null);
- }
-
- @Test
- public void testExecuteWithResultSetException() throws Exception {
- doThrow(new SQLException()).when(stmt).execute();
-
- callExecuteWithResultSetWithException(handler, "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");
- }
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.dbutils;
+
+import static org.junit.Assert.fail;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+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.CallableStatement;
+import java.sql.Connection;
+import java.sql.ParameterMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.sql.DataSource;
+
+import org.apache.commons.dbutils.handlers.ArrayHandler;
+import org.apache.commons.dbutils.handlers.ScalarHandler;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+@SuppressWarnings("boxing") // test code
+public class QueryRunnerTest {
+ QueryRunner runner;
+ ArrayHandler handler;
+
+ @Mock DataSource dataSource;
+ @Mock Connection conn;
+ @Mock PreparedStatement stmt;
+ @Mock CallableStatement call;
+ @Mock ParameterMetaData meta;
+ @Mock ResultSet results;
+ @Mock ResultSetMetaData resultsMeta;
+
+ @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(conn.prepareCall(any(String.class))).thenReturn(call);
+ when(call.getParameterMetaData()).thenReturn(meta);
+ when(call.getResultSet()).thenReturn(results);
+ when(call.getMoreResults()).thenReturn(false);
+ 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);
+ 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 do not close the connection, since QueryRunner.batch(Connection, String, Object[][]) does not close connections
+ }
+
+ private void callGoodBatch(Object[][] params) throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+ 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 {
+ boolean caught = false;
+
+ try {
+ 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);
+ 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 do not close the connection, since QueryRunner.query(Connection, String, ResultSetHandler<T>, Object...) does not close connections
+
+ // call the other variation of query
+ when(meta.getParameterCount()).thenReturn(0);
+ 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 do not close the connection, see above
+ }
+
+ private void callGoodQuery() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+ 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);
+ 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 {
+ boolean caught = false;
+
+ try {
+ when(meta.getParameterCount()).thenReturn(2);
+ 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);
+ 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 do not close the connection, since QueryRunner.update(Connection, String, Object...) does not close connections
+
+ // call the other variation
+ when(meta.getParameterCount()).thenReturn(0);
+ 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 do not close the connection, see above
+
+ // call the other variation
+ when(meta.getParameterCount()).thenReturn(1);
+ 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 do not close the connection, see above
+ }
+
+ private void callGoodUpdate() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+ 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);
+ 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);
+ 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);
+ }
+
+ @Test
+ public void testGoodInsert() throws Exception {
+ results = mock(ResultSet.class);
+
+ when(meta.getParameterCount()).thenReturn(2);
+ when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt);
+ when(stmt.getGeneratedKeys()).thenReturn(results);
+ when(results.next()).thenReturn(true).thenReturn(false);
+ when(results.getObject(1)).thenReturn(1L);
+
+ Long generatedKey = runner.insert("INSERT INTO blah(col1, col2) VALUES(?,?)", new ScalarHandler<Long>(), "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
+
+ Assert.assertEquals(1L, generatedKey.longValue());
+ }
+
+ @Test
+ public void testGoodBatchInsert() throws Exception {
+ results = mock(ResultSet.class);
+ resultsMeta = mock(ResultSetMetaData.class);
+
+ when(meta.getParameterCount()).thenReturn(2);
+ when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt);
+ when(stmt.getGeneratedKeys()).thenReturn(results);
+ when(results.next()).thenReturn(true).thenReturn(true).thenReturn(false);
+ when(results.getMetaData()).thenReturn(resultsMeta);
+ when(resultsMeta.getColumnCount()).thenReturn(1);
+
+ ResultSetHandler<List<Object>> handler = new ResultSetHandler<List<Object>>()
+ {
+ @Override
+ public List<Object> handle(ResultSet rs) throws SQLException
+ {
+ List<Object> objects = new ArrayList<>();
+ while (rs.next())
+ {
+ objects.add(new Object());
+ }
+ return objects;
+ }
+ };
+
+ Object[][] params = new Object[2][2];
+ params[0][0] = "Test";
+ params[0][1] = "Blah";
+ params[1][0] = "Test2";
+ params[1][1] = "Blah2";
+
+ List<Object> generatedKeys = runner.insertBatch("INSERT INTO blah(col1, col2) VALUES(?,?)", handler, 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
+
+ Assert.assertEquals(2, generatedKeys.size());
+ }
+
+ // helper method for calling batch when an exception is expected
+ private void callUpdateWithException(Object... params) throws Exception {
+ boolean caught = false;
+
+ try {
+ when(meta.getParameterCount()).thenReturn(2);
+ 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");
+ }
+
+ @Test
+ public void testStatementConfiguration() throws Exception {
+ StatementConfiguration stmtConfig = new StatementConfiguration(1, 2, 3, 4, 5);
+ QueryRunner queryRunner = new QueryRunner(stmtConfig);
+ queryRunner.prepareStatement(conn, "select 1");
+
+ verify(stmt).setFetchDirection(eq(1));
+ verify(stmt).setFetchSize(eq(2));
+ verify(stmt).setMaxFieldSize(eq(3));
+ verify(stmt).setMaxRows(eq(4));
+ verify(stmt).setQueryTimeout(eq(5));
+ }
+
+ //
+ // Execute tests
+ //
+ private void callGoodExecute(Connection conn) throws Exception {
+ when(call.execute()).thenReturn(false);
+ when(call.getUpdateCount()).thenReturn(3);
+
+ when(meta.getParameterCount()).thenReturn(2);
+ int result = runner.execute(conn, "{call my_proc(?, ?)}", "unit", "test");
+
+ Assert.assertEquals(3, result);
+
+ verify(call, times(1)).execute();
+ verify(call, times(1)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // call the other variation of query
+ when(meta.getParameterCount()).thenReturn(0);
+ result = runner.execute(conn, "{call my_proc()}");
+
+ Assert.assertEquals(3, result);
+
+ verify(call, times(2)).execute();
+ verify(call, times(2)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // Test single OUT parameter
+ when(meta.getParameterCount()).thenReturn(1);
+ when(call.getObject(1)).thenReturn(42);
+ OutParameter<Integer> intParam =
+ new OutParameter<>(Types.INTEGER, Integer.class);
+ result = runner.execute(conn, "{?= call my_proc()}", intParam);
+
+ Assert.assertEquals(42, intParam.getValue().intValue());
+ Assert.assertEquals(3, result);
+
+ verify(call, times(3)).execute();
+ verify(call, times(3)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // Test OUT parameters with IN parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(4242);
+ intParam.setValue(null);
+ result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "unit", "test");
+
+ Assert.assertEquals(4242, intParam.getValue().intValue());
+ Assert.assertEquals(3, result);
+
+ verify(call, times(4)).execute();
+ verify(call, times(4)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // Test INOUT parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(24);
+ when(call.getObject(3)).thenReturn("out");
+ intParam.setValue(null);
+ OutParameter<String> stringParam =
+ new OutParameter<>(Types.VARCHAR, String.class, "in");
+ result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "test", stringParam);
+
+ Assert.assertEquals(24, intParam.getValue().intValue());
+ Assert.assertEquals("out", stringParam.getValue());
+ Assert.assertEquals(3, result);
+
+ verify(call, times(5)).execute();
+ verify(call, times(5)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+ }
+
+ private void callGoodExecute() throws Exception {
+ when(call.execute()).thenReturn(false);
+ when(call.getUpdateCount()).thenReturn(3);
+
+ when(meta.getParameterCount()).thenReturn(2);
+ int result = runner.execute("{call my_proc(?, ?)}", "unit", "test");
+
+ Assert.assertEquals(3, result);
+
+ verify(call, times(1)).execute();
+ verify(call, times(1)).close(); // make sure we closed the statement
+ verify(conn, times(1)).close(); // make sure we do not close the connection
+
+ // call the other variation of query
+ when(meta.getParameterCount()).thenReturn(0);
+ result = runner.execute("{call my_proc()}");
+
+ Assert.assertEquals(3, result);
+
+ verify(call, times(2)).execute();
+ verify(call, times(2)).close(); // make sure we closed the statement
+ verify(conn, times(2)).close(); // make sure we do not close the connection
+
+ // Test single OUT parameter
+ when(meta.getParameterCount()).thenReturn(1);
+ when(call.getObject(1)).thenReturn(42);
+ OutParameter<Integer> intParam =
+ new OutParameter<>(Types.INTEGER, Integer.class);
+ result = runner.execute("{?= call my_proc()}", intParam);
+
+ Assert.assertEquals(42, intParam.getValue().intValue());
+ Assert.assertEquals(3, result);
+
+ verify(call, times(3)).execute();
+ verify(call, times(3)).close(); // make sure we closed the statement
+ verify(conn, times(3)).close(); // make sure we do not close the connection
+
+ // Test OUT parameters with IN parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(4242);
+ intParam.setValue(null);
+ result = runner.execute("{?= call my_proc(?, ?)}", intParam, "unit", "test");
+
+ Assert.assertEquals(4242, intParam.getValue().intValue());
+ Assert.assertEquals(3, result);
+
+ verify(call, times(4)).execute();
+ verify(call, times(4)).close(); // make sure we closed the statement
+ verify(conn, times(4)).close(); // make sure we do not close the connection
+
+ // Test INOUT parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(24);
+ when(call.getObject(3)).thenReturn("out");
+ intParam.setValue(null);
+ OutParameter<String> stringParam =
+ new OutParameter<>(Types.VARCHAR, String.class, "in");
+ result = runner.execute("{?= call my_proc(?, ?)}", intParam, "test", stringParam);
+
+ Assert.assertEquals(24, intParam.getValue().intValue());
+ Assert.assertEquals("out", stringParam.getValue());
+ Assert.assertEquals(3, result);
+
+ verify(call, times(5)).execute();
+ verify(call, times(5)).close(); // make sure we closed the statement
+ verify(conn, times(5)).close(); // make sure we do not close the connection
+ }
+
+ @Test
+ public void testGoodExecute() throws Exception {
+ callGoodExecute();
+ }
+
+ @Test
+ public void testGoodExecutePmdTrue() throws Exception {
+ runner = new QueryRunner(true);
+ callGoodExecute(conn);
+ }
+
+ @Test
+ public void testGoodExecuteDefaultConstructor() throws Exception {
+ runner = new QueryRunner();
+ callGoodExecute(conn);
+ }
+
+ // helper method for calling execute when an exception is expected
+ private void callExecuteWithException(Object... params) throws Exception {
+ boolean caught = false;
+
+ try {
+ when(call.execute()).thenReturn(false);
+ when(meta.getParameterCount()).thenReturn(2);
+ runner.query("{call my_proc(?, ?)}", handler, params);
+
+ } catch(SQLException e) {
+ caught = true;
+ }
+
+ if(!caught) {
+ fail("Exception never thrown, but expected");
+ }
+ }
+
+ @Test
+ public void testNoParamsExecute() throws Exception {
+ callExecuteWithException();
+ }
+
+ @Test
+ public void testTooFewParamsExecute() throws Exception {
+ callExecuteWithException("unit");
+ }
+
+ @Test
+ public void testTooManyParamsExecute() throws Exception {
+ callExecuteWithException("unit", "test", "fail");
+ }
+
+ @Test(expected=SQLException.class)
+ public void testNullConnectionExecute() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+ when(dataSource.getConnection()).thenReturn(null);
+
+ runner.execute("{call my_proc(?, ?)}", "unit", "test");
+ }
+
+ @Test(expected=SQLException.class)
+ public void testNullSqlExecute() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+
+ runner.execute(null);
+ }
+
+ @Test(expected=SQLException.class)
+ public void testNullHandlerExecute() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+
+ runner.execute("{call my_proc(?, ?)}");
+ }
+
+ @Test
+ public void testExecuteException() throws Exception {
+ doThrow(new SQLException()).when(stmt).execute();
+
+ callExecuteWithException(handler, "unit", "test");
+ }
+
+ //
+ // Execute with ResultSetHandler
+ //
+
+ @Test
+ public void testExecuteWithMultipleResultSets() throws Exception {
+ when(call.execute()).thenReturn(true);
+ when(call.getMoreResults()).thenAnswer(new Answer<Boolean>()
+ {
+ int count = 1;
+ @Override
+ public Boolean answer(InvocationOnMock invocation)
+ {
+ return ++count <= 3;
+ }
+ });
+ when(meta.getParameterCount()).thenReturn(0);
+ List<Object[]> objects = runner.execute("{call my_proc()}", handler);
+
+ Assert.assertEquals(3, objects.size());
+ verify(call, times(1)).execute();
+ verify(results, times(3)).close();
+ verify(call, times(1)).close(); // make sure we closed the statement
+ verify(conn, times(1)).close(); // make sure we close the connection
+
+ }
+
+ private void callGoodExecuteWithResultSet(Connection conn) throws Exception {
+ when(call.execute()).thenReturn(true);
+
+ when(meta.getParameterCount()).thenReturn(2);
+ runner.execute(conn, "{call my_proc(?, ?)}", handler, "unit", "test");
+
+ verify(call, times(1)).execute();
+ verify(results, times(1)).close();
+ verify(call, times(1)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // call the other variation of query
+ when(meta.getParameterCount()).thenReturn(0);
+ runner.execute(conn, "{call my_proc()}", handler);
+
+ verify(call, times(2)).execute();
+ verify(results, times(2)).close();
+ verify(call, times(2)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // Test single OUT parameter
+ when(meta.getParameterCount()).thenReturn(1);
+ when(call.getObject(1)).thenReturn(42);
+ OutParameter<Integer> intParam =
+ new OutParameter<>(Types.INTEGER, Integer.class);
+ runner.execute(conn, "{?= call my_proc()}", handler, intParam);
+
+ Assert.assertEquals(42, intParam.getValue().intValue());
+
+ verify(call, times(3)).execute();
+ verify(results, times(3)).close();
+ verify(call, times(3)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // Test OUT parameters with IN parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(4242);
+ intParam.setValue(null);
+ runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "unit", "test");
+
+ Assert.assertEquals(4242, intParam.getValue().intValue());
+
+ verify(call, times(4)).execute();
+ verify(results, times(4)).close();
+ verify(call, times(4)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+
+ // Test INOUT parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(24);
+ when(call.getObject(3)).thenReturn("out");
+ intParam.setValue(null);
+ OutParameter<String> stringParam =
+ new OutParameter<>(Types.VARCHAR, String.class, "in");
+ runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam);
+
+ Assert.assertEquals(24, intParam.getValue().intValue());
+ Assert.assertEquals("out", stringParam.getValue());
+
+ verify(call, times(5)).execute();
+ verify(results, times(5)).close();
+ verify(call, times(5)).close(); // make sure we closed the statement
+ verify(conn, times(0)).close(); // make sure we do not close the connection
+ }
+
+ private void callGoodExecuteWithResultSet() throws Exception {
+ when(call.execute()).thenReturn(true);
+
+ when(meta.getParameterCount()).thenReturn(2);
+ runner.execute("{call my_proc(?, ?)}", handler, "unit", "test");
+
+ verify(call, times(1)).execute();
+ verify(results, times(1)).close();
+ verify(call, times(1)).close(); // make sure we closed the statement
+ verify(conn, times(1)).close(); // make sure we do not close the connection
+
+ // call the other variation of query
+ when(meta.getParameterCount()).thenReturn(0);
+ runner.execute("{call my_proc()}", handler);
+
+ verify(call, times(2)).execute();
+ verify(results, times(2)).close();
+ verify(call, times(2)).close(); // make sure we closed the statement
+ verify(conn, times(2)).close(); // make sure we do not close the connection
+
+ // Test single OUT parameter
+ when(meta.getParameterCount()).thenReturn(1);
+ when(call.getObject(1)).thenReturn(42);
+ OutParameter<Integer> intParam =
+ new OutParameter<>(Types.INTEGER, Integer.class);
+ runner.execute("{?= call my_proc()}", handler, intParam);
+
+ Assert.assertEquals(42, intParam.getValue().intValue());
+
+ verify(call, times(3)).execute();
+ verify(results, times(3)).close();
+ verify(call, times(3)).close(); // make sure we closed the statement
+ verify(conn, times(3)).close(); // make sure we do not close the connection
+
+ // Test OUT parameters with IN parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(4242);
+ intParam.setValue(null);
+ runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "unit", "test");
+
+ Assert.assertEquals(4242, intParam.getValue().intValue());
+
+ verify(call, times(4)).execute();
+ verify(results, times(4)).close();
+ verify(call, times(4)).close(); // make sure we closed the statement
+ verify(conn, times(4)).close(); // make sure we do not close the connection
+
+ // Test INOUT parameters
+ when(meta.getParameterCount()).thenReturn(3);
+ when(call.getObject(1)).thenReturn(24);
+ when(call.getObject(3)).thenReturn("out");
+ intParam.setValue(null);
+ OutParameter<String> stringParam =
+ new OutParameter<>(Types.VARCHAR, String.class, "in");
+ runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam);
+
+ Assert.assertEquals(24, intParam.getValue().intValue());
+ Assert.assertEquals("out", stringParam.getValue());
+
+ verify(call, times(5)).execute();
+ verify(results, times(5)).close();
+ verify(call, times(5)).close(); // make sure we closed the statement
+ verify(conn, times(5)).close(); // make sure we do not close the connection
+ }
+
+ @Test
+ public void testGoodExecuteWithResultSet() throws Exception {
+ callGoodExecuteWithResultSet();
+ }
+
+ @Test
+ public void testGoodExecuteWithResultSetPmdTrue() throws Exception {
+ runner = new QueryRunner(true);
+ callGoodExecuteWithResultSet(conn);
+ }
+
+ @Test
+ public void testGoodExecuteWithResultSetDefaultConstructor() throws Exception {
+ runner = new QueryRunner();
+ callGoodExecuteWithResultSet(conn);
+ }
+
+ // helper method for calling execute when an exception is expected
+ private void callExecuteWithResultSetWithException(Object... params) throws Exception {
+ boolean caught = false;
+
+ try {
+ when(call.execute()).thenReturn(true);
+ when(meta.getParameterCount()).thenReturn(2);
+ runner.query("{call my_proc(?, ?)}", handler, params);
+
+ } catch(SQLException e) {
+ caught = true;
+ }
+
+ if(!caught) {
+ fail("Exception never thrown, but expected");
+ }
+ }
+
+ @Test
+ public void testNoParamsExecuteWithResultSet() throws Exception {
+ callExecuteWithResultSetWithException();
+ }
+
+ @Test
+ public void testTooFewParamsExecuteWithResultSet() throws Exception {
+ callExecuteWithResultSetWithException("unit");
+ }
+
+ @Test
+ public void testTooManyParamsExecuteWithResultSet() throws Exception {
+ callExecuteWithResultSetWithException("unit", "test", "fail");
+ }
+
+ @Test(expected=SQLException.class)
+ public void testNullConnectionExecuteWithResultSet() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+ when(dataSource.getConnection()).thenReturn(null);
+
+ runner.execute("{call my_proc(?, ?)}", handler, "unit", "test");
+ }
+
+ @Test(expected=SQLException.class)
+ public void testNullSqlExecuteWithResultSet() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+
+ runner.execute(null, handler);
+ }
+
+ @Test(expected=SQLException.class)
+ public void testNullHandlerExecuteWithResultSet() throws Exception {
+ when(meta.getParameterCount()).thenReturn(2);
+
+ runner.execute("{call my_proc(?, ?)}", (ResultSetHandler)null);
+ }
+
+ @Test
+ public void testExecuteWithResultSetException() throws Exception {
+ doThrow(new SQLException()).when(stmt).execute();
+
+ callExecuteWithResultSetWithException(handler, "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");
+ }
+}
http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java b/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java
index 6eb7135..6d5e2cb 100644
--- a/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java
+++ b/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java
@@ -28,7 +28,7 @@ import org.apache.commons.dbutils.TestBean;
public class BeanHandlerTest extends BaseTestCase {
public void testHandle() throws SQLException {
- ResultSetHandler<TestBean> h = new BeanHandler<TestBean>(TestBean.class);
+ ResultSetHandler<TestBean> h = new BeanHandler<>(TestBean.class);
TestBean results = h.handle(this.rs);
assertNotNull(results);
@@ -39,7 +39,7 @@ public class BeanHandlerTest extends BaseTestCase {
}
public void testEmptyResultSetHandle() throws SQLException {
- ResultSetHandler<TestBean> h = new BeanHandler<TestBean>(TestBean.class);
+ ResultSetHandler<TestBean> h = new BeanHandler<>(TestBean.class);
TestBean results = h.handle(this.emptyResultSet);
assertNull(results);
http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java b/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java
index ef3a9e5..d5b293b 100644
--- a/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java
+++ b/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java
@@ -30,7 +30,7 @@ import org.apache.commons.dbutils.TestBean;
public class BeanListHandlerTest extends BaseTestCase {
public void testHandle() throws SQLException {
- ResultSetHandler<List<TestBean>> h = new BeanListHandler<TestBean>(TestBean.class);
+ ResultSetHandler<List<TestBean>> h = new BeanListHandler<>(TestBean.class);
List<TestBean> results = h.handle(this.rs);
assertNotNull(results);
@@ -57,7 +57,7 @@ public class BeanListHandlerTest extends BaseTestCase {
}
public void testEmptyResultSetHandle() throws SQLException {
- ResultSetHandler<List<TestBean>> h = new BeanListHandler<TestBean>(TestBean.class);
+ ResultSetHandler<List<TestBean>> h = new BeanListHandler<>(TestBean.class);
List<TestBean> results = h.handle(this.emptyResultSet);
assertNotNull(results);
http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java b/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java
index 09ae157..60d505a 100644
--- a/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java
+++ b/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java
@@ -57,32 +57,32 @@ public class BeanMapHandlerTest {
@Test
public void testBeanMapHandlerClassOfV() throws Exception {
- bmh = new BeanMapHandler<Long, TestBean>(TestBean.class);
+ bmh = new BeanMapHandler<>(TestBean.class);
handle();
}
@Test
public void testBeanMapHandlerClassOfVRowProcessor() throws Exception {
- bmh = new BeanMapHandler<Long, TestBean>(TestBean.class, rp);
+ bmh = new BeanMapHandler<>(TestBean.class, rp);
handle();
}
@Test
public void testBeanMapHandlerClassOfVInt() throws Exception {
- bmh = new BeanMapHandler<Long, TestBean>(TestBean.class, 2);
+ bmh = new BeanMapHandler<>(TestBean.class, 2);
handle();
}
@Test
public void testBeanMapHandlerClassOfVString() throws Exception {
- bmh = new BeanMapHandler<Long, TestBean>(TestBean.class, "id");
+ bmh = new BeanMapHandler<>(TestBean.class, "id");
handle();
}
@Test
public void testEmptyResultSet() throws Exception {
when(Boolean.valueOf(rs.next())).thenReturn(Boolean.FALSE);
- bmh = new BeanMapHandler<Long, TestBean>(TestBean.class);
+ bmh = new BeanMapHandler<>(TestBean.class);
res = bmh.handle(rs);
assertNull(res.get(Long.valueOf(23L)));
}