public void Visit_with_drop_foreign_key_operation()
{
var model = new DatabaseModel();
var column0 = new Column("Foo", typeof(int));
var column1 = new Column("Bar", typeof(int));
var table0 = new Table("dbo.T0", new[] { column0 });
var table1 = new Table("dbo.T1", new[] { column1 });
var foreignKey = new ForeignKey("FK", new[] { column0 }, new[] { column1 }, cascadeDelete: true);
var operation = new DropForeignKeyOperation("dbo.T0", "FK");
model.AddTable(table0);
model.AddTable(table1);
table0.AddForeignKey(foreignKey);
Assert.Equal(1, table0.ForeignKeys.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(0, table0.ForeignKeys.Count);
}
public void Visit_with_move_table_operation()
{
var model = new DatabaseModel();
var operation = new MoveTableOperation("dbo.MyTable", "RenamedSchema");
model.AddTable(new Table("dbo.MyTable"));
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(1, model.Tables.Count);
Assert.Equal("RenamedSchema.MyTable", model.Tables[0].Name);
}
public void Visit_with_drop_table_operation()
{
var model = new DatabaseModel();
var operation = new DropTableOperation("dbo.MyTable");
model.AddTable(new Table("dbo.MyTable"));
Assert.Equal(1, model.Tables.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(0, model.Tables.Count);
}
public void AddTable_adds_specified_table()
{
var database = new DatabaseModel();
Assert.Equal(0, database.Tables.Count);
var table = new Table("dbo.MyTable");
database.AddTable(table);
Assert.Equal(1, database.Tables.Count);
Assert.Same(table, database.Tables[0]);
}
public void Visit_with_rename_column_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int));
var table = new Table("dbo.MyTable", new[] { column });
var operation = new RenameColumnOperation("dbo.MyTable", "Foo", "Bar");
model.AddTable(table);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal("Bar", column.Name);
}
public void Visit_with_drop_column_operation()
{
var model = new DatabaseModel();
var table = new Table("dbo.MyTable", new[] { new Column("Foo", typeof(int)) });
var operation = new DropColumnOperation("dbo.MyTable", "Foo");
model.AddTable(table);
Assert.Equal(1, table.Columns.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(0, table.Columns.Count);
}
public void Visit_with_add_default_constraint_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int));
var table = new Table("dbo.MyTable", new[] { column });
var operation = new AddDefaultConstraintOperation("dbo.MyTable", "Foo", 5, "Sql");
model.AddTable(table);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(5, column.DefaultValue);
Assert.Equal("Sql", column.DefaultSql);
}
public void Generate_when_add_column_operation()
{
var database = new DatabaseModel();
database.AddTable(new Table("dbo.MyTable"));
var column = new Column("Bar", "int")
{
IsNullable = false, DefaultValue = 5
};
Assert.Equal(
@"ALTER TABLE [dbo].[MyTable] ADD [Bar] int NOT NULL DEFAULT 5",
Generate(new AddColumnOperation("dbo.MyTable", column), database).Sql);
}
public void Visit_with_add_column_operation()
{
var model = new DatabaseModel();
var table = new Table("dbo.MyTable");
var column = new Column("Foo", typeof(int));
var operation = new AddColumnOperation("dbo.MyTable", column);
model.AddTable(table);
Assert.Equal(0, table.Columns.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(1, table.Columns.Count);
Assert.Same(column, table.Columns[0]);
}
public void Visit_with_rename_index_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int));
var table = new Table("dbo.MyTable", new[] { column });
var index = new Index("IX", new[] { column }, isUnique: true, isClustered: true);
var operation = new RenameIndexOperation("dbo.MyTable", "IX", "RenamedIndex");
model.AddTable(table);
table.AddIndex(index);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(1, table.Indexes.Count);
Assert.Equal("RenamedIndex", table.Indexes[0].Name);
}
public void Database_setter_clones_value()
{
var sqlGenerator = (new Mock <MigrationOperationSqlGenerator>(new RelationalTypeMapper())
{
CallBase = true
}).Object;
var database = new DatabaseModel();
var table = new Table("dbo.MyTable");
database.AddTable(table);
sqlGenerator.Database = database;
Assert.NotSame(database, sqlGenerator.Database);
Assert.Equal(1, sqlGenerator.Database.Tables.Count);
Assert.NotSame(table, sqlGenerator.Database.Tables[0]);
Assert.Equal("dbo.MyTable", sqlGenerator.Database.Tables[0].Name);
}
public void Visit_with_drop_unique_constraint_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int));
var table = new Table("dbo.MyTable", new[] { column });
table.AddUniqueConstraint(new UniqueConstraint("UC", new[] { column }));
var operation = new DropUniqueConstraintOperation("dbo.MyTable", "UC");
model.AddTable(table);
Assert.Equal(1, table.UniqueConstraints.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(0, table.UniqueConstraints.Count);
}
public void Visit_with_drop_default_constraint_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int))
{
DefaultValue = 5, DefaultSql = "Sql"
};
var table = new Table("dbo.MyTable", new[] { column });
var operation = new DropDefaultConstraintOperation("dbo.MyTable", "Foo");
model.AddTable(table);
Assert.True(column.HasDefault);
operation.Accept(new DatabaseModelModifier(), model);
Assert.False(column.HasDefault);
}
public void Generate_uses_preprocessor()
{
var database = new DatabaseModel();
var column = new Column("Id", typeof(string))
{
IsNullable = false
};
var newColumn = new Column("Id", typeof(int))
{
IsNullable = false
};
var table
= new Table("A", new[] { column })
{
PrimaryKey = new PrimaryKey("PK", new[] { column })
};
database.AddTable(table);
var operations
= new MigrationOperation[]
{
new AlterColumnOperation(table.Name, newColumn, isDestructiveChange: true)
};
var stringBuilder = new StringBuilder();
foreach (var statement in CreateGenerator(database).Generate(operations))
{
stringBuilder.AppendLine(statement.Sql);
}
Assert.Equal(
@"ALTER TABLE ""A"" RENAME TO ""__mig_tmp__A""
CREATE TABLE ""A"" (
""Id"" INT NOT NULL,
CONSTRAINT ""PK"" PRIMARY KEY (""Id"")
)
INSERT INTO ""A"" ( ""Id"" )
SELECT ""Id"" FROM ""__mig_tmp__A""
DROP TABLE ""__mig_tmp__A""
",
stringBuilder.ToString());
}
public void Visit_with_drop_primary_key_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int));
var table
= new Table("dbo.MyTable", new[] { column })
{
PrimaryKey = new PrimaryKey("PK", new[] { column }, isClustered: false)
};
var operation = new DropPrimaryKeyOperation("dbo.MyTable", "PK");
model.AddTable(table);
Assert.NotNull(table.PrimaryKey);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Null(table.PrimaryKey);
}
public void Visit_with_add_primary_key_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int));
var table = new Table("dbo.MyTable", new[] { column });
var operation = new AddPrimaryKeyOperation("dbo.MyTable", "PK", new[] { "Foo" }, isClustered: false);
model.AddTable(table);
Assert.Null(table.PrimaryKey);
operation.Accept(new DatabaseModelModifier(), model);
Assert.NotNull(table.PrimaryKey);
Assert.Equal("PK", table.PrimaryKey.Name);
Assert.Equal(1, table.PrimaryKey.Columns.Count);
Assert.Same(column, table.PrimaryKey.Columns[0]);
Assert.False(table.PrimaryKey.IsClustered);
}
public void Generate_uses_preprocessor()
{
var database = new DatabaseModel();
var column = new Column("Id", typeof(string))
{
IsNullable = false
};
var newColumn = new Column("Id", typeof(int))
{
IsNullable = false
};
var table = new Table("A", new[] { column });
database.AddTable(table);
table.PrimaryKey = new PrimaryKey("PK", new[] { column });
var operations
= new MigrationOperation[]
{
new CreateTableOperation(table),
new AlterColumnOperation(table.Name, newColumn, isDestructiveChange: true)
};
var stringBuilder = new StringBuilder();
foreach (var statement in CreateSqlGenerator(database).Generate(operations))
{
stringBuilder.AppendLine(statement.Sql);
}
Assert.Equal(
@"CREATE TABLE [A] (
[Id] nvarchar(128) NOT NULL,
CONSTRAINT [PK] PRIMARY KEY ([Id])
)
ALTER TABLE [A] DROP CONSTRAINT [PK]
ALTER TABLE [A] ALTER COLUMN [Id] int NOT NULL
ALTER TABLE [A] ADD CONSTRAINT [PK] PRIMARY KEY ([Id])
",
stringBuilder.ToString());
}
public void Visit_with_alter_column_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(string));
var table = new Table("dbo.MyTable", new[] { column });
var operation
= new AlterColumnOperation(
"dbo.MyTable",
new Column("Foo", typeof(int))
{
DataType = "T",
IsNullable = false,
DefaultValue = "V",
DefaultSql = "Sql",
ValueGenerationStrategy = ValueGenerationOnSave.WhenInsertingAndUpdating,
IsTimestamp = true,
MaxLength = 4,
Precision = 3,
Scale = 2,
IsFixedLength = true,
IsUnicode = true
},
isDestructiveChange: true);
model.AddTable(table);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal("Foo", column.Name);
Assert.Same(typeof(int), column.ClrType);
Assert.Equal("T", column.DataType);
Assert.Equal("V", column.DefaultValue);
Assert.Equal("Sql", column.DefaultSql);
Assert.Equal(ValueGenerationOnSave.WhenInsertingAndUpdating, column.ValueGenerationStrategy);
Assert.True(column.IsTimestamp);
Assert.Equal(4, column.MaxLength.Value);
Assert.Equal(3, column.Precision.Value);
Assert.Equal(2, column.Scale.Value);
Assert.True(column.IsFixedLength.Value);
Assert.True(column.IsUnicode.Value);
}
public void Visit_with_add_unique_constraint_operation()
{
var model = new DatabaseModel();
var column = new Column("Foo", typeof(int));
var table = new Table("dbo.MyTable", new[] { column });
var operation = new AddUniqueConstraintOperation("dbo.MyTable", "UK", new[] { "Foo" });
model.AddTable(table);
Assert.Equal(0, table.UniqueConstraints.Count);
operation.Accept(new DatabaseModelModifier(), model);
Assert.Equal(1, table.UniqueConstraints.Count);
var uniqueConstraint = table.UniqueConstraints[0];
Assert.Equal("UK", uniqueConstraint.Name);
Assert.Equal(1, uniqueConstraint.Columns.Count);
Assert.Same(column, uniqueConstraint.Columns[0]);
}
