Examples of com.alibaba.druid.proxy.jdbc.DataSourceProxyImpl

com.alibaba.druid.proxy.jdbc.DataSourceProxyImpl
@author wenshao

    }
    
    public void test_logFilter_0() throws Exception {
        DataSourceProxyConfig config = new DataSourceProxyConfig();
        config.setRawUrl("jdbc:mock:");
        DataSourceProxyImpl dataSource = new DataSourceProxyImpl(new MockDriver(), config);


        Log4jFilter log4jFilter = new Log4jFilter();
        log4jFilter.init(dataSource);
        config.getFilters().add(log4jFilter);
        setLogDisableAll(log4jFilter, true);

View Full Code Here

    }


    public void test_logFilter_1() throws Exception {
        DataSourceProxyConfig config = new DataSourceProxyConfig();
        config.setRawUrl("jdbc:mock:");
        DataSourceProxyImpl dataSource = new DataSourceProxyImpl(new MockDriver(), config);


        Log4jFilter log4jFilter = new Log4jFilter();
        log4jFilter.init(dataSource);
        config.getFilters().add(log4jFilter);
        setLogDisableAll(log4jFilter, true);

View Full Code Here

    }


    public void test_logFilter_2() throws Exception {
        DataSourceProxyConfig config = new DataSourceProxyConfig();
        config.setRawUrl("jdbc:mock:");
        DataSourceProxyImpl dataSource = new DataSourceProxyImpl(new MockDriver(), config);


        Log4jFilter log4jFilter = new Log4jFilter();
        {
            log4jFilter.init(dataSource);
            setLogDisableAll(log4jFilter, true);
            config.getFilters().add(log4jFilter);
        }


        CommonsLogFilter logFilter = new CommonsLogFilter();
        {
            logFilter.init(dataSource);
            setLogDisableAll(logFilter, true);
            config.getFilters().add(logFilter);
        }


        final MockResultSetMetaData rsMeta = new MockResultSetMetaData() {


            private int[] types = new int[] { Types.BLOB, Types.CLOB, Types.NCLOB, Types.BINARY, Types.OTHER };


            @Override
            public int getColumnCount() throws SQLException {
                return types.length;
            }


            @Override
            public int getColumnType(int column) throws SQLException {
                return types[column - 1];
            }


        };


        ConnectionProxy conn = (ConnectionProxy) dataSource.connect(new Properties());


        {
            StatementProxy stmt = (StatementProxy) conn.createStatement();
            MockResultSet rs = new MockResultSet(null) {

View Full Code Here

    
    public void test_countFilter() throws Exception {
        DataSourceProxyConfig config = new DataSourceProxyConfig();
        config.setUrl("");


        DataSourceProxyImpl dataSource = new DataSourceProxyImpl(null, config);
        JdbcDataSourceStat dataSourceStat = dataSource.getDataSourceStat();
        
        StatFilter filter = new StatFilter();
        filter.init(dataSource);


        dataSourceStat.reset();

View Full Code Here

        config.setRawUrl("jdbc:mock:");


        StatFilter filter = new StatFilter();


        MockDriver driver = new MockDriver();
        DataSourceProxyImpl dataSource = new DataSourceProxyImpl(driver, config);


        filter.init(dataSource);
        config.getFilters().add(filter);


        Connection conn = dataSource.connect(null);


        Statement stmt = conn.createStatement();
        ResultSetProxy rs = (ResultSetProxy) stmt.executeQuery(sql);
        rs.close();
        stmt.close();


        conn.close();
        conn.close();
        
        dataSource.getCompositeData();
        dataSource.getProperties();
        dataSource.getDataSourceMBeanDomain();
    }

View Full Code Here

        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(9, dataSource.getRawDriverMinorVersion());


        Assert.assertFalse(connection.isWrapperFor(com.mysql.jdbc.Connection.class));
        Assert.assertTrue(connection.isWrapperFor(ConnectionProxyImpl.class));
        Assert.assertTrue(connection.isWrapperFor(org.apache.derby.impl.jdbc.EmbedConnection.class));
        Assert.assertNotNull(connection.unwrap(ConnectionProxyImpl.class));

View Full Code Here

        Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size());
    }
    
    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();
                }

View Full Code Here

        Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size());
    }
    
    public void test_connection() throws Exception {
        DataSourceProxyConfig config = new DataSourceProxyConfig();
        DataSourceProxy dataSource = new DataSourceProxyImpl(null, config);


        FilterEventAdapter filter = new FilterEventAdapter() {
        };
        filter.init(dataSource);

View Full Code Here


        MockDriver driver = new MockDriver();
        DataSourceProxyConfig config = new DataSourceProxyConfig();
        config.setUrl("");
        config.setRawUrl("jdbc:mock:");
        DataSourceProxyImpl dataSource = new DataSourceProxyImpl(driver, config);


        {
            StatFilter filter = new StatFilter();
            filter.init(dataSource);
            config.getFilters().add(filter);
        }
        {
            Log4jFilter filter = new Log4jFilter();
            filter.init(dataSource);
            config.getFilters().add(filter);
        }


        Connection conn = dataSource.connect(null);


        conn.setClientInfo("name", null);


        Statement stmt = conn.createStatement();
        ResultSetProxy rs = (ResultSetProxy) stmt.executeQuery(sql);

View Full Code Here

        Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size());
    }
    
    public void test_call() throws Exception {
        DataSourceProxyConfig config = new DataSourceProxyConfig();
        DataSourceProxy dataSource = new DataSourceProxyImpl(null, config);


        FilterEventAdapter filter = new FilterEventAdapter() {
        };
        filter.init(dataSource);

View Full Code Here

0 1 2 3 4

TOP

Related Classes of com.alibaba.druid.proxy.jdbc.DataSourceProxyImpl

com.alibaba.druid.bvt.proxy.CallableStatementProxyImplTest

com.alibaba.druid.bvt.proxy.ConnectionProxyImplTest

com.alibaba.druid.bvt.proxy.CounterFilterTest

com.alibaba.druid.bvt.proxy.JdbcFilterEventAdapterTest

com.alibaba.druid.bvt.proxy.LogFilterTest

com.alibaba.druid.bvt.proxy.ResultSetProxyImplTest

com.alibaba.druid.bvt.proxy.WrapImplTest

com.alibaba.druid.filter.FilterChain

com.alibaba.druid.filter.FilterChainImpl

com.alibaba.druid.filter.stat.StatFilter

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.