dbunittasktest.java

一个基于JUnit测试框架的关于数据库的测试框架

        List tables = export.getTables();
        assertTrue("Export should have had two subtables, but has: "
                + tables.size(), tables.size() == 2);
        Table testTable = (Table)tables.get(0);
        Table pkTable = (Table)tables.get(1);
        assertTrue("Should have been been TABLE TEST_TABLE, but was: "
                + testTable.getName(), testTable.getName().equals("TEST_TABLE"));
        assertTrue("Should have been been TABLE PK_TABLE, but was: "
                + pkTable.getName(), pkTable.getName().equals("PK_TABLE"));
    }

    public void testExportFlat()
    {
        String targetName = "test-export-format-flat";
        Export export = (Export)getFirstStepFromTarget(targetName);
        assertTrue("Should have been a flat format, "
                + "but was: " + export.getFormat(),
                export.getFormat().equalsIgnoreCase("flat"));
    }

    public void testExportXml()
    {
        String targetName = "test-export-format-xml";
        Export export = (Export)getFirstStepFromTarget(targetName);
        assertTrue("Should have been an xml format, "
                + "but was: " + export.getFormat(),
                export.getFormat().equalsIgnoreCase("xml"));
    }

    public void testExportDtd()
    {
        String targetName = "test-export-format-dtd";
        Export export = (Export)getFirstStepFromTarget(targetName);
        assertTrue("Should have been a dtd format, "
                + "but was: " + export.getFormat(),
                export.getFormat().equalsIgnoreCase("dtd"));
    }

    public void testInvalidExportFormat()
    {
        expectBuildException("invalid-export-format",
                "Should have objected to invalid format attribute.");
    }

    public void testExportQuery()
    {
        String targetName = "test-export-query";
        Export export = (Export)getFirstStepFromTarget(targetName);
        assertEquals("format", "flat", export.getFormat());

        List queries = export.getTables();
        assertEquals("query count", 2, getQueryCount(queries));

        Query testTable = (Query)queries.get(0);
        assertEquals("name", "TEST_TABLE", testTable.getName());
        assertEquals("sql", "SELECT * FROM test_table", testTable.getSql());

        Query pkTable = (Query)queries.get(1);
        assertEquals("name", "PK_TABLE", pkTable.getName());
        assertEquals("sql", "SELECT * FROM pk_table", pkTable.getSql());
    }

    public void testExportQueryMixed()
    {
        String targetName = "test-export-query-mixed";
        Export export = (Export)getFirstStepFromTarget(targetName);
        assertEquals("format", "flat", export.getFormat());

        List tables = export.getTables();
        assertEquals("total count", 2, tables.size());
        assertEquals("table count", 1, getTableCount(tables));
        assertEquals("query count", 1, getQueryCount(tables));

        Table testTable = (Table)tables.get(0);
        assertEquals("name", "TEST_TABLE", testTable.getName());

        Query pkTable = (Query)tables.get(1);
        assertEquals("name", "PK_TABLE", pkTable.getName());
    }

    public void testDataTypeFactory() throws Exception
    {
        String targetName = "test-datatypefactory";
        DbUnitTask task = getFirstTargetTask(targetName);

        IDatabaseConnection connection = task.createConnection();
        IDataTypeFactory factory = (IDataTypeFactory)connection.getConfig().getProperty(
                        DatabaseConfig.PROPERTY_DATATYPE_FACTORY);

        Class expectedClass = OracleDataTypeFactory.class;
        assertEquals("factory", expectedClass, factory.getClass());
    }

    public void testEscapePattern() throws Exception
    {
        String targetName = "test-escapepattern";
        DbUnitTask task = getFirstTargetTask(targetName);

        IDatabaseConnection connection = task.createConnection();
        String actualPattern = (String)connection.getConfig().getProperty(
                        DatabaseConfig.PROPERTY_ESCAPE_PATTERN);

        String expectedPattern = "[?]";
        assertEquals("factory", expectedPattern, actualPattern);
    }

    public void testClasspath() throws Exception
    {
        String targetName = "test-classpath";

        try
        {
            executeTarget(targetName);
            fail("Should not be able to connect with invalid url!");
        }
        catch (BuildException e)
        {
            // Verify exception type
            assertEquals("nested exception type", SQLException.class, e.getException().getClass());
        }

    }

    public void testDriverNotInClasspath() throws Exception
    {
        String targetName = "test-drivernotinclasspath";

        try
        {
            executeTarget(targetName);
            fail("Should not have found driver!");
        }
        catch (BuildException e)
        {
            // Verify exception type
            assertEquals("nested exception type", ClassNotFoundException.class, e.getException().getClass());
        }
    }


    protected void assertOperationType(String failMessage, String targetName, DatabaseOperation expected)
    {
        Operation oper = (Operation)getFirstStepFromTarget(targetName);
        DatabaseOperation dbOper = oper.getDbOperation();
        assertTrue(failMessage + ", but was: " + dbOper, expected.equals(dbOper));
    }

    protected int getQueryCount(List tables)
    {
        int count = 0;
        for (Iterator it = tables.iterator(); it.hasNext();)
        {
            if (it.next() instanceof Query)
            {
                count++;
            }
        }

        return count;
    }

    protected int getTableCount(List tables)
    {
        int count = 0;
        for (Iterator it = tables.iterator(); it.hasNext();)
        {
            if (it.next() instanceof Table)
            {
                count++;
            }
        }

        return count;
    }

    protected DbUnitTaskStep getFirstStepFromTarget(String targetName)
    {
        DbUnitTaskStep result = null;
        DbUnitTask task = getFirstTargetTask(targetName);
        List steps = task.getSteps();
        if (steps != null && steps.size() > 0)
        {
            result = (DbUnitTaskStep)steps.get(0);
        }
        else
        {
            fail("Can't get a dbunit <step> from the target: " + targetName);
        }
        return result;
    }

    private DbUnitTask getFirstTargetTask(String targetName)
    {
        Hashtable targets = project.getTargets();
        executeTarget(targetName);
        Target target = (Target)targets.get(targetName);
        DbUnitTask task = (DbUnitTask)target.getTasks()[0];
        return task;
    }

    public static Test suite()
    {
        TestSuite suite = new TestSuite(classUnderTest);
        return suite;
    }

    public static void main(String args[])
    {
        if (args.length > 0 && args[0].equals("-gui"))
        {
            String[] testCaseName = {classUnderTest.getName()};
            junit.swingui.TestRunner.main(testCaseName);
        }
        else
        {
            junit.textui.TestRunner.run(suite());
        }
    }
}