package io.ebean.dbmigration.model;
import io.ebean.dbmigration.migration.AlterColumn;
import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
public class MColumnTest {
MTable table = new MTable("tab");
MColumn basic() {
return new MColumn("col", "integer");
}
ModelDiff diff() {
return new ModelDiff();
}
@Test
public void noDiff() throws Exception {
ModelDiff diff = diff();
basic().compare(diff, table, basic());
assertThat(diff.getApplyChanges()).isEmpty();
assertThat(diff.getDropChanges()).isEmpty();
}
@Test
public void diffType() throws Exception {
ModelDiff diff = diff();
basic().compare(diff, table, new MColumn("col", "integer(8)"));
assertChanges(diff);
AlterColumn alterColumn = getAlterColumn(diff);
assertThat(alterColumn.getType()).isEqualTo("integer(8)");
}
@Test
public void diffNotNull() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setNotnull(true);
basic().compare(diff, table, newCol);
assertChanges(diff);
AlterColumn alterColumn = getAlterColumn(diff);
assertThat(alterColumn.isNotnull()).isEqualTo(true);
assertThat(alterColumn.getType()).isNull();
assertThat(alterColumn.getUnique()).isNull();
assertThat(alterColumn.getUniqueOneToOne()).isNull();
assertThat(alterColumn.getDefaultValue()).isNull();
}
@Test
public void diffNull() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setNotnull(false);
MColumn baseCol = basic();
baseCol.setNotnull(true);
baseCol.compare(diff, table, newCol);
assertChanges(diff);
AlterColumn alterColumn = getAlterColumn(diff);
assertThat(alterColumn.isNotnull()).isEqualTo(false);
}
@Test
public void applyNotNull_expect_notNull() throws Exception {
MColumn newCol = basic();
newCol.setNotnull(true);
AlterColumn alterColumn = new AlterColumn();
alterColumn.setNotnull(Boolean.FALSE);
newCol.apply(alterColumn);
assertThat(newCol.isNotnull()).isFalse();
}
@Test
public void diffCheckAdd() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setCheckConstraint("abc");
basic().compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getCheckConstraint()).isEqualTo("abc");
assertThat(getAlterColumn(diff).getDropCheckConstraint()).isNull();
}
@Test
public void diffCheckRemove() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
MColumn oldCol = basic();
oldCol.setCheckConstraint("z");
oldCol.setCheckConstraintName("abc");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getCheckConstraint()).isNull();
assertThat(getAlterColumn(diff).getDropCheckConstraint()).isEqualTo("abc");
}
@Test
public void diffCheckChange() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setCheckConstraint("abc");
MColumn oldCol = basic();
oldCol.setCheckConstraint("z");
oldCol.setCheckConstraintName("d");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getCheckConstraint()).isEqualTo("abc");
assertThat(getAlterColumn(diff).getDropCheckConstraint()).isNull();
}
@Test
public void diffDefaultValueAdd() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setDefaultValue("abc");
basic().compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getDefaultValue()).isEqualTo("abc");
}
@Test
public void diffDefaultValueRemove() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
MColumn oldCol = basic();
oldCol.setDefaultValue("abc");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getDefaultValue()).isEqualTo("DROP DEFAULT");
}
@Test
public void diffDefaultValueChange() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setDefaultValue("abc");
MColumn oldCol = basic();
oldCol.setDefaultValue("d");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getDefaultValue()).isEqualTo("abc");
}
@Test
public void diffReferencesAdd() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setReferences("abc");
basic().compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getReferences()).isEqualTo("abc");
assertThat(getAlterColumn(diff).getDropForeignKey()).isNull();
}
@Test
public void diffReferencesRemove() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
MColumn oldCol = basic();
oldCol.setReferences("abc");
oldCol.setForeignKeyName("fk_ab");
oldCol.setForeignKeyIndex("ix_ab");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getReferences()).isNull();
assertThat(getAlterColumn(diff).getForeignKeyName()).isNull();
assertThat(getAlterColumn(diff).getForeignKeyIndex()).isNull();
assertThat(getAlterColumn(diff).getDropForeignKey()).isEqualTo("fk_ab");
assertThat(getAlterColumn(diff).getDropForeignKeyIndex()).isEqualTo("ix_ab");
}
@Test
public void diffReferencesChange() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setReferences("ab");
newCol.setForeignKeyName("fk_ab");
newCol.setForeignKeyIndex("ix_ab");
MColumn oldCol = basic();
oldCol.setReferences("d");
oldCol.setForeignKeyName("fk_d");
oldCol.setForeignKeyIndex("ix_d");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getReferences()).isEqualTo("ab");
assertThat(getAlterColumn(diff).getForeignKeyName()).isEqualTo("fk_ab");
assertThat(getAlterColumn(diff).getForeignKeyIndex()).isEqualTo("ix_ab");
assertThat(getAlterColumn(diff).getDropForeignKey()).isEqualTo("fk_d");
assertThat(getAlterColumn(diff).getDropForeignKeyIndex()).isEqualTo("ix_d");
}
@Test
public void diffUniqueAdd() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setUnique("uq_one");
basic().compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getUnique()).isEqualTo("uq_one");
}
@Test
public void diffUniqueRemove() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
MColumn oldCol = basic();
oldCol.setUnique("uq_one");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getDropUnique()).isEqualTo("uq_one");
}
@Test
public void diffUniqueOneToOneAdd() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setUniqueOneToOne("uq_new");
MColumn oldCol = basic();
oldCol.setUniqueOneToOne("uq_old");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getUniqueOneToOne()).isEqualTo("uq_new");
assertThat(getAlterColumn(diff).getDropUnique()).isEqualTo("uq_old");
}
@Test
public void diffUniqueOneToOneRemove() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
MColumn oldCol = basic();
oldCol.setUniqueOneToOne("uq_new");
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).getDropUnique()).isEqualTo("uq_new");
}
@Test
public void diffHistoryExcludeAdd() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
newCol.setHistoryExclude(true);
basic().compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).isHistoryExclude()).isEqualTo(true);
}
@Test
public void diffHistoryExcludeRemove() throws Exception {
ModelDiff diff = diff();
MColumn newCol = basic();
MColumn oldCol = basic();
oldCol.setHistoryExclude(true);
oldCol.compare(diff, table, newCol);
assertChanges(diff);
assertThat(getAlterColumn(diff).isHistoryExclude()).isEqualTo(false);
}
@NotNull
private AlterColumn getAlterColumn(ModelDiff diff) {
return (AlterColumn) diff.getApplyChanges().get(0);
}
private void assertChanges(ModelDiff diff) {
assertThat(diff.getDropChanges()).isEmpty();
assertThat(diff.getApplyChanges()).hasSize(1);
}
}