Clover Coverage Report - Liquibase Core 2.0.3-SNAPSHOT
Coverage timestamp: Sat Aug 6 2011 11:33:15 EDT
Overview   Package   File
    FRAMES   NO FRAMES     
246   435   32   10.7
18   353   0.13   23
23     1.39  
1    
 
  AddColumnChangeTest       Line # 21 246 0% 32 0 100% 1.0
 
  (13)
 
1    package liquibase.change.core;
2   
3    import liquibase.change.AbstractChangeTest;
4    import liquibase.change.Change;
5    import liquibase.change.ColumnConfig;
6    import liquibase.change.ConstraintsConfig;
7    import liquibase.database.Database;
8    import liquibase.database.core.DB2Database;
9    import liquibase.statement.SqlStatement;
10    import liquibase.statement.ColumnConstraint;
11    import liquibase.statement.ForeignKeyConstraint;
12    import liquibase.statement.core.AddColumnStatement;
13    import liquibase.statement.core.ReorganizeTableStatement;
14    import liquibase.statement.core.UpdateStatement;
15    import static org.junit.Assert.*;
16    import org.junit.Test;
17   
18    /**
19    * Tests for {@link AddColumnChange}
20    */
 
21    public class AddColumnChangeTest extends AbstractChangeTest {
22   
23   
 
24  1 toggle @Override
25    public void validate() throws Exception {
26  1 super.validate(); //To change body of overridden methods use File | Settings | File Templates.
27    }
28   
 
29  1 toggle @Override
30    @Test
31    public void getRefactoringName() throws Exception {
32  1 AddColumnChange refactoring = new AddColumnChange();
33  1 assertEquals("Add Column", refactoring.getChangeMetaData().getDescription());
34    }
35   
 
36  1 toggle @Test
37    public void addColumn() throws Exception {
38  1 AddColumnChange change = new AddColumnChange();
39  1 assertEquals(0, change.getColumns().size());
40   
41  1 change.addColumn(new ColumnConfig().setName("a"));
42  1 assertEquals(1, change.getColumns().size());
43   
44  1 change.addColumn(new ColumnConfig().setName("b"));
45  1 assertEquals(2, change.getColumns().size());
46    }
47   
 
48  1 toggle @Test
49    public void removeColumn() throws Exception {
50  1 ColumnConfig columnA = new ColumnConfig().setName("a");
51  1 ColumnConfig columnB = new ColumnConfig().setName("b");
52   
53  1 AddColumnChange change = new AddColumnChange();
54  1 assertEquals(0, change.getColumns().size());
55   
56  1 change.removeColumn(columnA);
57  1 assertEquals(0, change.getColumns().size());
58   
59  1 change.addColumn(columnA);
60  1 assertEquals(1, change.getColumns().size());
61   
62  1 change.removeColumn(columnB);
63  1 assertEquals(1, change.getColumns().size());
64   
65  1 change.removeColumn(columnA);
66  1 assertEquals(0, change.getColumns().size());
67    }
68   
 
69  1 toggle @Override
70    @Test
71    public void generateStatement() throws Exception {
72  1 AddColumnChange refactoring = new AddColumnChange();
73  1 refactoring.setSchemaName("SCHEMA");
74  1 refactoring.setTableName("TAB");
75   
76  1 ColumnConfig column = new ColumnConfig();
77  1 column.setName("NEWCOL");
78  1 column.setType("TYP");
79   
80  1 ConstraintsConfig constraints = new ConstraintsConfig();
81  1 constraints.setNullable(Boolean.FALSE);
82   
83  1 column.setConstraints(constraints);
84   
85  1 refactoring.addColumn(column);
86   
87    //Add the second column def to the same refactoring
88  1 column = new ColumnConfig();
89  1 column.setName("NEWCOL2");
90  1 column.setType("TYP2");
91  1 column.setConstraints(new ConstraintsConfig());
92  1 refactoring.addColumn(column);
93   
94  1 testChangeOnAll(refactoring, new GenerateAllValidator() {
 
95  15 toggle public void validate(SqlStatement[] sqlStatements, Database database) {
96   
97  15 if (database instanceof DB2Database) {
98  1 assertEquals(4, sqlStatements.length);
99  1 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
100  1 assertTrue(sqlStatements[1] instanceof ReorganizeTableStatement);
101  1 assertTrue(sqlStatements[2] instanceof AddColumnStatement);
102  1 assertTrue(sqlStatements[3] instanceof ReorganizeTableStatement);
103    } else {
104  14 assertEquals(2, sqlStatements.length);
105  14 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
106  14 assertTrue(sqlStatements[1] instanceof AddColumnStatement);
107    }
108   
109  15 AddColumnStatement firstAddColumnStatement = (AddColumnStatement) sqlStatements[0];
110  15 AddColumnStatement secondAddColumnStatement = null;
111  15 if (database instanceof DB2Database) {
112  1 secondAddColumnStatement = (AddColumnStatement) sqlStatements[2];
113    } else {
114  14 secondAddColumnStatement = (AddColumnStatement) sqlStatements[1];
115    }
116   
117  15 assertEquals("SCHEMA", firstAddColumnStatement.getSchemaName());
118  15 assertEquals("TAB", firstAddColumnStatement.getTableName());
119  15 assertEquals("NEWCOL", firstAddColumnStatement.getColumnName());
120  15 assertEquals("TYP", firstAddColumnStatement.getColumnType());
121  15 assertFalse(firstAddColumnStatement.isPrimaryKey());
122  15 assertFalse(firstAddColumnStatement.isNullable());
123   
124  15 assertEquals("SCHEMA", secondAddColumnStatement.getSchemaName());
125  15 assertEquals("TAB", secondAddColumnStatement.getTableName());
126  15 assertEquals("NEWCOL2", secondAddColumnStatement.getColumnName());
127  15 assertEquals("TYP2", secondAddColumnStatement.getColumnType());
128  15 assertTrue(secondAddColumnStatement.isNullable());
129    }
130    });
131    }
132   
 
133  1 toggle @Test
134    public void generateStatement_nullable() throws Exception {
135  1 AddColumnChange refactoring = new AddColumnChange();
136  1 refactoring.setSchemaName("SCHEMA");
137  1 refactoring.setTableName("TAB");
138  1 ColumnConfig column = new ColumnConfig();
139  1 column.setName("NEWCOL");
140  1 column.setType("TYP");
141   
142  1 ConstraintsConfig constraints = new ConstraintsConfig();
143  1 constraints.setNullable(Boolean.TRUE);
144   
145  1 column.setConstraints(constraints);
146   
147  1 refactoring.addColumn(column);
148   
149  1 testChangeOnAll(refactoring, new GenerateAllValidator() {
 
150  15 toggle public void validate(SqlStatement[] sqlStatements, Database database) {
151   
152  15 if (database instanceof DB2Database) {
153  1 assertEquals(2, sqlStatements.length);
154  1 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
155  1 assertTrue(sqlStatements[1] instanceof ReorganizeTableStatement);
156    } else {
157  14 assertEquals(1, sqlStatements.length);
158  14 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
159    }
160   
161  15 assertEquals("SCHEMA", ((AddColumnStatement) sqlStatements[0]).getSchemaName());
162  15 assertEquals("TAB", ((AddColumnStatement) sqlStatements[0]).getTableName());
163  15 assertEquals("NEWCOL", ((AddColumnStatement) sqlStatements[0]).getColumnName());
164  15 assertEquals("TYP", ((AddColumnStatement) sqlStatements[0]).getColumnType());
165  15 assertFalse(((AddColumnStatement) sqlStatements[0]).isPrimaryKey());
166  15 assertTrue(((AddColumnStatement) sqlStatements[0]).isNullable());
167    }
168    });
169    }
170   
 
171  1 toggle @Test
172    public void generateStatement_notNull() throws Exception {
173  1 AddColumnChange refactoring = new AddColumnChange();
174  1 refactoring.setSchemaName("SCHEMA");
175  1 refactoring.setTableName("TAB");
176  1 ColumnConfig column = new ColumnConfig();
177  1 column.setName("NEWCOL");
178  1 column.setType("TYP");
179   
180  1 ConstraintsConfig constraints = new ConstraintsConfig();
181  1 constraints.setNullable(Boolean.FALSE);
182   
183  1 column.setConstraints(constraints);
184   
185  1 refactoring.addColumn(column);
186   
187  1 testChangeOnAll(refactoring, new GenerateAllValidator() {
 
188  15 toggle public void validate(SqlStatement[] sqlStatements, Database database) {
189  15 if (database instanceof DB2Database) {
190  1 assertEquals(2, sqlStatements.length);
191  1 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
192  1 assertTrue(sqlStatements[1] instanceof ReorganizeTableStatement);
193    } else {
194  14 assertEquals(1, sqlStatements.length);
195  14 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
196    }
197   
198  15 assertEquals("SCHEMA", ((AddColumnStatement) sqlStatements[0]).getSchemaName());
199  15 assertEquals("TAB", ((AddColumnStatement) sqlStatements[0]).getTableName());
200  15 assertEquals("NEWCOL", ((AddColumnStatement) sqlStatements[0]).getColumnName());
201  15 assertEquals("TYP", ((AddColumnStatement) sqlStatements[0]).getColumnType());
202  15 assertFalse(((AddColumnStatement) sqlStatements[0]).isPrimaryKey());
203  15 assertFalse(((AddColumnStatement) sqlStatements[0]).isNullable());
204    }
205    });
206    }
207   
 
208  1 toggle @Test
209    public void generateStatement_primaryKey() throws Exception {
210  1 AddColumnChange refactoring = new AddColumnChange();
211  1 refactoring.setSchemaName("SCHEMA");
212  1 refactoring.setTableName("TAB");
213  1 ColumnConfig column = new ColumnConfig();
214  1 column.setName("NEWCOL");
215  1 column.setType("TYP");
216   
217  1 ConstraintsConfig constraints = new ConstraintsConfig();
218  1 constraints.setNullable(Boolean.FALSE);
219  1 constraints.setPrimaryKey(Boolean.TRUE);
220   
221  1 column.setConstraints(constraints);
222   
223  1 refactoring.addColumn(column);
224   
225  1 testChangeOnAll(refactoring, new GenerateAllValidator() {
 
226  15 toggle public void validate(SqlStatement[] sqlStatements, Database database) {
227  15 if (database instanceof DB2Database) {
228  1 assertEquals(2, sqlStatements.length);
229  1 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
230  1 assertTrue(sqlStatements[1] instanceof ReorganizeTableStatement);
231    } else {
232  14 assertEquals(1, sqlStatements.length);
233  14 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
234    }
235   
236  15 assertTrue(((AddColumnStatement) sqlStatements[0]).isPrimaryKey());
237    }
238    });
239    }
240   
 
241  1 toggle @Test
242    public void generateStatement_foreignKey() throws Exception {
243  1 AddColumnChange refactoring = new AddColumnChange();
244  1 refactoring.setSchemaName("SCHEMA");
245  1 refactoring.setTableName("TAB");
246  1 ColumnConfig column = new ColumnConfig();
247  1 column.setName("NEWCOL");
248  1 column.setType("TYP");
249   
250  1 ConstraintsConfig constraints = new ConstraintsConfig();
251  1 constraints.setNullable(Boolean.FALSE);
252  1 constraints.setPrimaryKey(Boolean.TRUE);
253  1 constraints.setForeignKeyName("fk_name");
254  1 constraints.setReferences("ref_table(id)");
255   
256  1 column.setConstraints(constraints);
257   
258  1 refactoring.addColumn(column);
259   
260  1 testChangeOnAll(refactoring, new GenerateAllValidator() {
 
261  15 toggle public void validate(SqlStatement[] sqlStatements, Database database) {
262  15 if (database instanceof DB2Database) {
263  1 assertEquals(2, sqlStatements.length);
264  1 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
265  1 assertTrue(sqlStatements[1] instanceof ReorganizeTableStatement);
266    } else {
267  14 assertEquals(1, sqlStatements.length);
268  14 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
269    }
270   
271  15 assertTrue(((AddColumnStatement) sqlStatements[0]).isPrimaryKey());
272  15 boolean foundFkInfo = false;
273  15 for (ColumnConstraint constraint : ((AddColumnStatement) sqlStatements[0]).getConstraints()) {
274  45 if (constraint instanceof ForeignKeyConstraint) {
275  15 foundFkInfo = true;
276    }
277    }
278  15 assertTrue("Did not find foreign key info", foundFkInfo);
279    }
280    });
281    }
282   
 
283  1 toggle @Test
284    public void generateStatement_withDefaultValue() throws Exception {
285  1 AddColumnChange refactoring = new AddColumnChange();
286  1 refactoring.setSchemaName("SCHEMA");
287  1 refactoring.setTableName("TAB");
288  1 ColumnConfig column = new ColumnConfig();
289  1 column.setName("NEWCOL");
290  1 column.setType("TYP");
291  1 column.setValue("SOME VALUE");
292   
293  1 ConstraintsConfig constraints = new ConstraintsConfig();
294  1 constraints.setNullable(Boolean.FALSE);
295  1 constraints.setPrimaryKey(Boolean.TRUE);
296  1 column.setAutoIncrement(Boolean.TRUE);
297   
298  1 column.setConstraints(constraints);
299   
300  1 refactoring.addColumn(column);
301   
302  1 testChangeOnAll(refactoring, new GenerateAllValidator() {
 
303  15 toggle public void validate(SqlStatement[] sqlStatements, Database database) {
304  15 if (database instanceof DB2Database) {
305  1 assertEquals(3, sqlStatements.length);
306  1 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
307  1 assertTrue(sqlStatements[1] instanceof ReorganizeTableStatement);
308  1 assertTrue(sqlStatements[2] instanceof UpdateStatement);
309    } else {
310  14 assertEquals(2, sqlStatements.length);
311  14 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
312  14 assertTrue(sqlStatements[1] instanceof UpdateStatement);
313    }
314   
315  15 assertTrue(((AddColumnStatement) sqlStatements[0]).isPrimaryKey());
316  15 assertTrue(((AddColumnStatement) sqlStatements[0]).isAutoIncrement());
317   
318  15 assertEquals("TAB", ((UpdateStatement) sqlStatements[sqlStatements.length - 1]).getTableName());
319  15 assertEquals("SOME VALUE", ((UpdateStatement) sqlStatements[sqlStatements.length - 1]).getNewColumnValues().get("NEWCOL"));
320    }
321    });
322    }
323   
 
324  1 toggle @Test
325    public void generateStatement_autoIncrement() throws Exception {
326  1 AddColumnChange refactoring = new AddColumnChange();
327  1 refactoring.setSchemaName("SCHEMA");
328  1 refactoring.setTableName("TAB");
329  1 ColumnConfig column = new ColumnConfig();
330  1 column.setName("NEWCOL");
331  1 column.setType("TYP");
332   
333  1 ConstraintsConfig constraints = new ConstraintsConfig();
334  1 constraints.setNullable(Boolean.FALSE);
335  1 constraints.setPrimaryKey(Boolean.TRUE);
336  1 column.setAutoIncrement(Boolean.TRUE);
337   
338  1 column.setConstraints(constraints);
339   
340  1 refactoring.addColumn(column);
341   
342  1 testChangeOnAll(refactoring, new GenerateAllValidator() {
 
343  15 toggle public void validate(SqlStatement[] sqlStatements, Database database) {
344  15 if (database instanceof DB2Database) {
345  1 assertEquals(2, sqlStatements.length);
346  1 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
347  1 assertTrue(sqlStatements[1] instanceof ReorganizeTableStatement);
348    } else {
349  14 assertEquals(1, sqlStatements.length);
350  14 assertTrue(sqlStatements[0] instanceof AddColumnStatement);
351    }
352   
353  15 assertTrue(((AddColumnStatement) sqlStatements[0]).isPrimaryKey());
354  15 assertTrue(((AddColumnStatement) sqlStatements[0]).isAutoIncrement());
355    }
356    });
357    }
358   
 
359  1 toggle @Test
360    public void createInverses_singleColumn() throws Exception {
361  1 AddColumnChange refactoring = new AddColumnChange();
362  1 refactoring.setSchemaName("SCHEMA");
363  1 refactoring.setTableName("TAB");
364  1 ColumnConfig column = new ColumnConfig();
365  1 column.setName("NEWCOL");
366  1 column.setType("TYP");
367   
368  1 ConstraintsConfig constraints = new ConstraintsConfig();
369  1 constraints.setNullable(Boolean.FALSE);
370  1 constraints.setPrimaryKey(Boolean.TRUE);
371  1 column.setAutoIncrement(Boolean.TRUE);
372   
373  1 column.setConstraints(constraints);
374   
375  1 refactoring.addColumn(column);
376   
377  1 testInverseOnAll(refactoring, new InverseValidator() {
 
378  15 toggle public void validate(Change[] changes) {
379  15 assertEquals(1, changes.length);
380  15 assertTrue(changes[0] instanceof DropColumnChange);
381  15 assertEquals("TAB", ((DropColumnChange) changes[0]).getTableName());
382  15 assertEquals("NEWCOL", ((DropColumnChange) changes[0]).getColumnName());
383   
384    }
385    });
386    }
387   
 
388  1 toggle @Test
389    public void createInverses_multiColumn() throws Exception {
390  1 AddColumnChange refactoring = new AddColumnChange();
391  1 refactoring.setSchemaName("SCHEMA");
392  1 refactoring.setTableName("TAB");
393  1 ColumnConfig column = new ColumnConfig();
394  1 column.setName("NEWCOL");
395  1 column.setType("TYP");
396   
397  1 ConstraintsConfig constraints = new ConstraintsConfig();
398  1 constraints.setNullable(Boolean.FALSE);
399  1 constraints.setPrimaryKey(Boolean.TRUE);
400  1 column.setAutoIncrement(Boolean.TRUE);
401   
402  1 column.setConstraints(constraints);
403   
404  1 refactoring.addColumn(column);
405   
406  1 column = new ColumnConfig();
407  1 column.setName("NEWCOL2");
408  1 column.setType("TYP");
409  1 refactoring.addColumn(column);
410   
411  1 testInverseOnAll(refactoring, new InverseValidator() {
 
412  15 toggle public void validate(Change[] changes) {
413  15 assertEquals(2, changes.length);
414  15 assertTrue(changes[0] instanceof DropColumnChange);
415  15 assertEquals("NEWCOL", ((DropColumnChange) changes[0]).getColumnName());
416  15 assertTrue(changes[1] instanceof DropColumnChange);
417  15 assertEquals("NEWCOL2", ((DropColumnChange) changes[1]).getColumnName());
418    }
419    });
420    }
421   
 
422  1 toggle @Override
423    @Test
424    public void getConfirmationMessage() throws Exception {
425  1 AddColumnChange refactoring = new AddColumnChange();
426  1 refactoring.setTableName("TAB");
427  1 ColumnConfig column = new ColumnConfig();
428  1 column.setName("NEWCOL");
429  1 column.setType("TYP");
430  1 refactoring.addColumn(column);
431   
432  1 assertEquals("Columns NEWCOL(TYP) added to TAB", refactoring.getConfirmationMessage());
433    }
434   
435    }
 
CloverReport generated by Clover Code Coverage v3.0.2
Sat Aug 6 2011 11:34:46 EDT.		   Clover: Open Source License registered to University of Arizona.