1 package org.dbunit.assertion;
2
3 import static org.assertj.core.api.Assertions.assertThatThrownBy;
4 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
5
6 import java.io.IOException;
7 import java.util.Map;
8
9 import org.dbunit.assertion.comparer.value.ValueComparer;
10 import org.dbunit.assertion.comparer.value.ValueComparers;
11 import org.dbunit.assertion.comparer.value.builder.ColumnValueComparerMapBuilder;
12 import org.dbunit.dataset.Column;
13 import org.dbunit.dataset.DataSetException;
14 import org.dbunit.dataset.DefaultDataSet;
15 import org.dbunit.dataset.DefaultTable;
16 import org.dbunit.dataset.IDataSet;
17 import org.dbunit.dataset.ITable;
18 import org.dbunit.dataset.datatype.DataType;
19 import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
20 import org.dbunit.testutil.TestUtils;
21 import org.junit.jupiter.api.Test;
22
23 public class DbUnitValueComparerAssertIT
24 {
25 public static final String FILE_PATH = "xml/assertionTest.xml";
26
27 private final DbUnitValueComparerAssert sut =
28 new DbUnitValueComparerAssert();
29
30 private IDataSet getDataSet() throws DataSetException, IOException
31 {
32 return new FlatXmlDataSetBuilder()
33 .build(TestUtils.getFileReader(FILE_PATH));
34 }
35
36 @Test
37 void testAssertWithValueComparerITableITableValueComparer_AllRowsEqual_NoFail()
38 throws Exception
39 {
40 final IDataSet dataSet = getDataSet();
41
42 final ITable expectedTable = dataSet.getTable("TEST_TABLE");
43 final ITable actualTable =
44 dataSet.getTable("TEST_TABLE_WITH_SAME_VALUE");
45 final ValueComparer defaultValueComparer =
46 ValueComparers.isActualEqualToExpected;
47 assertDoesNotThrow(() -> sut.assertWithValueComparer(expectedTable,
48 actualTable, defaultValueComparer));
49 }
50
51 @Test
52 void testAssertWithValueComparerITableITableValueComparerMap_OneColumnNotEqual_NoFail()
53 throws Exception
54 {
55 final IDataSet dataSet = getDataSet();
56
57 final ITable expectedTable = dataSet.getTable("TEST_TABLE");
58 final ITable actualTable =
59 dataSet.getTable("TEST_TABLE_WITH_WRONG_VALUE_ALL_ROWS");
60 final ValueComparer defaultValueComparer =
61 ValueComparers.isActualEqualToExpected;
62 final ValueComparer valueComparer =
63 ValueComparers.isActualNotEqualToExpected;
64 final Map<String, ValueComparer> columnValueComparers =
65 new ColumnValueComparerMapBuilder()
66 .add("COLUMN2", valueComparer).build();
67 assertDoesNotThrow(() -> sut.assertWithValueComparer(expectedTable,
68 actualTable, defaultValueComparer, columnValueComparers));
69 }
70
71 @Test
72 void testAssertWithValueComparer_isActualGreaterThan_passesWhenActualIsLarger()
73 throws Exception
74 {
75 final Column[] columns = new Column[]{new Column("SCORE", DataType.INTEGER)};
76
77 final DefaultTable expected = new DefaultTable("T", columns);
78 expected.addRow(new Object[]{10});
79
80 final DefaultTable actual = new DefaultTable("T", columns);
81 actual.addRow(new Object[]{20});
82
83 assertDoesNotThrow(() -> sut.assertWithValueComparer(expected, actual,
84 ValueComparers.isActualGreaterThanExpected));
85 }
86
87 @Test
88 void testAssertWithValueComparer_isActualGreaterThan_failsWhenActualIsSmaller()
89 throws Exception
90 {
91 final Column[] columns = new Column[]{new Column("SCORE", DataType.INTEGER)};
92
93 final DefaultTable expected = new DefaultTable("T", columns);
94 expected.addRow(new Object[]{100});
95
96 final DefaultTable actual = new DefaultTable("T", columns);
97 actual.addRow(new Object[]{5});
98
99 assertThatThrownBy(() -> sut.assertWithValueComparer(expected, actual,
100 ValueComparers.isActualGreaterThanExpected))
101 .as("Smaller actual should fail isActualGreaterThan.")
102 .isInstanceOf(DbComparisonFailure.class);
103 }
104
105 @Test
106 void testAssertWithValueComparer_regularExpression_passesWhenActualMatchesPattern()
107 throws Exception
108 {
109 final Column[] columns =
110 new Column[]{new Column("ID", DataType.VARCHAR)};
111
112 final DefaultTable expected = new DefaultTable("T", columns);
113 expected.addRow(new Object[]{"[0-9]+"});
114
115 final DefaultTable actual = new DefaultTable("T", columns);
116 actual.addRow(new Object[]{"4071"});
117
118 assertDoesNotThrow(() -> sut.assertWithValueComparer(expected, actual,
119 ValueComparers.regularExpressionValueComparer));
120 }
121
122 @Test
123 void testAssertWithValueComparer_regularExpression_failsWhenActualDoesNotMatchPattern()
124 throws Exception
125 {
126 final Column[] columns =
127 new Column[]{new Column("ID", DataType.VARCHAR)};
128
129 final DefaultTable expected = new DefaultTable("T", columns);
130 expected.addRow(new Object[]{"[0-9]+"});
131
132 final DefaultTable actual = new DefaultTable("T", columns);
133 actual.addRow(new Object[]{"4071-A"});
134
135 assertThatThrownBy(() -> sut.assertWithValueComparer(expected, actual,
136 ValueComparers.regularExpressionValueComparer))
137 .as("A value not matching the pattern should fail the comparison.")
138 .isInstanceOf(DbComparisonFailure.class);
139 }
140
141 @Test
142 void testAssertWithValueComparer_isActualNull_passesWhenActualIsNull()
143 throws Exception
144 {
145 final Column[] columns = new Column[]{new Column("VAL", DataType.VARCHAR)};
146
147 final DefaultTable expected = new DefaultTable("T", columns);
148 expected.addRow(new Object[]{"anything"});
149
150 final DefaultTable actual = new DefaultTable("T", columns);
151 actual.addRow(new Object[]{null});
152
153 assertDoesNotThrow(() -> sut.assertWithValueComparer(expected, actual,
154 ValueComparers.isActualNullValueComparer));
155 }
156
157 @Test
158 void testAssertWithValueComparer_isActualNotNull_passesWhenActualIsNotNull()
159 throws Exception
160 {
161 final Column[] columns = new Column[]{new Column("VAL", DataType.VARCHAR)};
162
163 final DefaultTable expected = new DefaultTable("T", columns);
164 expected.addRow(new Object[]{"anything"});
165
166 final DefaultTable actual = new DefaultTable("T", columns);
167 actual.addRow(new Object[]{"someValue"});
168
169 assertDoesNotThrow(() -> sut.assertWithValueComparer(expected, actual,
170 ValueComparers.isActualNotNullValueComparer));
171 }
172 }