DbUnitAssert.java

  1. /*
  2.  *
  3.  * The DbUnit Database Testing Framework
  4.  * Copyright (C)2002-2008, DbUnit.org
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with this library; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  *
  20.  */
  21. package org.dbunit.assertion;

  23. import java.sql.SQLException;

  25. import org.dbunit.DatabaseUnitException;
  26. import org.dbunit.assertion.comparer.value.ValueComparers;
  27. import org.dbunit.database.IDatabaseConnection;
  28. import org.dbunit.dataset.Column;
  29. import org.dbunit.dataset.IDataSet;
  30. import org.dbunit.dataset.ITable;
  31. import org.dbunit.dataset.datatype.DataType;
  32. import org.dbunit.dataset.datatype.UnknownDataType;
  33. import org.dbunit.dataset.filter.DefaultColumnFilter;
  34. import org.slf4j.Logger;
  35. import org.slf4j.LoggerFactory;

  37. /**
  38.  * Default implementation of DbUnit assertions, based on the original methods
  39.  * present at {@link org.dbunit.Assertion}.
  40.  *
  41.  * All are equality comparisons.
  42.  *
  43.  * @author Felipe Leme (dbunit@felipeal.net)
  44.  * @author gommma (gommma AT users.sourceforge.net)
  45.  * @version $Revision$ $Date$
  46.  * @since 2.4.0
  47.  */
  48. public class DbUnitAssert extends DbUnitAssertBase
  49. {
  50.     private static final Logger logger =
  51.             LoggerFactory.getLogger(DbUnitAssert.class);

  53.     /**
  54.      * Compare one table present in two datasets ignoring specified columns.
  55.      *
  56.      * @param expectedDataset
  57.      *            First dataset.
  58.      * @param actualDataset
  59.      *            Second dataset.
  60.      * @param tableName
  61.      *            Table name of the table to be compared.
  62.      * @param ignoreCols
  63.      *            Columns to be ignored in comparison.
  64.      * @throws org.dbunit.DatabaseUnitException
  65.      *             If an error occurs.
  66.      */
  67.     public void assertEqualsIgnoreCols(final IDataSet expectedDataset,
  68.             final IDataSet actualDataset, final String tableName,
  69.             final String[] ignoreCols) throws DatabaseUnitException
  70.     {
  71.         logger.debug(
  72.                 "assertEqualsIgnoreCols(expectedDataset={}, actualDataset={}, tableName={}, ignoreCols={}) - start",
  73.                 expectedDataset, actualDataset, tableName, ignoreCols);

  75.         assertEqualsIgnoreCols(expectedDataset.getTable(tableName),
  76.                 actualDataset.getTable(tableName), ignoreCols);
  77.     }

  79.     /**
  80.      * Compare the given tables ignoring specified columns.
  81.      *
  82.      * @param expectedTable
  83.      *            First table.
  84.      * @param actualTable
  85.      *            Second table.
  86.      * @param ignoreCols
  87.      *            Columns to be ignored in comparison.
  88.      * @throws org.dbunit.DatabaseUnitException
  89.      *             If an error occurs.
  90.      */
  91.     public void assertEqualsIgnoreCols(final ITable expectedTable,
  92.             final ITable actualTable, final String[] ignoreCols)
  93.             throws DatabaseUnitException
  94.     {
  95.         logger.debug(
  96.                 "assertEqualsIgnoreCols(expectedTable={}, actualTable={}, ignoreCols={}) - start",
  97.                 expectedTable, actualTable, ignoreCols);

  99.         final ITable expectedTableFiltered = DefaultColumnFilter
  100.                 .excludedColumnsTable(expectedTable, ignoreCols);
  101.         final ITable actualTableFiltered = DefaultColumnFilter
  102.                 .excludedColumnsTable(actualTable, ignoreCols);
  103.         assertEquals(expectedTableFiltered, actualTableFiltered);
  104.     }

  106.     /**
  107.      * Compare a table from a dataset with a table generated from an sql query.
  108.      *
  109.      * @param expectedDataset
  110.      *            Dataset to retrieve the first table from.
  111.      * @param connection
  112.      *            Connection to use for the SQL statement.
  113.      * @param sqlQuery
  114.      *            SQL query that will build the data in returned second table
  115.      *            rows.
  116.      * @param tableName
  117.      *            Table name of the table to compare.
  118.      * @param ignoreCols
  119.      *            Columns to be ignored in comparison.
  120.      * @throws DatabaseUnitException
  121.      *             If an error occurs while performing the comparison.
  122.      * @throws java.sql.SQLException
  123.      *             If an SQL error occurs.
  124.      */
  125.     public void assertEqualsByQuery(final IDataSet expectedDataset,
  126.             final IDatabaseConnection connection, final String sqlQuery,
  127.             final String tableName, final String[] ignoreCols)
  128.             throws DatabaseUnitException, SQLException
  129.     {
  130.         logger.debug(
  131.                 "assertEqualsByQuery(expectedDataset={}, connection={}, tableName={}, sqlQuery={}, ignoreCols={}) - start",
  132.                 expectedDataset, connection, tableName, sqlQuery, ignoreCols);

  134.         final ITable expectedTable = expectedDataset.getTable(tableName);
  135.         assertEqualsByQuery(expectedTable, connection, tableName, sqlQuery,
  136.                 ignoreCols);
  137.     }

  139.     /**
  140.      * Compare a table with a table generated from an sql query.
  141.      *
  142.      * @param expectedTable
  143.      *            Table containing all expected results.
  144.      * @param connection
  145.      *            Connection to use for the SQL statement.
  146.      * @param tableName
  147.      *            The name of the table to query from the database.
  148.      * @param sqlQuery
  149.      *            SQL query that will build the data in returned second table
  150.      *            rows.
  151.      * @param ignoreCols
  152.      *            Columns to be ignored in comparison.
  153.      * @throws DatabaseUnitException
  154.      *             If an error occurs while performing the comparison.
  155.      * @throws java.sql.SQLException
  156.      *             If an SQL error occurs.
  157.      */
  158.     public void assertEqualsByQuery(final ITable expectedTable,
  159.             final IDatabaseConnection connection, final String tableName,
  160.             final String sqlQuery, final String[] ignoreCols)
  161.             throws DatabaseUnitException, SQLException
  162.     {
  163.         logger.debug(
  164.                 "assertEqualsByQuery(expectedTable={}, connection={}, tableName={}, sqlQuery={}, ignoreCols={}) - start",
  165.                 expectedTable, connection, tableName, sqlQuery, ignoreCols);

  167.         final ITable expected = DefaultColumnFilter
  168.                 .excludedColumnsTable(expectedTable, ignoreCols);
  169.         final ITable queriedTable =
  170.                 connection.createQueryTable(tableName, sqlQuery);
  171.         final ITable actual = DefaultColumnFilter
  172.                 .excludedColumnsTable(queriedTable, ignoreCols);
  173.         assertEquals(expected, actual);
  174.     }

  176.     /**
  177.      * Asserts that the two specified dataset are equals. This method ignore the
  178.      * tables order.
  179.      */
  180.     public void assertEquals(final IDataSet expectedDataSet,
  181.             final IDataSet actualDataSet) throws DatabaseUnitException
  182.     {
  183.         logger.debug(
  184.                 "assertEquals(expectedDataSet={}, actualDataSet={}) - start",
  185.                 expectedDataSet, actualDataSet);
  186.         assertEquals(expectedDataSet, actualDataSet, null);
  187.     }

  189.     /**
  190.      * Asserts that the two specified dataset are equals. This method ignore the
  191.      * tables order.
  192.      *
  193.      * @since 2.4
  194.      */
  195.     public void assertEquals(final IDataSet expectedDataSet,
  196.             final IDataSet actualDataSet, final FailureHandler failureHandler)
  197.             throws DatabaseUnitException
  198.     {
  199.         assertWithValueComparer(expectedDataSet, actualDataSet, failureHandler,
  200.                 null, null);
  201.     }

  203.     protected void compareTables(final IDataSet expectedDataSet,
  204.             final IDataSet actualDataSet, final String[] expectedNames,
  205.             final FailureHandler failureHandler) throws DatabaseUnitException
  206.     {
  207.         compareTables(expectedDataSet, actualDataSet, expectedNames,
  208.                 failureHandler, null, null);
  209.     }

  211.     /**
  212.      * Asserts that the two specified tables are equals. This method ignores the
  213.      * table names, the columns order, the columns data type and which columns
  214.      * are composing the primary keys.
  215.      *
  216.      * @param expectedTable
  217.      *            Table containing all expected results.
  218.      * @param actualTable
  219.      *            Table containing all actual results.
  220.      * @throws DatabaseUnitException
  221.      */
  222.     public void assertEquals(final ITable expectedTable,
  223.             final ITable actualTable) throws DatabaseUnitException
  224.     {
  225.         logger.debug("assertEquals(expectedTable={}, actualTable={}) - start",
  226.                 expectedTable, actualTable);
  227.         assertEquals(expectedTable, actualTable, (Column[]) null);
  228.     }

  230.     /**
  231.      * Asserts that the two specified tables are equals. This method ignores the
  232.      * table names, the columns order, the columns data type and which columns
  233.      * are composing the primary keys. <br />
  234.      * Example: <code><pre>
  235.      * ITable actualTable = ...;
  236.      * ITable expectedTable = ...;
  237.      * ITableMetaData metaData = actualTable.getTableMetaData();
  238.      * Column[] additionalInfoCols = Columns.getColumns(new String[] {"MY_PK_COLUMN"}, metaData.getColumns());
  239.      * assertEquals(expectedTable, actualTable, additionalInfoCols);
  240.      * </pre></code>
  241.      *
  242.      * @param expectedTable
  243.      *            Table containing all expected results.
  244.      * @param actualTable
  245.      *            Table containing all actual results.
  246.      * @param additionalColumnInfo
  247.      *            The columns to be printed out if the assert fails because of a
  248.      *            data mismatch. Provides some additional column values that may
  249.      *            be useful to quickly identify the columns for which the
  250.      *            mismatch occurred (for example a primary key column). Can be
  251.      *            <code>null</code>.
  252.      * @throws DatabaseUnitException
  253.      */
  254.     public void assertEquals(final ITable expectedTable,
  255.             final ITable actualTable, final Column[] additionalColumnInfo)
  256.             throws DatabaseUnitException
  257.     {
  258.         logger.debug(
  259.                 "assertEquals(expectedTable={}, actualTable={}, additionalColumnInfo={}) - start",
  260.                 expectedTable, actualTable, additionalColumnInfo);

  262.         FailureHandler failureHandler = null;
  263.         if (additionalColumnInfo != null)
  264.         {
  265.             failureHandler = getDefaultFailureHandler(additionalColumnInfo);
  266.         }

  268.         assertEquals(expectedTable, actualTable, failureHandler);
  269.     }

  271.     /**
  272.      * Asserts that the two specified tables are equals. This method ignores the
  273.      * table names, the columns order, the columns data type and which columns
  274.      * are composing the primary keys. <br />
  275.      * Example: <code><pre>
  276.      * ITable actualTable = ...;
  277.      * ITable expectedTable = ...;
  278.      * ITableMetaData metaData = actualTable.getTableMetaData();
  279.      * FailureHandler failureHandler = new DefaultFailureHandler();
  280.      * assertEquals(expectedTable, actualTable, failureHandler);
  281.      * </pre></code>
  282.      *
  283.      * @param expectedTable
  284.      *            Table containing all expected results.
  285.      * @param actualTable
  286.      *            Table containing all actual results.
  287.      * @param failureHandler
  288.      *            The failure handler used if the assert fails because of a data
  289.      *            mismatch. Provides some additional information that may be
  290.      *            useful to quickly identify the rows for which the mismatch
  291.      *            occurred (for example by printing an additional primary key
  292.      *            column). Can be <code>null</code>.
  293.      * @throws DatabaseUnitException
  294.      * @since 2.4
  295.      */
  296.     public void assertEquals(final ITable expectedTable,
  297.             final ITable actualTable, final FailureHandler failureHandler)
  298.             throws DatabaseUnitException
  299.     {
  300.         assertWithValueComparer(expectedTable, actualTable, failureHandler,
  301.                 ValueComparers.isActualEqualToExpectedWithEmptyFailMessage,
  302.                 null);
  303.     }

  305.     /**
  306.      * Represents a single column to be used for the comparison of table data.
  307.      * It contains the {@link DataType} to be used for comparing the given
  308.      * column. This {@link DataType} matches the expected and actual column's
  309.      * datatype.
  310.      *
  311.      * @author gommma (gommma AT users.sourceforge.net)
  312.      * @author Last changed by: $Author: gommma $
  313.      * @version $Revision: 864 $ $Date: 2008-11-07 06:27:26 -0800 (Fri, 07 Nov
  314.      *          2008) $
  315.      * @since 2.4.0
  316.      */
  317.     public static class ComparisonColumn
  318.     {
  319.         private static final Logger logger =
  320.                 LoggerFactory.getLogger(ComparisonColumn.class);

  322.         private String columnName;
  323.         private DataType dataType;

  325.         /**
  326.          * @param tableName
  327.          *            The table name which is only needed for debugging output.
  328.          * @param expectedColumn
  329.          *            The expected column needed to resolve the {@link DataType}
  330.          *            to use for the actual comparison.
  331.          * @param actualColumn
  332.          *            The actual column needed to resolve the {@link DataType}
  333.          *            to use for the actual comparison.
  334.          * @param failureHandler
  335.          *            The {@link FailureHandler} to be used when no datatype can
  336.          *            be determined.
  337.          */
  338.         public ComparisonColumn(final String tableName,
  339.                 final Column expectedColumn, final Column actualColumn,
  340.                 final FailureHandler failureHandler)
  341.         {
  342.             this.columnName = expectedColumn.getColumnName();
  343.             this.dataType = getComparisonDataType(tableName, expectedColumn,
  344.                     actualColumn, failureHandler);
  345.         }

  347.         /**
  348.          * @return The column actually being compared.
  349.          */
  350.         public String getColumnName()
  351.         {
  352.             return this.columnName;
  353.         }

  355.         /**
  356.          * @return The {@link DataType} to use for the actual comparison.
  357.          */
  358.         public DataType getDataType()
  359.         {
  360.             return this.dataType;
  361.         }

  363.         /**
  364.          * @param tableName
  365.          *            The table name which is only needed for debugging output.
  366.          * @param expectedColumn
  367.          * @param actualColumn
  368.          * @param failureHandler
  369.          *            The {@link FailureHandler} to be used when no datatype can
  370.          *            be determined.
  371.          * @return The dbunit {@link DataType} to use for comparing the given
  372.          *         column.
  373.          */
  374.         private DataType getComparisonDataType(final String tableName,
  375.                 final Column expectedColumn, final Column actualColumn,
  376.                 final FailureHandler failureHandler)
  377.         {
  378.             logger.debug(
  379.                     "getComparisonDataType(tableName={}, expectedColumn={}, actualColumn={}, failureHandler={}) - start",
  380.                     tableName, expectedColumn, actualColumn, failureHandler);

  382.             final DataType expectedDataType = expectedColumn.getDataType();
  383.             final DataType actualDataType = actualColumn.getDataType();

  385.             // The two columns have different data type
  386.             if (!expectedDataType.getClass().isInstance(actualDataType))
  387.             {
  388.                 // Expected column data type is unknown, use actual column data
  389.                 // type
  390.                 if (expectedDataType instanceof UnknownDataType)
  391.                 {
  392.                     return actualDataType;
  393.                 }

  395.                 // Actual column data type is unknown, use expected column data
  396.                 // type
  397.                 if (actualDataType instanceof UnknownDataType)
  398.                 {
  399.                     return expectedDataType;
  400.                 }

  402.                 // Impossible to determine which data type to use
  403.                 final String msg = "Incompatible data types: (table="
  404.                         + tableName + ", col=" + expectedColumn.getColumnName()
  405.                         + ")";
  406.                 throw failureHandler.createFailure(msg,
  407.                         String.valueOf(expectedDataType),
  408.                         String.valueOf(actualDataType));
  409.             }

  411.             // Both columns have same data type, return any one of them
  412.             return expectedDataType;
  413.         }
  414.     }
  415. }
Created with JaCoCo 0.8.3.201901230119