p6testcommon.java

一个跟踪调试jdbc的工具包。通过把jdbc做一个封装

            // test rollback logging
            P6SpyOptions.setFilter("true");
            P6LogQuery.setExcludeTables("");
            P6LogQuery.setIncludeTables("");
            P6LogQuery.setExcludeCategories("");
            P6LogQuery.setIncludeCategories("");
            String query = "select 'y' from stmt_test";
            statement.executeQuery(query);
            assertTrue(P6LogQuery.getLastEntry().indexOf(query) != -1);
            connection.rollback();
            assertTrue(P6LogQuery.getLastEntry().indexOf("rollback") != -1);
            
            // test commit logging
            P6SpyOptions.setFilter("true");
            P6LogQuery.setExcludeTables("");
            P6LogQuery.setIncludeTables("");
            P6LogQuery.setExcludeCategories("");
            P6LogQuery.setIncludeCategories("");
            query = "select 'y' from stmt_test";
            statement.executeQuery(query);
            assertTrue(P6LogQuery.getLastEntry().indexOf(query) != -1);
            connection.commit();
            assertTrue(P6LogQuery.getLastEntry().indexOf("commit") != -1);
            
            // test debug logging
            P6SpyOptions.setFilter("true");
            P6LogQuery.setExcludeTables("stmt_test");
            P6LogQuery.setIncludeTables("");
            P6LogQuery.setExcludeCategories("");
            P6LogQuery.setIncludeCategories("debug,info");
            query = "select 'y' from stmt_test";
            statement.executeQuery(query);
            assertTrue(P6LogQuery.getLastEntry().indexOf("intentionally") != -1);
            
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }
    
    public void testStacktrace() {
        try {
            // get a statement
            Statement statement = connection.createStatement();
            P6SpyOptions.setStackTrace("true");
            
            // perform a query & make sure we get the stack trace
            P6SpyOptions.setFilter("true");
            P6LogQuery.setExcludeTables("");
            P6LogQuery.setIncludeTables("");
            String query = "select 'y' from stmt_test";
            statement.executeQuery(query);
            assertTrue(P6LogQuery.getLastEntry().indexOf(query) != -1);
            assertTrue(P6LogQuery.getLastStack().indexOf("Stack") != -1);
            
            // filter on stack trace that will not match
            P6LogQuery.clearLastStack();
            P6SpyOptions.setStackTraceClass("com.dont.match");
            P6SpyOptions.setFilter("true");
            P6LogQuery.setExcludeTables("");
            P6LogQuery.setIncludeTables("");
            query = "select 'a' from stmt_test";
            statement.executeQuery(query);
            // this will actually match - just the stack trace wont fire
            assertTrue(P6LogQuery.getLastEntry().indexOf(query) != -1);
            assertNull(P6LogQuery.getLastStack());
            
            P6LogQuery.clearLastStack();
            P6SpyOptions.setStackTraceClass("com.p6spy");
            P6SpyOptions.setFilter("true");
            P6LogQuery.setExcludeTables("");
            P6LogQuery.setIncludeTables("");
            query = "select 'b' from stmt_test";
            statement.executeQuery(query);
            assertTrue(P6LogQuery.getLastEntry().indexOf(query) != -1);
            assertTrue(P6LogQuery.getLastStack().indexOf("Stack") != -1);
            
        } catch (Exception e) {
            fail(e.getMessage()+getStackTrace(e));
        }
    }
    
    public void testReload() {
        try {
            Statement statement = connection.createStatement();
            
            HashMap tp = getDefaultPropertyFile();
            reloadProperty(tp);
            
            String query = "select 'b' from stmt_test";
            statement.executeQuery(query);
            
            assertEquals(P6SpyOptions.getFilter(), false);
            
            tp.put("filter","true");
            tp.put("include","bob");
            tp.put("exclude","barb");
            tp.put("trace","false");
            tp.put("autoflush","false");
            tp.put("logfile","reload.log");
            tp.put("append","false");
            tp.put("dateformat","dd-MM-yyyy");
            tp.put("includecategories","debug");
            tp.put("excludecategories","result,batch");
            tp.put("stringmatcher","com.p6spy.engine.common.JakartaRegexMatcher");
            tp.put("stacktrace","true");
            tp.put("stacktraceclass","dummy");
            tp.put("reloadproperties","true");
            tp.put("reloadpropertiesinterval","1");
            writeProperty(PROPERTY_FILE, tp);
            
            P6SpyProperties properties = new P6SpyProperties();
            properties.setSpyProperties(PROPERTY_FILE);
            properties.forceReadProperties();
            OptionReloader.reload();
                        
            Thread.sleep(2000);
            query = "select 'c' from stmt_test";
            statement.executeQuery(query);
            assertEquals(P6SpyOptions.getFilter(), true);
            assertEquals(P6SpyOptions.getInclude(), "bob");
            assertEquals(P6SpyOptions.getExclude(), "barb");
            assertEquals(P6SpyOptions.getAutoflush(), false);
            assertEquals(P6SpyOptions.getLogfile(), "reload.log");
            assertEquals(P6SpyOptions.getAppend(), false);
            assertEquals(P6SpyOptions.getDateformat(), "dd-MM-yyyy");
            assertEquals(P6SpyOptions.getIncludecategories(), "debug");
            assertEquals(P6SpyOptions.getExcludecategories(), "result,batch");
            assertEquals(P6SpyOptions.getStringmatcher(), "com.p6spy.engine.common.JakartaRegexMatcher");
            assertEquals(P6SpyOptions.getStringMatcherEngine().getClass().getName(), "com.p6spy.engine.common.JakartaRegexMatcher");
            assertEquals(P6SpyOptions.getStackTrace(), true);
            assertEquals(P6SpyOptions.getStackTraceClass(), "dummy");
            assertEquals(P6SpyOptions.getReloadProperties(), true);
            assertEquals(P6SpyOptions.getReloadPropertiesInterval(), 1);
        } catch (Exception e) {
            fail(e.getMessage()+getStackTrace(e));
        }
    }
    
    public void testMultiDriver() {
        Statement statement2 = null;
        
        try {
            // rebuild the properties so it can find the second connection
            HashMap tp = getDefaultPropertyFile();
            reloadProperty(tp);
            
            // rebuild a second connection for the multi-driver test
            Properties props = loadProperties("P6Test.properties");
            String drivername = props.getProperty("p6driver2");
            String user = props.getProperty("user2");
            String password = props.getProperty("password2");
            String url = props.getProperty("url2");
            
            P6Util.forName(drivername);
            System.err.println("REGISTERED: "+drivername);
            printAllDrivers();
            Driver driver = DriverManager.getDriver(url);
            Connection conn2 = DriverManager.getConnection(url, user, password);
            statement2 = conn2.createStatement();
            
            // the original
            Statement statement = connection.createStatement();
            
            // rebuild the tables
            dropStatement("drop table stmt_test2", statement2);
            statement2.execute("create table stmt_test2 (col1 varchar(255), col2 int(5))");
            
            // this should be fine
            String query = "select 'q1' from stmt_test";
            statement.executeQuery(query);
            assertTrue(P6LogQuery.getLastEntry().indexOf(query) != -1);
            
            // this table should not exist
            try {
                query = "select 'q2' from stmt_test2";
                statement.executeQuery(query);
                fail("Exception should have occured");
            } catch (Exception e) {
            }
            
            // this should be fine for the second connection
            query = "select 'b' from stmt_test2";
            statement2.executeQuery(query);
            assertTrue(P6LogQuery.getLastEntry().indexOf(query) != -1);
            
            // this table should not exist
            try {
                query = "select 'q3' from stmt_test";
                statement2.executeQuery(query);
                fail("Exception should have occured");
            } catch (Exception e) {
            }
            
        } catch (Exception e) {
            printAllDrivers();
            fail(e.getMessage()+getStackTrace(e));
        } finally {
            try {
                dropStatement("drop table stmt_test2", statement2);
                statement2.close();
            } catch (Exception e) { }
        }
    }
    
    protected void tearDown() {
        try {
            Statement statement = connection.createStatement();
            drop(statement);
            statement.close();
            super.tearDown();
        }  catch (Exception e) {
            fail(e.getMessage());
        }
    }
    
    protected void drop(Statement statement) {
        if (statement == null) { return; }
        dropStatement("drop table stmt_test", statement);
    }
    
    protected void dropStatement(String sql, Statement statement) {
        try {
            statement.execute(sql);
        } catch (Exception e) {
            // we don't really care about cleanup failing
        }
    }
}