UtilTest.java

package com.github.davidmoten.rx.jdbc;

import static com.github.davidmoten.rx.jdbc.Util.autoMap;
import static com.github.davidmoten.rx.jdbc.Util.closeQuietly;
import static com.github.davidmoten.rx.jdbc.Util.closeQuietlyIfAutoCommit;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.expectLastCall;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.assertEquals;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Types;
import java.util.Arrays;

import org.easymock.EasyMock;
import org.junit.Test;
import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import com.github.davidmoten.junit.Asserts;

public class UtilTest {

    @Test
    public void obtainCoverageOfPrivateConstructor() {
        Asserts.assertIsUtilityClass(Util.class);
    }

    @Test
    public void testAutoMapOfUtilDateToSqlDate() {
        assertEquals(new java.sql.Date(1), autoMap(new java.util.Date(1), java.sql.Date.class));
    }

    @Test
    public void testAutoMapOfSqlDateToUtilDate() {
        assertEquals(new java.util.Date(1), autoMap(new java.sql.Date(1), java.util.Date.class));
    }

    @Test
    public void testAutoMapOfSqlDateToLong() {
        assertEquals(1L, autoMap(new java.sql.Date(1), Long.class));
    }

    @Test
    public void testAutoMapOfSqlDateToBigInteger() {
        assertEquals(BigInteger.ONE, autoMap(new java.sql.Date(1), BigInteger.class));
    }

    private static class Simple {
    }

    @Test
    public void testAutoMapOfSqlDateToSimple() {
        assertEquals(new java.sql.Date(1), autoMap(new java.sql.Date(1), Simple.class));
    }

    @Test
    public void testAutoMapOfSqlTimestampToUtilDate() {
        assertEquals(new java.util.Date(1),
                autoMap(new java.sql.Timestamp(1), java.util.Date.class));
    }

    @Test
    public void testAutoMapOfSqlTimestampToLong() {
        assertEquals(1L, autoMap(new java.sql.Timestamp(1), Long.class));
    }

    @Test
    public void testAutoMapOfSqlTimestampToBigInteger() {
        assertEquals(BigInteger.ONE, autoMap(new java.sql.Timestamp(1), BigInteger.class));
    }

    @Test
    public void testAutoMapOfSqlTimestampToSimple() {
        assertEquals(new java.sql.Timestamp(1), autoMap(new java.sql.Timestamp(1), Simple.class));
    }

    @Test
    public void testAutoMapOfSqlTimeToUtilDate() {
        assertEquals(new java.util.Date(1), autoMap(new java.sql.Time(1), java.util.Date.class));
    }

    @Test
    public void testAutoMapOfSqlTimeToLong() {
        assertEquals(1L, autoMap(new java.sql.Time(1), Long.class));
    }

    @Test
    public void testAutoMapOfSqlTimeToBigInteger() {
        assertEquals(BigInteger.ONE, autoMap(new java.sql.Time(1), BigInteger.class));
    }

    @Test
    public void testAutoMapOfSqlTimeToSimple() {
        assertEquals(new java.sql.Time(1), autoMap(new java.sql.Time(1), Simple.class));
    }

    @Test
    public void testAutoMapBlobToByteArray() throws SQLException {
        Blob blob = EasyMock.createMock(Blob.class);
        byte[] b = "hello there".getBytes();
        expect(blob.getBinaryStream()).andReturn(new ByteArrayInputStream(b)).once();
        blob.free();
        EasyMock.expectLastCall().once();
        replay(blob);
        Object bytes = autoMap(blob, byte[].class);
        Arrays.equals(b, (byte[]) bytes);
        verify(blob);
    }

    @Test
    public void testAutoMapBlobToSimple() throws SQLException {
        Blob blob = EasyMock.createMock(Blob.class);
        replay(blob);
        Object bytes = autoMap(blob, Simple.class);
        assertEquals(bytes, blob);
        verify(blob);
    }

    @Test
    public void testAutoMapClobToByteArray() throws SQLException {
        Clob clob = EasyMock.createMock(Clob.class);
        String s = "hello there";
        expect(clob.getCharacterStream()).andReturn(new StringReader(s)).once();
        clob.free();
        EasyMock.expectLastCall().once();
        replay(clob);
        Object string = autoMap(clob, String.class);
        assertEquals(s, string);
        verify(clob);
    }

    @Test
    public void testAutoMapClobToSimple() throws SQLException {
        Clob clob = EasyMock.createMock(Clob.class);
        replay(clob);
        Object result = autoMap(clob, Simple.class);
        assertEquals(clob, result);
        verify(clob);
    }

    @Test
    public void testAutoMapBigIntegerToLong() {
        assertEquals(1L, autoMap(BigInteger.ONE, Long.class));
    }

