public void ShouldRenameColumnDefaultConstraintIfMergedWithRenameOperation()
{
var op = new UpdateTableOperation("schema", "table",
new[]
{
Column.Bit("no default", Nullable.NotNull, null, null, null),
Column.Int("name2", Nullable.NotNull, "1", "name", null)
},
new[]
{
Column.Bit("no default2", Nullable.NotNull, null, null, null),
Column.Int("name", Nullable.NotNull, "2", "name2", null)
},
null);
var renameOp = new RenameObjectOperation("SCHEMA", "NAME", "NEW NAME");
var rename2Op = new RenameObjectOperation("SCHEMA", "NAME2", "NEW NAME2");
op.Merge(renameOp);
op.Merge(rename2Op);
Assert.That(op.Disabled, Is.False);
Assert.That(op.Name, Is.EqualTo("table"));
Assert.That(op.AddColumns[1].Name, Is.EqualTo("name2"));
Assert.That(op.AddColumns[1].DefaultConstraintName, Is.EqualTo("NEW NAME"));
Assert.That(op.UpdateColumns[1].Name, Is.EqualTo("name"));
Assert.That(op.UpdateColumns[1].DefaultConstraintName, Is.EqualTo("NEW NAME2"));
Assert.That(renameOp.Disabled, Is.True);
Assert.That(rename2Op.Disabled, Is.True);
}
public void ShouldNotRenameTableIfTableIsRenamedAfterColumnsAreRenamed()
{
var columns = new[]
{
Column.Int("c1", Nullable.NotNull, null, null, "description"),
Column.VarChar("c2", new CharacterLength(1008), "collation", Nullable.NotNull, null, null, "description")
};
var op = new AddTableOperation("schema", "table", columns, false, "file group", "textimagefilegroup", "filestreamfilegroup", new string[0]);
var renameColumn1Op = new RenameColumnOperation("SCHEMA", "TABLE", "C1", "C1New");
var renameColumn2Op = new RenameColumnOperation("SCHEMA", "TABLE", "C2", "C2New");
var renameTableOp = new RenameObjectOperation("SCHEMA", "TABLE", "T1New");
renameColumn2Op.Merge(renameTableOp);
renameColumn1Op.Merge(renameTableOp);
op.Merge(renameTableOp);
renameColumn1Op.Merge(renameColumn2Op);
op.Merge(renameColumn2Op);
op.Merge(renameColumn1Op);
Assert.That(op.Disabled, Is.False);
Assert.That(renameColumn1Op.Disabled, Is.True);
Assert.That(renameColumn2Op.Disabled, Is.True);
Assert.That(renameTableOp.Disabled, Is.True);
Assert.That(columns[0].Name, Is.EqualTo("C1New"));
Assert.That(columns[1].Name, Is.EqualTo("C2New"));
Assert.That(renameColumn2Op.TableName, Is.EqualTo("T1New"));
Assert.That(renameColumn1Op.TableName, Is.EqualTo("T1New"));
Assert.That(op.Name, Is.EqualTo("T1New"));
}
public void ShouldNotDisableTableRenameWhenMerging()
{
var renameIdx = new RenameIndexOperation("schema", "table", "name", "new name");
var renameTable = new RenameObjectOperation("schema", "table", "new table");
renameIdx.Merge(renameTable);
Assert.That(renameTable.Disabled, Is.False);
Assert.That(renameIdx.Disabled, Is.False);
}
public void ShouldSetPropertiesForRenameTableOperation()
{
var op = new RenameObjectOperation(SchemaName, CurrentName, NewName);
Assert.AreEqual(SchemaName, op.SchemaName);
Assert.AreEqual(CurrentName, op.Name);
Assert.AreEqual(NewName, op.NewName);
Assert.AreEqual(TypeName, op.Type);
}
public void ShouldRenameConstraintWhenMergedWithRename()
{
var op = new AddDefaultConstraintOperation("schema", "table", "name", "column", "expression", false);
var renameOp = new RenameObjectOperation("SCHEMA", "NAME", "NEW NAME");
op.Merge(renameOp);
Assert.That(op.Name, Is.EqualTo("NEW NAME"));
Assert.That(op.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.True);
}
public void ShouldUpdateOperationIfViewIsRenamed()
{
var op = new AddExtendedPropertyOperation("schema", "view", "name", "value", true);
var renameOp = new RenameObjectOperation("SCHEMA", "VIEW", "newview");
op.Merge(renameOp);
Assert.That(op.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.False);
Assert.That(op.TableViewName, Is.EqualTo("newview"));
}
public void ShouldChangeConstraintReferencedTableNameIfReferencedTableRenamed()
{
var op = new AddForeignKeyOperation("schema", "table", "name", new string[0], "ref schema", "ref table", new string[0], "on delete", "on update", false, false);
var renameTableOp = new RenameObjectOperation("REF SCHEMA", "REF TABLE", "new table");
op.Merge(renameTableOp);
Assert.That(op.Disabled, Is.False);
Assert.That(renameTableOp.Disabled, Is.True);
Assert.That(op.ReferencesTableName, Is.EqualTo(renameTableOp.NewName));
}
public void ShouldNotChangeConstraintReferencedTableNameIfANonReferencedTableRenamed(string schemaName, string tableName)
{
var op = new AddForeignKeyOperation("schema", "table", "name", new string[0], "ref schema", "ref table", new string[0], "on delete", "on update", false, false);
var renameTableOp = new RenameObjectOperation(schemaName, tableName, "new table");
op.Merge(renameTableOp);
Assert.That(op.Disabled, Is.False);
Assert.That(renameTableOp.Disabled, Is.False);
Assert.That(op.ReferencesTableName, Is.EqualTo("ref table"));
}
public void ShouldNotRenameObjectIfDifferentObject()
{
var op = new AddStoredProcedureOperation("schema", "name", "definition");
var renameOp = new RenameObjectOperation("SCHEMA", "another_object", "newname");
op.Merge(renameOp);
Assert.That(op.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.False);
Assert.That(op.Name, Is.EqualTo("name"));
}
public void ShouldRenameConstraintWhenMergedWithRenameObjectOperation()
{
var op = new AddPrimaryKeyOperation("schema", "table", "name", new string[0], false, new string[0]);
var renameOp = new RenameObjectOperation("SCHEMA", "NAME", "NEW NAME");
op.Merge(renameOp);
Assert.That(op.Name, Is.EqualTo("NEW NAME"));
Assert.That(renameOp.Disabled);
Assert.That(op.Disabled, Is.False);
}
public void ShouldChangeConstraintName()
{
var op = new AddForeignKeyOperation("schema", "table", "name", new string[0], "ref schema", "ref table",
new string[0], "on delete", "on update", false, false);
var renameOp = new RenameObjectOperation("SCHEMA", "NAME", "new name");
op.Merge(renameOp);
Assert.That(op.Name, Is.EqualTo("new name"));
Assert.That(renameOp.Disabled);
Assert.That(op.Disabled, Is.False);
}
public void ShouldDisableRenameOperationAndUpdateObjectNameWhenObjectIsRenamed()
{
// first, make sure we have them all.
foreach (var objectOp in GetObjectOperations())
{
//var objectType = (objectOp is AddIndexOperation || objectOp is RemoveIndexOperation) ? "INDEX" : "OBJECT";
var renameOp = new RenameObjectOperation("SCHEMA", "NAME", "newname");
objectOp.Merge(renameOp);
Assert.That(objectOp.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.True, $"Merge with rename on {objectOp.GetType().FullName} didn't disable rename operation.");
Assert.That(objectOp.Name, Is.EqualTo("newname"), $"Merge with rename on {objectOp.GetType().FullName} didn't change name.");
}
}
public void ShouldNotRenameTableIfRenamedTableNotAddedDuringMerge()
{
var renameColumn1Op = new RenameColumnOperation("SCHEMA", "TABLE", "C1", "C1New");
var renameColumn2Op = new RenameColumnOperation("SCHEMA", "TABLE", "C2", "C2New");
var renameTableOp = new RenameObjectOperation("SCHEMA", "TABLE", "T1New");
renameColumn2Op.Merge(renameTableOp);
renameColumn1Op.Merge(renameTableOp);
renameColumn1Op.Merge(renameColumn2Op);
Assert.That(renameColumn1Op.Disabled, Is.False);
Assert.That(renameColumn2Op.Disabled, Is.False);
Assert.That(renameTableOp.Disabled, Is.False);
Assert.That(renameColumn2Op.TableName, Is.EqualTo("TABLE"));
Assert.That(renameColumn1Op.TableName, Is.EqualTo("TABLE"));
}
public void ShouldUpdateTargetObjectNameIfItGetsRenamedByMerge(string targetDatabaseName)
{
var op = new AddSynonymOperation("schema", "name", "targetschema", targetDatabaseName, "targetobject");
var renameOp = new RenameObjectOperation("TARGETSCHEMA", "TARGETOBJECT", "newtargetobject");
op.Merge(renameOp);
Assert.That(op.Disabled, Is.False);
if (null == targetDatabaseName)
{
Assert.That(renameOp.Disabled, Is.True);
Assert.That(op.TargetObjectName, Is.EqualTo("newtargetobject"));
}
else
{
Assert.That(renameOp.Disabled, Is.False);
Assert.That(op.TargetObjectName, Is.EqualTo("targetobject"));
}
}
public void ShouldRenameColumnDefaultConstraintIfMergedWithRenameOperation()
{
var columns = new[]
{
Column.Bit("no default", Nullable.NotNull, null, null, null),
Column.Int("Name", Nullable.NotNull, null, "DF_ID", null),
Column.VarChar("ID2", new CharacterLength(500), null, Nullable.NotNull, null, "name", null),
};
var op = new AddTableOperation("schema", "table", columns, false, null, null, null, new string[0]);
var renameOp = new RenameObjectOperation("SCHEMA", "NAME", "NEW NAME");
op.Merge(renameOp);
Assert.That(op.Name, Is.EqualTo("table"));
Assert.That(op.Columns[0].DefaultConstraintName, Is.Null);
Assert.That(op.Columns[1].DefaultConstraintName, Is.EqualTo("DF_ID"));
Assert.That(op.Columns[2].DefaultConstraintName, Is.EqualTo("NEW NAME"));
Assert.That(op.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.True);
}
public void ShouldDisableRenameOperationAndUpdateTableNameWhenRenamingTable()
{
var tableObjectOps = new TableObjectOperation[]
{
new AddRowGuidColOperation("schema", "name", "columnName"),
new AddCheckConstraintOperation("schema", "name", "constraint", "expression", false, false),
new AddDefaultConstraintOperation("schema", "name", "expression", "column", "constraint", false),
new AddForeignKeyOperation("schema", "name", "key", new string[0], "referencesschema", "referencestable", new string[0], "ondelete", "onupdate", false, false),
new AddIndexOperation("schema", "name", "index", new string[0], false, false, new string[0], "where", "on", "filestreamon", new string[0]),
new AddPrimaryKeyOperation("schema", "name", "key", new string[0], false, new string[0]),
new AddUniqueKeyOperation("schema", "name", "key", new string[0], false, 0, new string[0], "filegroup"),
new DisableConstraintOperation("schema", "name", "constraint"),
new EnableConstraintOperation("schema", "name", "constraint", false),
};
// first, make sure we have them all.
var expectedOps = AppDomain.CurrentDomain.GetAssemblies()
.Where(assembly => assembly.GetName().Name == "Rivet")
.SelectMany(assembly => assembly.GetTypes())
.Where(type => type.IsSubclassOf(typeof(TableObjectOperation)))
.Where(type => !type.IsAbstract)
.Where(type => !type.Name.StartsWith("Remove", StringComparison.InvariantCultureIgnoreCase));
Assert.That(expectedOps, Is.Not.Empty);
foreach (var expectedOp in expectedOps)
{
var count = tableObjectOps.Where(t => t.GetType() == expectedOp).Count();
Assert.That(count, Is.Not.EqualTo(0),
$"Class {expectedOp.FullName} is missing. Please add an instance of this type to this test.");
}
foreach (var tableObjectOp in tableObjectOps)
{
var renameOp = new RenameObjectOperation("SCHEMA", "NAME", "newname");
tableObjectOp.Merge(renameOp);
Assert.That(tableObjectOp.Disabled, Is.False);
Assert.That(renameOp.Disabled, Is.True,
$"Merge with rename on {tableObjectOp.GetType().FullName} didn't disable rename operation.");
Assert.That(tableObjectOp.TableName, Is.EqualTo("newname"),
$"Merge with rename on {tableObjectOp.GetType().FullName} didn't change name.");
}
}
public void ShouldAddNewColumnsToARenamedTable()
{
var addTableOp = new AddTableOperation("schema", "name", null, false, "file group", "text image file group",
"file stream file group", null);
var renameTableOp = new RenameObjectOperation("schema", "name", "new table");
var newColumns = new[]
{
Column.TinyInt("errorId", Nullable.Null, null, null, "some description")
};
var updateTableOp = new UpdateTableOperation("schema", "new table", newColumns, null, null);
addTableOp.Merge(renameTableOp);
renameTableOp.Merge(updateTableOp);
addTableOp.Merge(updateTableOp);
Assert.That(renameTableOp.Disabled, Is.True);
Assert.That(updateTableOp.Disabled, Is.True);
Assert.That(addTableOp.Disabled, Is.False);
Assert.That(addTableOp.Columns, Is.Not.Empty);
Assert.That(addTableOp.Columns, Has.Count.EqualTo(1));
Assert.That(addTableOp.Columns[0], Is.SameAs(newColumns[0]));
Assert.That(addTableOp.Name, Is.EqualTo("new table"));
}
public void ShouldWriteQueryForRenameTableOperation()
{
var op = new RenameObjectOperation(SchemaName, CurrentName, NewName);
Assert.That(op.ToQuery(), Contains.Substring("@objname = '[schemaName].[currentName]', @newname = 'newName', @objtype = 'OBJECT'"));
}
