insertoperationtest.java

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

        // setup mock objects
        MockBatchStatement statement = new MockBatchStatement();
        statement.addExpectedBatchStrings(expected);
        statement.setExpectedExecuteBatchCalls(2);
        statement.setExpectedClearBatchCalls(2);
        statement.setExpectedCloseCalls(2);

        MockStatementFactory factory = new MockStatementFactory();
        factory.setExpectedCreatePreparedStatementCalls(2);
        factory.setupStatement(statement);

        MockDatabaseConnection connection = new MockDatabaseConnection();
        connection.setupDataSet(new DefaultDataSet(table));
        connection.setupSchema(schemaName);
        connection.setupStatementFactory(factory);
        connection.setExpectedCloseCalls(0);

        // execute operation
        new InsertOperation().execute(connection, dataSet);

        statement.verify();
        factory.verify();
        connection.verify();
    }

    public void testExecuteWithEmptyTable() throws Exception
    {
        Column[] columns = {new Column("c1", DataType.VARCHAR)};
        ITable table = new DefaultTable(new DefaultTableMetaData(
                "name", columns, columns), new ArrayList());
        IDataSet dataSet = new DefaultDataSet(table);

        // setup mock objects
        MockStatementFactory factory = new MockStatementFactory();
        factory.setExpectedCreatePreparedStatementCalls(0);

        MockDatabaseConnection connection = new MockDatabaseConnection();
        connection.setupDataSet(dataSet);
        connection.setupStatementFactory(factory);
        connection.setExpectedCloseCalls(0);

        // execute operation
        new InsertOperation().execute(connection, dataSet);

        factory.verify();
        connection.verify();
    }

    public void testInsertClob() throws Exception
    {
        // execute this test only if the target database support CLOB
        DatabaseEnvironment environment = DatabaseEnvironment.getInstance();
        if (environment.support(TestFeature.CLOB))
        {
            String tableName = "CLOB_TABLE";

            Reader in = new FileReader(new File("src/xml/clobInsertTest.xml"));
            IDataSet xmlDataSet = new FlatXmlDataSet(in);

            assertEquals("count before", 0, _connection.getRowCount(tableName));

            DatabaseOperation.INSERT.execute(_connection, xmlDataSet);

            ITable tableAfter = _connection.createDataSet().getTable(tableName);
            assertEquals("count after", 3, tableAfter.getRowCount());
            Assertion.assertEquals(xmlDataSet.getTable(tableName), tableAfter);
        }
    }

    public void testInsertBlob() throws Exception
    {
        // execute this test only if the target database support BLOB
        DatabaseEnvironment environment = DatabaseEnvironment.getInstance();
        if (environment.support(TestFeature.BLOB))
        {
            String tableName = "BLOB_TABLE";

            Reader in = new FileReader(new File("src/xml/blobInsertTest.xml"));
            IDataSet xmlDataSet = new FlatXmlDataSet(in);

            assertEquals("count before", 0, _connection.getRowCount(tableName));

            DatabaseOperation.INSERT.execute(_connection, xmlDataSet);

            ITable tableAfter = _connection.createDataSet().getTable(tableName);
            assertEquals("count after", 1, tableAfter.getRowCount());
            Assertion.assertEquals(xmlDataSet.getTable(tableName), tableAfter);
        }
    }

    public void testMissingColumns() throws Exception
    {
        Reader in = new FileReader("src/xml/missingColumnTest.xml");
        IDataSet xmlDataSet = new XmlDataSet(in);

        ITable[] tablesBefore = DataSetUtils.getTables(_connection.createDataSet());
        DatabaseOperation.INSERT.execute(_connection, xmlDataSet);
        ITable[] tablesAfter = DataSetUtils.getTables(_connection.createDataSet());

        // verify tables before
        for (int i = 0; i < tablesBefore.length; i++)
        {
            ITable table = tablesBefore[i];
            String tableName = table.getTableMetaData().getTableName();
            if (tableName.startsWith("EMPTY"))
            {
                assertEquals(tableName + " before", 0, table.getRowCount());
            }
        }

        // verify tables after
        for (int i = 0; i < tablesAfter.length; i++)
        {
            ITable databaseTable = tablesAfter[i];
            String tableName = databaseTable.getTableMetaData().getTableName();

            if (tableName.startsWith("EMPTY"))
            {
                Column[] columns = databaseTable.getTableMetaData().getColumns();
                ITable xmlTable = xmlDataSet.getTable(tableName);

                // verify row count
                assertEquals("row count", xmlTable.getRowCount(),
                        databaseTable.getRowCount());

                // for each table row
                for (int j = 0; j < databaseTable.getRowCount(); j++)
                {
                    // verify first column values
                    Object expected = xmlTable.getValue(j, columns[0].getColumnName());
                    Object actual = databaseTable.getValue(j, columns[0].getColumnName());

                    assertEquals(tableName + "." + columns[0].getColumnName(),
                            expected, actual);

                    // all remaining columns should be null except mssql server timestamp column which is of type binary.
                    for (int k = 1; k < columns.length; k++)
                    {
                        String columnName = columns[k].getColumnName();
                        assertEquals(tableName + "." + columnName,
                                null, databaseTable.getValue(j, columnName));
                    }
                }
            }
        }

    }

    public void testExecute() throws Exception
    {
        Reader in = new FileReader("src/xml/insertOperationTest.xml");
        IDataSet dataSet = new XmlDataSet(in);

        testExecute(dataSet);
    }

    public void testExecuteCaseInsensitive() throws Exception
    {
        Reader in = new FileReader("src/xml/insertOperationTest.xml");
        IDataSet dataSet = new XmlDataSet(in);

        testExecute(new LowerCaseDataSet(dataSet));
    }

    public void testExecuteForwardOnly() throws Exception
    {
        Reader in = new FileReader("src/xml/insertOperationTest.xml");
        IDataSet dataSet = new XmlDataSet(in);

        testExecute(new ForwardOnlyDataSet(dataSet));
    }

    private void testExecute(IDataSet dataSet) throws Exception, SQLException
    {
        ITable[] tablesBefore = DataSetUtils.getTables(_connection.createDataSet());
        DatabaseOperation.INSERT.execute(_connection, dataSet);
        ITable[] tablesAfter = DataSetUtils.getTables(_connection.createDataSet());

        assertEquals("table count", tablesBefore.length, tablesAfter.length);
        for (int i = 0; i < tablesBefore.length; i++)
        {
            ITable table = tablesBefore[i];
            String name = table.getTableMetaData().getTableName();


            if (name.startsWith("EMPTY"))
            {
                assertEquals(name + "before", 0, table.getRowCount());
            }
        }

        for (int i = 0; i < tablesAfter.length; i++)
        {
            ITable table = tablesAfter[i];
            String name = table.getTableMetaData().getTableName();

            if (name.startsWith("EMPTY"))
            {
                if (dataSet instanceof ForwardOnlyDataSet)
                {
                    assertTrue(name, table.getRowCount() > 0);
                }
                else
                {
                    SortedTable expectedTable = new SortedTable(
                            dataSet.getTable(name), table.getTableMetaData());
                    SortedTable actualTable = new SortedTable(table);
                    Assertion.assertEquals(expectedTable, actualTable);
                }
            }
        }
    }
}