    @Test
    public void testAutoMapBigIntegerToDouble() {
        assertEquals(1.0, (Double) autoMap(BigInteger.ONE, Double.class), 0.00001);
    }

    @Test
    public void testAutoMapBigIntegerToFloat() {
        assertEquals(1.0, (Float) autoMap(BigInteger.ONE, Float.class), 0.00001);
    }

    @Test
    public void testAutoMapBigIntegerToShort() {
        assertEquals((short) 1, autoMap(BigInteger.ONE, Short.class));
    }

    @Test
    public void testAutoMapBigIntegerToInteger() {
        assertEquals(1, autoMap(BigInteger.ONE, Integer.class));
    }

    @Test
    public void testAutoMapBigDecimalToDouble() {
        assertEquals(1.0, (Double) autoMap(BigDecimal.ONE, Double.class), 0.00001);
    }

    @Test
    public void testAutoMapBigDecimalToFloat() {
        assertEquals(1.0, (Float) autoMap(BigDecimal.ONE, Float.class), 0.00001);
    }

    @Test
    public void testAutoMapBigDecimalToShort() {
        assertEquals((short) 1, autoMap(BigDecimal.ONE, Short.class));
    }

    @Test
    public void testAutoMapBigDecimalToInteger() {
        assertEquals(1, autoMap(BigDecimal.ONE, Integer.class));
    }

    @Test
    public void testAutoMapBigDecimalToLong() {
        assertEquals(1L, autoMap(BigDecimal.ONE, Long.class));
    }

    @Test
    public void testAutoMapOfBigIntegerToSimple() {
        assertEquals(BigInteger.ONE, autoMap(BigInteger.ONE, Simple.class));
    }

    @Test
    public void testAutoMapOfBigDecimalToSimple() {
        assertEquals(BigDecimal.ONE, autoMap(BigDecimal.ONE, Simple.class));
    }

    @Test
    public void testAutoMapOfDoubleToBigDecimal() {
        assertEquals(BigDecimal.ONE.doubleValue(),
                ((BigDecimal) autoMap(1.0, BigDecimal.class)).doubleValue(), 0.0001);
    }

    @Test
    public void testAutoMapOfIntegerToBigDecimal() {
        assertEquals(BigDecimal.ONE.doubleValue(),
                ((BigDecimal) autoMap(1, BigDecimal.class)).doubleValue(), 0.0001);
    }

    @Test
    public void testAutoMapOfDoubleToBigInteger() {
        assertEquals(1.2, (Double) autoMap(1.2, BigInteger.class), 0.0001);
    }

    @Test
    public void testAutoMapOfShortToBigInteger() {
        assertEquals(BigInteger.ONE, autoMap((short) 1, BigInteger.class));
    }

    @Test
    public void testAutoMapOfIntegerToBigInteger() {
        assertEquals(BigInteger.ONE, autoMap(1, BigInteger.class));
    }

    @Test
    public void testAutoMapOfNumberToBigInteger() {
        assertEquals(BigInteger.ONE, autoMap(1L, BigInteger.class));
    }

    @Test
    public void testAutoMapOfNumberToInteger() {
        assertEquals(1, autoMap(1L, Integer.class));
    }

    @Test
    public void testAutoMapOfNumberToShort() {
        assertEquals((short) 1, autoMap(1L, Short.class));
    }

    @Test
    public void testAutoMapOfNumberToDouble() {
        assertEquals(1.0, (Double) autoMap(1L, Double.class), 0.00001);
    }

    @Test
    public void testAutoMapOfNumberToLong() {
        assertEquals(1L, (long) (Long) autoMap(1, Long.class));
    }

    @Test
    public void testAutoMapOfLongToFloat() {
        assertEquals(1.0f, (Float) autoMap(1L, Float.class), 0.00001);
    }

    @Test
    public void testClose1() throws SQLException {
        Connection con = createMock(Connection.class);
        expect(con.isClosed()).andThrow(new SQLException());
        replay(con);
        closeQuietly(con);
        verify(con);
    }

    @Test(expected = RuntimeException.class)
    public void testClose2() throws SQLException {
        Connection con = createMock(Connection.class);
        expect(con.isClosed()).andThrow(new SQLException());
        replay(con);
        closeQuietlyIfAutoCommit(con);
        verify(con);
    }

    @Test(expected = RuntimeException.class)
    public void testCommit() throws SQLException {
        Connection con = createMock(Connection.class);
        con.commit();
        expectLastCall().andThrow(new SQLException());
        replay(con);
        Util.commit(con);
        verify(con);
    }

    @Test
    public void testCommitNullDoesNothing() {
        Util.commit(null);
    }

    @Test
    public void testRollbackNullDoesNothing() {
        Util.rollback(null);
    }

