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;
22
23 import java.util.Arrays;
24 import java.util.Map;
25
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;
29
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;
43
44 /** The columns to exclude in table comparisons. */
45 private final String[] columnExclusionFilters;
46
47 /** The columns to include in table comparisons. */
48 private final String[] columnInclusionFilters;
49
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;
58
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;
65
66 private VerifyTableDefinitionVerifier verifyTableDefinitionVerifier =
67 new DefaultVerifyTableDefinitionVerifier();
68
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 }
84
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 }
111
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 }
143
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 }
162
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 }
199
200 tableName = table;
201 columnExclusionFilters = excludeColumns;
202 columnInclusionFilters = includeColumns;
203 this.defaultValueComparer = defaultValueComparer;
204 this.columnValueComparers = columnValueComparers;
205
206 verifyTableDefinitionVerifier.verify(this);
207 }
208
209 public String getTableName()
210 {
211 return tableName;
212 }
213
214 public String[] getColumnExclusionFilters()
215 {
216 return columnExclusionFilters;
217 }
218
219 public String[] getColumnInclusionFilters()
220 {
221 return columnInclusionFilters;
222 }
223
224 /** @since 2.6.0 */
225 public ValueComparer getDefaultValueComparer()
226 {
227 return defaultValueComparer;
228 }
229
230 /** @since 2.6.0 */
231 public Map<String, ValueComparer> getColumnValueComparers()
232 {
233 return columnValueComparers;
234 }
235
236 /**
237 * {@inheritDoc}
238 */
239 @Override
240 public String toString()
241 {
242 final String exclusionString = arrayToString(columnExclusionFilters);
243 final String inclusionString = arrayToString(columnInclusionFilters);
244
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 }
257
258 protected String arrayToString(final String[] array)
259 {
260 return array == null ? "" : Arrays.toString(array);
261 }
262
263 public VerifyTableDefinitionVerifier getVerifyTableDefinitionVerifier()
264 {
265 return verifyTableDefinitionVerifier;
266 }
267
268 public void setVerifyTableDefinitionVerifier(
269 final VerifyTableDefinitionVerifier verifyTableDefinitionVerifier)
270 {
271 this.verifyTableDefinitionVerifier = verifyTableDefinitionVerifier;
272 }
273 }