updateoperationtest.java

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

        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 UpdateOperation().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 UpdateOperation().execute(connection, dataSet);

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

    public void testUpdateClob() 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";

            {
                IDataSet beforeDataSet = new FlatXmlDataSet(
                        new File("src/xml/clobInsertTest.xml"));

                ITable tableBefore = _connection.createDataSet().getTable(tableName);
                assertEquals("count before", 3, _connection.getRowCount(tableName));
                Assertion.assertEquals(beforeDataSet.getTable(tableName), tableBefore);
            }

            IDataSet afterDataSet = new FlatXmlDataSet(
                    new File("src/xml/clobUpdateTest.xml"));
            DatabaseOperation.REFRESH.execute(_connection, afterDataSet);

            {
                ITable tableAfter = _connection.createDataSet().getTable(tableName);
                assertEquals("count after", 4, tableAfter.getRowCount());
                Assertion.assertEquals(afterDataSet.getTable(tableName), tableAfter);
            }
        }
    }

    public void testUpdateBlob() 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";

            {
                IDataSet beforeDataSet = new FlatXmlDataSet(
                        new File("src/xml/blobInsertTest.xml"));

                ITable tableBefore = _connection.createDataSet().getTable(tableName);
                assertEquals("count before", 1, _connection.getRowCount(tableName));
                Assertion.assertEquals(beforeDataSet.getTable(tableName), tableBefore);

//                System.out.println("****** BEFORE *******");
//                FlatXmlDataSet.write(_connection.createDataSet(), System.out);
            }

            IDataSet afterDataSet = new FlatXmlDataSet(
                    new File("src/xml/blobUpdateTest.xml"));
            DatabaseOperation.REFRESH.execute(_connection, afterDataSet);

            {
                ITable tableAfter = _connection.createDataSet().getTable(tableName);
                assertEquals("count after", 2, tableAfter.getRowCount());
                Assertion.assertEquals(afterDataSet.getTable(tableName), tableAfter);

//                System.out.println("****** AFTER *******");
//                FlatXmlDataSet.write(_connection.createDataSet(), System.out);
            }
        }
    }

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

        testExecute(dataSet);

    }

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

        testExecute(new LowerCaseDataSet(dataSet));
    }

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

        testExecute(new ForwardOnlyDataSet(dataSet));
    }

    public void testExecuteAndNoPrimaryKeys() throws Exception
    {
        String tableName = "test_table";

        Reader reader = new FileReader("src/xml/updateOperationNoPKTest.xml");
        IDataSet dataSet = new FlatXmlDataSet(reader);

        // verify table before
        assertEquals("row count before", 6, _connection.getRowCount(tableName));

        try
        {
            DatabaseOperation.REFRESH.execute(_connection, dataSet);
            fail("Should not be here!");
        }
        catch (NoPrimaryKeyException e)
        {

        }

        // verify table after
        assertEquals("row count before", 6, _connection.getRowCount(tableName));
    }

    private void testExecute(IDataSet dataSet) throws Exception
    {
        String tableName = "PK_TABLE";
        String[] columnNames = {"PK0", "PK1", "PK2", "NORMAL0", "NORMAL1"};
        int modifiedRow = 1;

        // verify table before
        ITable tableBefore = createOrderedTable(tableName, columnNames[0]);
        assertEquals("row count before", 3, tableBefore.getRowCount());

        DatabaseOperation.UPDATE.execute(_connection, dataSet);

        ITable tableAfter = createOrderedTable(tableName, columnNames[0]);
        assertEquals("row count after", 3, tableAfter.getRowCount());
        for (int i = 0; i < tableAfter.getRowCount(); i++)
        {
            // verify modified row
            if (i == modifiedRow)
            {
                assertEquals("PK0", "1",
                        tableAfter.getValue(i, "PK0").toString());
                assertEquals("PK1", "1",
                        tableAfter.getValue(i, "PK1").toString());
                assertEquals("PK2", "1",
                        tableAfter.getValue(i, "PK2").toString());
                assertEquals("NORMAL0", "toto",
                        tableAfter.getValue(i, "NORMAL0").toString());
                assertEquals("NORMAL1", "qwerty",
                        tableAfter.getValue(i, "NORMAL1").toString());
            }
            // all other row must be equals than before update
            else
            {
                for (int j = 0; j < columnNames.length; j++)
                {
                    String name = columnNames[j];
                    Object valueAfter = tableAfter.getValue(i, name);
                    Object valueBefore = tableBefore.getValue(i, name);
                    assertEquals("c=" + name + ",r=" + j, valueBefore, valueAfter);
                }
            }
        }
    }


}