    @Test(expected = RuntimeException.class)
    public void testRollback() throws SQLException {
        Connection con = createMock(Connection.class);
        con.rollback();
        expectLastCall().andThrow(new SQLException());
        replay(con);
        Util.rollback(con);
        verify(con);
    }

    @Test
    public void testMapObjectExistingClob() throws SQLException, IOException {

        final Clob mock = Mockito.mock(Clob.class);
        Mockito.when(mock.getCharacterStream()).thenAnswer(new Answer<Reader>() {
            @Override
            public Reader answer(InvocationOnMock invocationOnMock) throws Throwable {
                return new StringReader("test");
            }
        });

        final ResultSetMetaData metaData = Mockito.mock(ResultSetMetaData.class);
        Mockito.when(metaData.getColumnType(1)).thenAnswer(new Answer<Integer>() {
            @Override
            public Integer answer(InvocationOnMock invocationOnMock) throws Throwable {
                return Types.CLOB;
            }
        });

        ResultSet resultSet = Mockito.mock(ResultSet.class);

        Mockito.when(resultSet.getObject(1)).thenAnswer(new Answer<Clob>() {
            @Override
            public Clob answer(InvocationOnMock invocationOnMock) throws Throwable {
                return mock;
            }
        });

        Mockito.when(resultSet.getClob(1)).thenAnswer(new Answer<Clob>() {
            @Override
            public Clob answer(InvocationOnMock invocationOnMock) throws Throwable {
                return mock;
            }
        });

        Mockito.when(resultSet.getMetaData()).thenAnswer(new Answer<ResultSetMetaData>() {
            @Override
            public ResultSetMetaData answer(InvocationOnMock invocationOnMock) throws Throwable {
                return metaData;
            }
        });

        assertEquals(Util.mapObject(resultSet, String.class, 1), "test");

    }

    @Test
    public void testMapObjectNullClob() throws SQLException, IOException {

        final ResultSetMetaData metaData = Mockito.mock(ResultSetMetaData.class);
        Mockito.when(metaData.getColumnType(1)).thenAnswer(new Answer<Integer>() {
            @Override
            public Integer answer(InvocationOnMock invocationOnMock) throws Throwable {
                return Types.CLOB;
            }
        });

        ResultSet resultSet = Mockito.mock(ResultSet.class);

        Mockito.when(resultSet.getObject(1)).thenAnswer(new Answer<Clob>() {
            @Override
            public Clob answer(InvocationOnMock invocationOnMock) throws Throwable {
                return null;
            }
        });

        Mockito.when(resultSet.getClob(1)).thenAnswer(new Answer<Clob>() {
            @Override
            public Clob answer(InvocationOnMock invocationOnMock) throws Throwable {
                return null;
            }
        });

        Mockito.when(resultSet.getMetaData()).thenAnswer(new Answer<ResultSetMetaData>() {
            @Override
            public ResultSetMetaData answer(InvocationOnMock invocationOnMock) throws Throwable {
                return metaData;
            }
        });

        assertEquals(Util.mapObject(resultSet, String.class, 1), null);

    }

    @Test
    public void testCamelCaseToUnderscore() {
        assertEquals("a", Util.camelCaseToUnderscore("a"));
    }

    @Test
    public void testCamelCaseToUnderscore2() {
        assertEquals("ab", Util.camelCaseToUnderscore("ab"));
    }

    @Test
    public void testCamelCaseToUnderscore3() {
        assertEquals("a_B", Util.camelCaseToUnderscore("aB"));
    }

    @Test
    public void testCamelCaseToUnderscore4() {
        assertEquals("a_BC", Util.camelCaseToUnderscore("aBC"));
    }

    @Test
    public void testCamelCaseToUnderscore5() {
        assertEquals("a_Before_Count", Util.camelCaseToUnderscore("aBeforeCount"));
    }

    @Test
    public void testCamelCaseToUnderscore6() {
        assertEquals("", Util.camelCaseToUnderscore(""));
    }

    @Test
    public void testCountOfQuestionMarks() {
        assertEquals(2,
                Util.countQuestionMarkParameters("select name from blah where a <? and b = ?"));
    }

    @Test
    public void testCountOfQuestionMarksIgnoresTextInQuotes() {
        assertEquals(1,
                Util.countQuestionMarkParameters("select name from blah where a < '?' and b = ?"));
    }

    @Test
    public void testCountOfNoQuestionMarks() {
        assertEquals(0, Util.countQuestionMarkParameters("boo"));
    }

    @Test
    public void testCountOfNoQuestionMarksReturnsZeroWhenEmptyString() {
        assertEquals(0, Util.countQuestionMarkParameters(""));
    }

    @Test
    public void testCountOfNoQuestionMarksSkipsNestedUnclosedQuotes() {
        assertEquals(1, Util.countQuestionMarkParameters(
                "select name from person where name > '\"?' and name > ?"));
    }
}