| /* |
| * 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.assertFalse; |
| import static org.junit.Assert.fail; |
| import static org.mockito.Mockito.doThrow; |
| import static org.mockito.Mockito.mock; |
| import static org.mockito.Mockito.reset; |
| import static org.mockito.Mockito.verify; |
| |
| import java.sql.Connection; |
| import java.sql.Driver; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.util.Properties; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| public class DbUtilsTest { |
| |
| public static class DriverProxyTest { |
| private static final Driver mockedDriver = mock(Driver.class); |
| private DbUtils.DriverProxy proxy; |
| |
| @Before |
| public void setUp() { |
| proxy = new DbUtils.DriverProxy(mockedDriver); |
| } |
| |
| @After |
| public void tearDown() { |
| reset(mockedDriver); |
| } |
| |
| @Test |
| public void testProxiedMethods() throws Exception { |
| proxy.getMajorVersion(); |
| verify(mockedDriver).getMajorVersion(); |
| proxy.getMinorVersion(); |
| verify(mockedDriver).getMinorVersion(); |
| proxy.jdbcCompliant(); |
| verify(mockedDriver).jdbcCompliant(); |
| |
| final String url = "testUrl"; |
| proxy.acceptsURL(url); |
| verify(mockedDriver).acceptsURL(url); |
| |
| final Properties props = new Properties(); |
| props.setProperty("test", "true"); |
| proxy.connect(url, props); |
| verify(mockedDriver).connect(url, props); |
| proxy.getPropertyInfo(url, props); |
| verify(mockedDriver).getPropertyInfo(url, props); |
| } |
| } |
| |
| @Test |
| public void closeConnection() throws Exception { |
| final Connection mockCon = mock(Connection.class); |
| DbUtils.close(mockCon); |
| verify(mockCon).close(); |
| } |
| |
| @Test |
| public void closeNullConnection() throws Exception { |
| DbUtils.close((Connection) null); |
| } |
| |
| @Test |
| public void closeNullResultSet() throws Exception { |
| DbUtils.close((ResultSet) null); |
| } |
| |
| @Test |
| public void closeNullStatement() throws Exception { |
| DbUtils.close((Statement) null); |
| } |
| |
| @Test |
| public void closeQuietlyConnection() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| DbUtils.closeQuietly(mockConnection); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void closeQuietlyConnectionResultSetStatement() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| final ResultSet mockResultSet = mock(ResultSet.class); |
| final Statement mockStatement = mock(Statement.class); |
| DbUtils.closeQuietly(mockConnection, mockStatement, mockResultSet); |
| verify(mockConnection).close(); |
| verify(mockResultSet).close(); |
| verify(mockStatement).close(); |
| } |
| |
| @Test |
| public void closeQuietlyConnectionResultSetStatementThrowingException() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| final ResultSet mockResultSet = mock(ResultSet.class); |
| final Statement mockStatement = mock(Statement.class); |
| doThrow(SQLException.class).when(mockStatement).close(); |
| DbUtils.closeQuietly(mockConnection, mockStatement, mockResultSet); |
| verify(mockConnection).close(); |
| verify(mockResultSet).close(); |
| verify(mockStatement).close(); |
| } |
| |
| @Test |
| public void closeQuietlyConnectionResultSetThrowingExceptionStatement() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| final ResultSet mockResultSet = mock(ResultSet.class); |
| doThrow(SQLException.class).when(mockResultSet).close(); |
| final Statement mockStatement = mock(Statement.class); |
| DbUtils.closeQuietly(mockConnection, mockStatement, mockResultSet); |
| verify(mockConnection).close(); |
| verify(mockResultSet).close(); |
| verify(mockStatement).close(); |
| } |
| |
| @Test |
| public void closeQuietlyConnectionThrowingException() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| doThrow(SQLException.class).when(mockConnection).close(); |
| DbUtils.closeQuietly(mockConnection); |
| } |
| |
| @Test |
| public void closeQuietlyConnectionThrowingExceptionResultSetStatement() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| doThrow(SQLException.class).when(mockConnection).close(); |
| final ResultSet mockResultSet = mock(ResultSet.class); |
| final Statement mockStatement = mock(Statement.class); |
| DbUtils.closeQuietly(mockConnection, mockStatement, mockResultSet); |
| verify(mockConnection).close(); |
| verify(mockResultSet).close(); |
| verify(mockStatement).close(); |
| } |
| |
| @Test |
| public void closeQuietlyNullConnection() throws Exception { |
| DbUtils.closeQuietly((Connection) null); |
| } |
| |
| @Test |
| public void closeQuietlyNullResultSet() throws Exception { |
| DbUtils.closeQuietly((ResultSet) null); |
| } |
| |
| @Test |
| public void closeQuietlyNullStatement() throws Exception { |
| DbUtils.closeQuietly((Statement) null); |
| } |
| |
| @Test |
| public void closeQuietlyResultSet() throws Exception { |
| final ResultSet mockResultSet = mock(ResultSet.class); |
| DbUtils.closeQuietly(mockResultSet); |
| verify(mockResultSet).close(); |
| } |
| |
| @Test |
| public void closeQuietlyResultSetThrowingException() throws Exception { |
| final ResultSet mockResultSet = mock(ResultSet.class); |
| doThrow(SQLException.class).when(mockResultSet).close(); |
| DbUtils.closeQuietly(mockResultSet); |
| } |
| |
| @Test |
| public void closeQuietlyStatement() throws Exception { |
| final Statement mockStatement = mock(Statement.class); |
| DbUtils.closeQuietly(mockStatement); |
| verify(mockStatement).close(); |
| } |
| |
| @Test |
| public void closeQuietlyStatementThrowingException() throws Exception { |
| final Statement mockStatement = mock(Statement.class); |
| doThrow(SQLException.class).when(mockStatement).close(); |
| DbUtils.closeQuietly(mockStatement); |
| } |
| |
| @Test |
| public void closeResultSet() throws Exception { |
| final ResultSet mockResultSet = mock(ResultSet.class); |
| DbUtils.close(mockResultSet); |
| verify(mockResultSet).close(); |
| } |
| |
| @Test |
| public void closeStatement() throws Exception { |
| final Statement mockStatement = mock(Statement.class); |
| DbUtils.close(mockStatement); |
| verify(mockStatement).close(); |
| } |
| |
| @Test |
| public void commitAndClose() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| DbUtils.commitAndClose(mockConnection); |
| verify(mockConnection).commit(); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void commitAndCloseQuietly() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| DbUtils.commitAndClose(mockConnection); |
| verify(mockConnection).commit(); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void commitAndCloseQuietlyWithException() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| doThrow(SQLException.class).when(mockConnection).close(); |
| DbUtils.commitAndCloseQuietly(mockConnection); |
| verify(mockConnection).commit(); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void commitAndCloseWithException() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| doThrow(SQLException.class).when(mockConnection).commit(); |
| try { |
| DbUtils.commitAndClose(mockConnection); |
| fail("DbUtils.commitAndClose() swallowed SQLEception!"); |
| } catch (final SQLException e) { |
| // we expect this exception |
| } |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void rollback() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| DbUtils.rollback(mockConnection); |
| verify(mockConnection).rollback(); |
| } |
| |
| @Test |
| public void rollbackAndClose() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| DbUtils.rollbackAndClose(mockConnection); |
| verify(mockConnection).rollback(); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void rollbackAndCloseNull() throws Exception { |
| DbUtils.rollbackAndClose(null); |
| } |
| |
| @Test |
| public void rollbackAndCloseQuietly() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| DbUtils.rollbackAndCloseQuietly(mockConnection); |
| verify(mockConnection).rollback(); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void rollbackAndCloseQuietlyNull() throws Exception { |
| DbUtils.rollbackAndCloseQuietly(null); |
| } |
| |
| @Test |
| public void rollbackAndCloseQuietlyWithException() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| doThrow(SQLException.class).when(mockConnection).rollback(); |
| DbUtils.rollbackAndCloseQuietly(mockConnection); |
| verify(mockConnection).rollback(); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void rollbackAndCloseWithException() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| doThrow(SQLException.class).when(mockConnection).rollback(); |
| try { |
| DbUtils.rollbackAndClose(mockConnection); |
| fail("DbUtils.rollbackAndClose() swallowed SQLException!"); |
| } catch (final SQLException e) { |
| // we expect this exception |
| } |
| verify(mockConnection).rollback(); |
| verify(mockConnection).close(); |
| } |
| |
| @Test |
| public void rollbackNull() throws Exception { |
| DbUtils.rollback(null); |
| } |
| |
| @Test |
| public void rollbackQuietly() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| DbUtils.rollbackQuietly(mockConnection); |
| verify(mockConnection).rollback(); |
| } |
| |
| @Test |
| public void rollbackQuietlyNull() throws Exception { |
| DbUtils.rollbackQuietly(null); |
| } |
| |
| @Test |
| public void rollbackQuietlyWithException() throws Exception { |
| final Connection mockConnection = mock(Connection.class); |
| doThrow(SQLException.class).when(mockConnection).rollback(); |
| DbUtils.rollbackQuietly(mockConnection); |
| verify(mockConnection).rollback(); |
| } |
| |
| @Test |
| public void testCommitAndCloseQuietlyWithNullDoesNotThrowAnSQLException() { |
| |
| DbUtils.commitAndCloseQuietly(null); |
| |
| } |
| |
| @Test |
| public void testLoadDriverReturnsFalse() { |
| |
| assertFalse(DbUtils.loadDriver("")); |
| |
| } |
| } |