Examples with ConnectionProxyImpl com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl used on opensource projects

Example 6 with ConnectionProxyImpl

use of com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl in project druid by alibaba.

the class ConnectionProxyImplTest method test_connection.

public void test_connection() throws Exception {
    DataSourceProxyConfig config = new DataSourceProxyConfig();
    DataSourceProxy dataSource = new DataSourceProxyImpl(null, config);
    FilterEventAdapter filter = new FilterEventAdapter() {
    };
    filter.init(dataSource);
    ConnectionProxyImpl rawConnection = new ConnectionProxyImpl(null, null, new Properties(), 0) {

        public void setClientInfo(String name, String value) throws SQLClientInfoException {
        }
    };
    ConnectionProxyImpl connection = new ConnectionProxyImpl(dataSource, rawConnection, new Properties(), 1001);
    connection.setClientInfo("name", null);
}

Example 7 with ConnectionProxyImpl

use of com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl in project druid by alibaba.

the class WrapImplTest method test_clone.

public void test_clone() throws Exception {
    Class.forName("com.alibaba.druid.proxy.DruidDriver");
    DruidDriver driver = (DruidDriver) DriverManager.getDriver(url);
    ConnectionProxyImpl connection = (ConnectionProxyImpl) driver.connect(url, new Properties());
    connection.getRawObject();
    FilterChain filterChain = (FilterChain) connection.createChain();
    filterChain.cloneChain();
    DataSourceProxyImpl dataSource = (DataSourceProxyImpl) connection.getDirectDataSource();
    dataSource.getId();
    Assert.assertEquals(4, dataSource.getProxyFilters().size());
    Assert.assertEquals(4, dataSource.getFilterClasses().length);
    Assert.assertNotNull(dataSource.getCreatedTime());
    Assert.assertTrue(dataSource.getCreatedTime().getTime() != 0);
    Assert.assertEquals("org.apache.derby.jdbc.EmbeddedDriver", dataSource.getRawDriverClassName());
    Assert.assertEquals(url, dataSource.getUrl());
    Assert.assertEquals("jdbc:derby:classpath:petstore-db", dataSource.getRawUrl());
    Assert.assertEquals(10, dataSource.getRawDriverMajorVersion());
    Assert.assertEquals(12, dataSource.getRawDriverMinorVersion());
    Class<?> mysql5ConnectionClass = Utils.loadClass("com.mysql.jdbc.Connection");
    if (mysql5ConnectionClass != null) {
        Assert.assertFalse(connection.isWrapperFor(mysql5ConnectionClass));
    }
    Assert.assertTrue(connection.isWrapperFor(ConnectionProxyImpl.class));
    Assert.assertTrue(connection.isWrapperFor(org.apache.derby.impl.jdbc.EmbedConnection.class));
    Assert.assertNotNull(connection.unwrap(ConnectionProxyImpl.class));
    Assert.assertNull(connection.unwrap(null));
    org.apache.derby.impl.jdbc.EmbedConnection derbyConnection = connection.unwrap(org.apache.derby.impl.jdbc.EmbedConnection.class);
    Assert.assertNotNull(derbyConnection);
    Statement statement = connection.createStatement();
    if (mysql5ConnectionClass != null) {
        Assert.assertFalse(statement.isWrapperFor(Class.forName("com.mysql.jdbc.Statement")));
    }
    Assert.assertFalse(statement.isWrapperFor(null));
    Assert.assertTrue(statement.isWrapperFor(org.apache.derby.impl.jdbc.EmbedStatement.class));
    org.apache.derby.impl.jdbc.EmbedStatement rayStatement = statement.unwrap(org.apache.derby.impl.jdbc.EmbedStatement.class);
    Assert.assertNotNull(rayStatement);
    statement.close();
}

Example 8 with ConnectionProxyImpl

use of com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl in project druid by alibaba.

the class JdbcFilterEventAdapterTest method test_filterEventAdapter.

public void test_filterEventAdapter() throws Exception {
    DataSourceProxyConfig config = new DataSourceProxyConfig();
    DataSourceProxy dataSource = new DataSourceProxyImpl(null, config);
    FilterEventAdapter filter = new FilterEventAdapter() {
    };
    String sql = "SELECT * FROM PATROL";
    ConnectionProxy connection = new ConnectionProxyImpl(dataSource, null, new Properties(), 1001);
    final PreparedStatementProxy statement = new PreparedStatementProxyImpl(connection, null, sql, 1002);
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int[] statement_executeBatch(StatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeBatch(chain, statement);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int[] statement_executeBatch(StatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeBatch(chain, statement);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int[] statement_executeBatch(StatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeBatch(chain, statement);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_executeQuery(StatementProxy statement, String sql) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeQuery(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_executeQuery(StatementProxy statement, String sql) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeQuery(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_executeQuery(StatementProxy statement, String sql) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeQuery(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int preparedStatement_executeUpdate(PreparedStatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeUpdate(chain, statement);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int preparedStatement_executeUpdate(PreparedStatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeUpdate(chain, statement);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int preparedStatement_executeUpdate(PreparedStatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeUpdate(chain, statement);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // ///////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_getGeneratedKeys(StatementProxy statement) throws SQLException {
                return null;
            }
        };
        filter.statement_getGeneratedKeys(chain, statement);
    }
    {
        final ResultSetProxy resultSet = new ResultSetProxyImpl(statement, null, 2001, null);
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_getGeneratedKeys(StatementProxy statement) throws SQLException {
                return resultSet;
            }
        };
        filter.statement_getGeneratedKeys(chain, statement);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean preparedStatement_execute(PreparedStatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_execute(chain, statement);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean preparedStatement_execute(PreparedStatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_execute(chain, statement);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean preparedStatement_execute(PreparedStatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_execute(chain, statement);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy preparedStatement_executeQuery(PreparedStatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeQuery(chain, statement);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy preparedStatement_executeQuery(PreparedStatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeQuery(chain, statement);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy preparedStatement_executeQuery(PreparedStatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeQuery(chain, statement);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public void dataSource_recycle(DruidPooledConnection connection) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_releaseConnection(chain, null);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public void dataSource_recycle(DruidPooledConnection connection) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_releaseConnection(chain, null);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public void dataSource_recycle(DruidPooledConnection connection) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_releaseConnection(chain, null);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public DruidPooledConnection dataSource_connect(DruidDataSource dataSource, long maxWaitMillis) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_getConnection(chain, null, 0L);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public DruidPooledConnection dataSource_connect(DruidDataSource dataSource, long maxWaitMillis) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_getConnection(chain, null, 0L);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public DruidPooledConnection dataSource_connect(DruidDataSource dataSource, long maxWaitMillis) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_getConnection(chain, null, 0L);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
}

Example 9 with ConnectionProxyImpl

use of com.alibaba.druid.proxy.jdbc.ConnectionProxyImpl in project druid by alibaba.

the class FilterChainTest_NClob_2 method setUp.

protected void setUp() throws Exception {
    dataSource = new DruidDataSource();
    MockCallableStatement mockStmt = new MockCallableStatement(null, "") {

        @Override
        public Object getObject(int parameterIndex) throws SQLException {
            invokeCount++;
            return new MockNClob();
        }
    };
    statement = new CallableStatementProxyImpl(new ConnectionProxyImpl(null, null, null, 0), mockStmt, "", 1);
}