VerifyTableDefinition.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;

  23. import java.util.Arrays;
  24. import java.util.Map;

  26. import org.dbunit.assertion.comparer.value.ValueComparer;
  27. import org.dbunit.assertion.comparer.value.verifier.DefaultVerifyTableDefinitionVerifier;
  28. import org.dbunit.assertion.comparer.value.verifier.VerifyTableDefinitionVerifier;

  30. /**
  31.  * Defines a database table to verify (assert on data), specifying include and
  32.  * exclude column filters and optional {@link ValueComparer}s.
  33.  *
  34.  * @author Jeff Jensen jeffjensen AT users.sourceforge.net
  35.  * @author Last changed by: $Author$
  36.  * @version $Revision$ $Date$
  37.  * @since 2.4.8
  38.  */
  39. public class VerifyTableDefinition
  40. {
  41.     /** The name of the table. */
  42.     private final String tableName;

  44.     /** The columns to exclude in table comparisons. */
  45.     private final String[] columnExclusionFilters;

  47.     /** The columns to include in table comparisons. */
  48.     private final String[] columnInclusionFilters;

  50.     /**
  51.      * {@link ValueComparer} to use with column value comparisons when the
  52.      * column name for the table is not in the {@link columnValueComparers}
  53.      * {@link Map}. Can be <code>null</code> and will default.
  54.      *
  55.      * @since 2.6.0
  56.      */
  57.     private final ValueComparer defaultValueComparer;

  59.     /**
  60.      * Map of column names to {@link ValueComparer}s to use for comparison.
  61.      * 
  62.      * @since 2.6.0
  63.      */
  64.     private final Map<String, ValueComparer> columnValueComparers;

  66.     private VerifyTableDefinitionVerifier verifyTableDefinitionVerifier =
  67.             new DefaultVerifyTableDefinitionVerifier();

  69.     /**
  70.      * Create a valid instance with all columns compared except exclude the
  71.      * specified columns.
  72.      *
  73.      * @param table
  74.      *            The name of the table - required.
  75.      * @param excludeColumns
  76.      *            The columns in the table to ignore (filter out) in expected vs
  77.      *            actual comparisons; null or empty array to exclude no columns.
  78.      */
  79.     public VerifyTableDefinition(final String table,
  80.             final String[] excludeColumns)
  81.     {
  82.         this(table, excludeColumns, null, null, null);
  83.     }

  85.     /**
  86.      * Create a valid instance with all columns compared and use the specified
  87.      * defaultValueComparer for all column comparisons not in the
  88.      * columnValueComparers {@link Map}.
  89.      *
  90.      * @param table
  91.      *            The name of the table - required.
  92.      * @param defaultValueComparer
  93.      *            {@link ValueComparer} to use with column value comparisons
  94.      *            when the column name for the table is not in the
  95.      *            columnValueComparers {@link Map}. Can be <code>null</code> and
  96.      *            will default.
  97.      * @param columnValueComparers
  98.      *            {@link Map} of {@link ValueComparer}s to use for specific
  99.      *            columns. Key is column name, value is {@link ValueComparer} to
  100.      *            use for comparison of that column. Can be <code>null</code>
  101.      *            and will default to defaultValueComparer for all columns in
  102.      *            all tables.
  103.      * @since 2.6.0
  104.      */
  105.     public VerifyTableDefinition(final String table,
  106.             final ValueComparer defaultValueComparer,
  107.             final Map<String, ValueComparer> columnValueComparers)
  108.     {
  109.         this(table, null, null, defaultValueComparer, columnValueComparers);
  110.     }

  112.     /**
  113.      * Create a valid instance with all columns compared and exclude the
  114.      * specified columns, and use the specified defaultValueComparer for all
  115.      * column comparisons not in the columnValueComparers {@link Map}.
  116.      *
  117.      * @param table
  118.      *            The name of the table - required.
  119.      * @param excludeColumns
  120.      *            The columns in the table to ignore (filter out) in expected vs
  121.      *            actual comparisons; null or empty array to exclude no columns.
  122.      * @param defaultValueComparer
  123.      *            {@link ValueComparer} to use with column value comparisons
  124.      *            when the column name for the table is not in the
  125.      *            columnValueComparers {@link Map}. Can be <code>null</code> and
  126.      *            will default.
  127.      * @param columnValueComparers
  128.      *            {@link Map} of {@link ValueComparer}s to use for specific
  129.      *            columns. Key is column name, value is {@link ValueComparer} to
  130.      *            use for comparison of that column. Can be <code>null</code>
  131.      *            and will default to defaultValueComparer for all columns in
  132.      *            all tables.
  133.      * @since 2.6.0
  134.      */
  135.     public VerifyTableDefinition(final String table,
  136.             final String[] excludeColumns,
  137.             final ValueComparer defaultValueComparer,
  138.             final Map<String, ValueComparer> columnValueComparers)
  139.     {
  140.         this(table, excludeColumns, null, defaultValueComparer,
  141.                 columnValueComparers);
  142.     }

  144.     /**
  145.      * Create a valid instance specifying exclude and include columns.
  146.      *
  147.      * @param table
  148.      *            The name of the table.
  149.      * @param excludeColumns
  150.      *            The columns in the table to ignore (filter out) in expected vs
  151.      *            actual comparisons; null or empty array to exclude no columns.
  152.      * @param includeColumns
  153.      *            The columns in the table to include in expected vs actual
  154.      *            comparisons; null to include all columns, empty array to
  155.      *            include no columns.
  156.      */
  157.     public VerifyTableDefinition(final String table,
  158.             final String[] excludeColumns, final String[] includeColumns)
  159.     {
  160.         this(table, excludeColumns, includeColumns, null, null);
  161.     }

  163.     /**
  164.      * Create a valid instance specifying exclude and include columns and use
  165.      * the specified defaultValueComparer for all column comparisons not in the
  166.      * columnValueComparers {@link Map}.
  167.      *
  168.      * @param table
  169.      *            The name of the table.
  170.      * @param excludeColumns
  171.      *            The columns in the table to ignore (filter out) in expected vs
  172.      *            actual comparisons; null or empty array to exclude no columns.
  173.      * @param includeColumns
  174.      *            The columns in the table to include in expected vs actual
  175.      *            comparisons; null to include all columns, empty array to
  176.      *            include no columns.
  177.      * @param defaultValueComparer
  178.      *            {@link ValueComparer} to use with column value comparisons
  179.      *            when the column name for the table is not in the
  180.      *            columnValueComparers {@link Map}. Can be <code>null</code> and
  181.      *            will default.
  182.      * @param columnValueComparers
  183.      *            {@link Map} of {@link ValueComparer}s to use for specific
  184.      *            columns. Key is column name, value is {@link ValueComparer} to
  185.      *            use for comparison of that column. Can be <code>null</code>
  186.      *            and will default to defaultValueComparer for all columns in
  187.      *            all tables.
  188.      * @since 2.6.0
  189.      */
  190.     public VerifyTableDefinition(final String table,
  191.             final String[] excludeColumns, final String[] includeColumns,
  192.             final ValueComparer defaultValueComparer,
  193.             final Map<String, ValueComparer> columnValueComparers)
  194.     {
  195.         if (table == null)
  196.         {
  197.             throw new IllegalArgumentException("table is null.");
  198.         }

  200.         tableName = table;
  201.         columnExclusionFilters = excludeColumns;
  202.         columnInclusionFilters = includeColumns;
  203.         this.defaultValueComparer = defaultValueComparer;
  204.         this.columnValueComparers = columnValueComparers;

  206.         verifyTableDefinitionVerifier.verify(this);
  207.     }

  209.     public String getTableName()
  210.     {
  211.         return tableName;
  212.     }

  214.     public String[] getColumnExclusionFilters()
  215.     {
  216.         return columnExclusionFilters;
  217.     }

  219.     public String[] getColumnInclusionFilters()
  220.     {
  221.         return columnInclusionFilters;
  222.     }

  224.     /** @since 2.6.0 */
  225.     public ValueComparer getDefaultValueComparer()
  226.     {
  227.         return defaultValueComparer;
  228.     }

  230.     /** @since 2.6.0 */
  231.     public Map<String, ValueComparer> getColumnValueComparers()
  232.     {
  233.         return columnValueComparers;
  234.     }

  236.     /**
  237.      * {@inheritDoc}
  238.      */
  239.     @Override
  240.     public String toString()
  241.     {
  242.         final String exclusionString = arrayToString(columnExclusionFilters);
  243.         final String inclusionString = arrayToString(columnInclusionFilters);

  245.         final StringBuilder sb = new StringBuilder(1000);
  246.         sb.append("tableName='").append(tableName).append("'");
  247.         sb.append(", columnExclusionFilters='").append(exclusionString)
  248.                 .append("'");
  249.         sb.append(", columnInclusionFilters='").append(inclusionString)
  250.                 .append("'");
  251.         sb.append(", defaultValueComparer='").append(defaultValueComparer)
  252.                 .append("'");
  253.         sb.append(", columnValueComparers='").append(columnValueComparers)
  254.                 .append("'");
  255.         return sb.toString();
  256.     }

  258.     protected String arrayToString(final String[] array)
  259.     {
  260.         return array == null ? "" : Arrays.toString(array);
  261.     }

  263.     public VerifyTableDefinitionVerifier getVerifyTableDefinitionVerifier()
  264.     {
  265.         return verifyTableDefinitionVerifier;
  266.     }

  268.     public void setVerifyTableDefinitionVerifier(
  269.             final VerifyTableDefinitionVerifier verifyTableDefinitionVerifier)
  270.     {
  271.         this.verifyTableDefinitionVerifier = verifyTableDefinitionVerifier;
  272.     }
  273. }
Created with JaCoCo 0.8.3.201901230119