public void System_operations_are_included_when_requested()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo).GetModel();
modelBuilder = new DbModelBuilder();
var model2 = modelBuilder.Build(ProviderInfo).GetModel();
new HistoryRepository(ConnectionString, ProviderFactory).AppendHistoryModel(model2, ProviderInfo);
var operations = new EdmModelDiffer().Diff(model1, model2, includeSystemOperations: true);
var createTableOperation
= operations.OfType<CreateTableOperation>().Single();
Assert.True(createTableOperation.IsSystem);
operations = new EdmModelDiffer().Diff(model2, model1, includeSystemOperations: true);
var dropTableOperation
= operations.OfType<DropTableOperation>().Single();
Assert.True(dropTableOperation.IsSystem);
}
public void System_operations_are_ignored_by_default()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo).GetModel();
modelBuilder = new DbModelBuilder();
var model2 = modelBuilder.Build(ProviderInfo).GetModel();
new HistoryRepository(ConnectionString, ProviderFactory).AppendHistoryModel(model2, ProviderInfo);
var operations = new EdmModelDiffer().Diff(model1, model2);
Assert.Equal(0, operations.Count());
}
public void Can_diff_identical_models_at_different_edm_versions_and_no_diffs_produced()
{
var modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V4_1);
modelBuilder.Entity<OrderLine>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder(DbModelBuilderVersion.V5_0);
modelBuilder.Entity<OrderLine>();
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(0, operations.Count());
}
public void Should_generate_add_column_operation_when_shared_pk_fk_moved_to_ia()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<ArubaRun>();
modelBuilder.Entity<ArubaTask>().HasKey(k => new { k.Id, k.Name });
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<ArubaRun>().HasMany(r => r.Tasks).WithRequired().Map(m => { });
var model2 = modelBuilder.Build(ProviderInfo);
var operations
= new EdmModelDiffer().Diff(model1.GetModel(), model2.GetModel());
Assert.Equal(5, operations.Count());
Assert.True(operations.Any(o => o is AddColumnOperation));
}
public void Bug_47549_crash_when_many_to_many_end_renamed_in_ospace()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<User>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder();
modelBuilder.Entity<User2>();
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(13, operations.Count());
}
public void Can_detect_simple_table_rename()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<MigrationsCustomer>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<MigrationsCustomer>().ToTable("Customer");
var model2 = modelBuilder.Build(ProviderInfo);
var operations
= new EdmModelDiffer().Diff(model1.GetModel(), model2.GetModel());
var tableRename = (RenameTableOperation)operations.Single();
Assert.Equal("dbo.MigrationsCustomers", tableRename.Name);
Assert.Equal("Customer", tableRename.NewName);
}
public void Can_detect_renamed_many_to_many_table()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<ManyManySelfRef>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<ManyManySelfRef>().ToTable("Renamed");
var model2 = modelBuilder.Build(ProviderInfo);
var operations
= new EdmModelDiffer().Diff(model1.GetModel(), model2.GetModel());
var tableRename = (RenameTableOperation)operations.Single();
Assert.Equal("dbo.ManyManySelfRefs", tableRename.Name);
Assert.Equal("Renamed", tableRename.NewName);
}
public void Can_detect_changed_primary_key_when_table_renamed()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity <OrderLine>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder();
modelBuilder.Entity <OrderLine>()
.HasKey(
ol => new
{
ol.Id,
ol.OrderId
})
.ToTable("tbl_OrderLines");
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(4, operations.Count());
var addPrimaryKeyOperation = operations.OfType <AddPrimaryKeyOperation>().Single();
Assert.Equal("dbo.tbl_OrderLines", addPrimaryKeyOperation.Table);
Assert.Equal("Id", addPrimaryKeyOperation.Columns.First());
Assert.Equal("OrderId", addPrimaryKeyOperation.Columns.Last());
var dropPrimaryKeyOperation = operations.OfType <DropPrimaryKeyOperation>().Single();
Assert.Equal("dbo.OrderLines", dropPrimaryKeyOperation.Table);
Assert.Equal("Id", dropPrimaryKeyOperation.Columns.Single());
}
public void Can_detect_changed_modification_functions_when_many_to_many()
{
var commandTreeGenerator
= new ModificationCommandTreeGenerator(TestContext.CreateDynamicUpdateModel());
var targetModel = new TestContext_v2b().GetModel();
var alterProcedureOperations
= new EdmModelDiffer()
.Diff(
new TestContext().GetModel(),
targetModel,
new Lazy<ModificationCommandTreeGenerator>(() => commandTreeGenerator),
new SqlServerMigrationSqlGenerator())
.OfType<AlterProcedureOperation>()
.ToList();
Assert.Equal(2, alterProcedureOperations.Count);
Assert.Equal(1, alterProcedureOperations.Count(ap => ap.Parameters.Any(p => p.Name == "order_thing_id")));
Assert.Equal(1, alterProcedureOperations.Count(ap => ap.Parameters.Any(p => p.Name == "order_id")));
}
public void Can_detect_moved_modification_functions()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<MigrationsCustomer>().MapToStoredProcedures();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder
.Entity<MigrationsCustomer>()
.MapToStoredProcedures(
m =>
{
m.Insert(c => c.HasName("MigrationsCustomer_Insert", "foo"));
m.Update(c => c.HasName("delete_it", "foo"));
});
var model2 = modelBuilder.Build(ProviderInfo);
var operations
= new EdmModelDiffer().Diff(model1.GetModel(), model2.GetModel());
Assert.Equal(3, operations.Count());
var moveProcedureOperations
= operations.OfType<MoveProcedureOperation>();
Assert.True(moveProcedureOperations.All(mpo => mpo.NewSchema == "foo"));
}
public void Can_detect_added_modification_functions()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
var model2 = new TestContext();
var commandTreeGenerator
= new ModificationCommandTreeGenerator(TestContext.CreateDynamicUpdateModel());
var createProcedureOperations
= new EdmModelDiffer()
.Diff(
model1.GetModel(),
model2.GetModel(),
new Lazy<ModificationCommandTreeGenerator>(() => commandTreeGenerator),
new SqlServerMigrationSqlGenerator())
.OfType<CreateProcedureOperation>()
.ToList();
Assert.Equal(20, createProcedureOperations.Count);
Assert.True(createProcedureOperations.All(c => c.Name.Any()));
Assert.True(createProcedureOperations.All(c => c.BodySql.Any()));
}
public void Can_detect_changed_modification_functions()
{
var commandTreeGenerator
= new ModificationCommandTreeGenerator(TestContext.CreateDynamicUpdateModel());
var targetModel = new TestContext_v2().GetModel();
var alterProcedureOperations
= new EdmModelDiffer()
.Diff(
new TestContext().GetModel(),
targetModel,
new Lazy<ModificationCommandTreeGenerator>(() => commandTreeGenerator),
new SqlServerMigrationSqlGenerator())
.OfType<AlterProcedureOperation>()
.ToList();
Assert.Equal(3, alterProcedureOperations.Count);
Assert.True(alterProcedureOperations.All(c => c.BodySql.Any()));
Assert.Equal(1, alterProcedureOperations.Count(c => c.Parameters.Any(p => p.Name == "key_for_update2")));
Assert.Equal(1, alterProcedureOperations.Count(c => c.Parameters.Any(p => p.Name == "affected_rows")));
}
public void Can_populate_table_model_for_added_tables()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<MigrationsCustomer>();
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(2, operations.OfType<AddForeignKeyOperation>().Count());
var createTableOperation = operations.OfType<CreateTableOperation>().Single(t => t.Name == "ordering.Orders");
Assert.Equal(4, createTableOperation.Columns.Count());
Assert.Equal(1, createTableOperation.PrimaryKey.Columns.Count());
Assert.Equal("OrderId", createTableOperation.PrimaryKey.Columns.Single());
var customerIdColumn = createTableOperation.Columns.Single(c => c.Name == "MigrationsCustomer_Id");
Assert.Equal(PrimitiveTypeKind.Int32, customerIdColumn.Type);
Assert.Null(customerIdColumn.IsNullable);
var orderIdColumn = createTableOperation.Columns.Single(c => c.Name == "OrderId");
Assert.True(orderIdColumn.IsIdentity);
}
public void Can_detect_added_tables()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<OrderLine>().ToTable("[foo.[]]].bar");
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(1, operations.Count());
var createTableOperation = operations.OfType<CreateTableOperation>().Single();
Assert.Equal("[foo.[]]].bar", createTableOperation.Name);
}
public void Should_not_detect_pk_change_when_pk_column_renamed()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<OrderLine>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder();
modelBuilder.Entity<OrderLine>().Property(ol => ol.Id).HasColumnName("pk_ID");
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(1, operations.Count());
Assert.True(operations.Single() is RenameColumnOperation);
}
public void Cross_provider_diff_should_be_clean_when_same_model()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>();
var model1 = modelBuilder.Build(new DbProviderInfo(DbProviders.Sql, "2008"));
modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>();
var model2 = modelBuilder.Build(new DbProviderInfo(DbProviders.SqlCe, "4"));
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(0, operations.Count());
}
public void Can_detect_added_foreign_keys()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<Order>();
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(4, operations.Count());
Assert.Equal(2, operations.OfType<CreateTableOperation>().Count());
Assert.Equal(1, operations.OfType<CreateIndexOperation>().Count());
// create fk indexes first
Assert.True(
operations.Select(
(o, i) => new
{
o,
i
}).Single(a => a.o is CreateIndexOperation).i <
operations.Select(
(o, i) => new
{
o,
i
}).Single(a => a.o is AddForeignKeyOperation).i);
var addForeignKeyOperation = operations.OfType<AddForeignKeyOperation>().Single();
Assert.Equal("ordering.Orders", addForeignKeyOperation.PrincipalTable);
Assert.Equal("OrderId", addForeignKeyOperation.PrincipalColumns.Single());
Assert.Equal("dbo.OrderLines", addForeignKeyOperation.DependentTable);
Assert.Equal("OrderId", addForeignKeyOperation.DependentColumns.Single());
Assert.True(addForeignKeyOperation.CascadeDelete);
}
public void Should_not_detect_changed_foreign_keys_when_multiplicity()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<Order>().HasMany(o => o.OrderLines).WithRequired();
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(0, operations.Count());
}
public void Can_detect_custom_store_type()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<OrderLine>();
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
var createTableOperation = operations.OfType<CreateTableOperation>().Single();
var column = createTableOperation.Columns.Single(c => c.Name == "Total");
Assert.Equal("money", column.StoreType);
createTableOperation.Columns.Except(new[] { column }).Each(c => Assert.Null(c.StoreType));
}
public void Can_detect_timestamp_columns()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>();
var model2 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>().Ignore(o => o.Version);
var model1 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(model1.GetModel(), model2.GetModel());
Assert.Equal(1, operations.Count());
var column = operations.OfType<AddColumnOperation>().Single().Column;
Assert.True(column.IsTimestamp);
}
public void Can_detect_dropped_columns()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>().Ignore(o => o.Version);
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(1, operations.Count());
var dropColumnOperation = operations.OfType<DropColumnOperation>().Single();
Assert.Equal("ordering.Orders", dropColumnOperation.Table);
Assert.Equal("Version", dropColumnOperation.Name);
var inverse = (AddColumnOperation)dropColumnOperation.Inverse;
Assert.NotNull(inverse);
Assert.Equal("ordering.Orders", inverse.Table);
Assert.Equal("Version", inverse.Column.Name);
}
public void Can_detect_renamed_modification_functions_when_many_to_many()
{
var commandTreeGenerator
= new ModificationCommandTreeGenerator(TestContext.CreateDynamicUpdateModel());
var targetModel = new TestContext_v2b().GetModel();
var renameProcedureOperations
= new EdmModelDiffer()
.Diff(
new TestContext().GetModel(),
targetModel,
new Lazy<ModificationCommandTreeGenerator>(() => commandTreeGenerator),
new SqlServerMigrationSqlGenerator())
.OfType<RenameProcedureOperation>()
.ToList();
Assert.Equal(1, renameProcedureOperations.Count);
Assert.Equal(1, renameProcedureOperations.Count(c => c.NewName == "m2m_insert"));
}
[MigrationsTheory] // CodePlex 726
public void Can_handle_max_length_set_to_MAX_in_SSDL()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<MigrationsCustomer>().Property(c => c.Photo).HasMaxLength(100);
modelBuilder.Entity<MigrationsCustomer>().Property(c => c.FullName).HasMaxLength(100);
var sourceModel = modelBuilder.Build(ProviderInfo).GetModel();
modelBuilder.Entity<MigrationsCustomer>().Property(c => c.Photo).IsMaxLength();
modelBuilder.Entity<MigrationsCustomer>().Property(c => c.FullName).IsMaxLength();
var targetModel = modelBuilder.Build(ProviderInfo).GetModel();
// Artificially add MaxLength=MAX to a couple of properties
var customerEntity = targetModel
.Elements().First()
.Elements().First()
.Elements().Single(e => e.Name.LocalName == "StorageModels")
.Elements().Single(e => e.Name.LocalName == "Schema")
.Elements().Single(e => e.Name.LocalName == "EntityType" && e.Attributes("Name").Any(a => a.Value == "MigrationsCustomer"));
customerEntity.Elements().Single(e => e.Name.LocalName == "Property" && e.Attributes("Name").Any(a => a.Value == "FullName"))
.Add(new XAttribute("MaxLength", "Max"));
customerEntity.Elements().Single(e => e.Name.LocalName == "Property" && e.Attributes("Name").Any(a => a.Value == "Photo"))
.Add(new XAttribute("MaxLength", "MAX"));
DbProviderInfo providerInfo;
var storageMappingItemCollection = sourceModel.GetStorageMappingItemCollection(out providerInfo);
var sourceMetadata = new EdmModelDiffer.ModelMetadata
{
Model = sourceModel,
StoreItemCollection = storageMappingItemCollection.StoreItemCollection,
StorageEntityContainerMapping
= storageMappingItemCollection.GetItems<StorageEntityContainerMapping>().Single(),
ProviderManifest = GetProviderManifest(providerInfo),
ProviderInfo = providerInfo
};
var targetMetadata = new EdmModelDiffer.ModelMetadata
{
Model = targetModel,
// Use the source model here since it doesn't effect the test and the SQL Server provider
// won't load the target model
StoreItemCollection = storageMappingItemCollection.StoreItemCollection,
StorageEntityContainerMapping
= storageMappingItemCollection.GetItems<StorageEntityContainerMapping>().Single(),
ProviderManifest = GetProviderManifest(providerInfo),
ProviderInfo = providerInfo
};
var operations = new EdmModelDiffer().Diff(sourceMetadata, targetMetadata, null, null);
Assert.Equal(2, operations.Count());
operations.OfType<AlterColumnOperation>().Each(
o =>
{
Assert.Null(o.Column.MaxLength);
Assert.Equal(100, ((AlterColumnOperation)o.Inverse).Column.MaxLength);
});
}
public void Can_detect_removed_modification_functions()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<OrderLine>().MapToStoredProcedures();
var model2 = new TestContext();
var dropProcedureOperations
= new EdmModelDiffer().Diff(model2.GetModel(), model1.GetModel())
.OfType<DropProcedureOperation>()
.ToList();
Assert.Equal(20, dropProcedureOperations.Count);
Assert.True(dropProcedureOperations.All(c => c.Name.Any()));
}
public void Can_detect_changed_primary_key_when_table_renamed()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<OrderLine>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder();
modelBuilder.Entity<OrderLine>()
.HasKey(
ol => new
{
ol.Id,
ol.OrderId
})
.ToTable("tbl_OrderLines");
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(4, operations.Count());
var addPrimaryKeyOperation = operations.OfType<AddPrimaryKeyOperation>().Single();
Assert.Equal("dbo.tbl_OrderLines", addPrimaryKeyOperation.Table);
Assert.Equal("Id", addPrimaryKeyOperation.Columns.First());
Assert.Equal("OrderId", addPrimaryKeyOperation.Columns.Last());
var dropPrimaryKeyOperation = operations.OfType<DropPrimaryKeyOperation>().Single();
Assert.Equal("dbo.OrderLines", dropPrimaryKeyOperation.Table);
Assert.Equal("Id", dropPrimaryKeyOperation.Columns.Single());
}
public void Can_detect_added_columns()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<OrderLine>();
var model2 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<OrderLine>().Ignore(ol => ol.OrderId);
var model1 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(1, operations.Count());
var addColumnOperation = operations.OfType<AddColumnOperation>().Single();
Assert.Equal("dbo.OrderLines", addColumnOperation.Table);
Assert.Equal("OrderId", addColumnOperation.Column.Name);
Assert.Equal(PrimitiveTypeKind.Int32, addColumnOperation.Column.Type);
Assert.False(addColumnOperation.Column.IsNullable.Value);
}
public void Should_not_detect_identity_when_not_valid_identity_type_for_ddl()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder = new DbModelBuilder();
WhenSqlCe(
() =>
{
modelBuilder.Entity<MigrationsStore>().Ignore(e => e.Location);
modelBuilder.Entity<MigrationsStore>().Ignore(e => e.FloorPlan);
});
modelBuilder
.Entity<MigrationsStore>()
.Property(s => s.Name)
.HasDatabaseGeneratedOption(DatabaseGeneratedOption.Identity);
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(1, operations.Count());
var column = operations.OfType<CreateTableOperation>().Single().Columns.Single(c => c.Name == "Name");
Assert.False(column.IsIdentity);
}
public void Can_detect_changed_foreign_keys_when_cascade()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Order>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<Order>().HasMany(o => o.OrderLines).WithOptional().WillCascadeOnDelete(false);
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(4, operations.Count());
Assert.Equal(1, operations.OfType<DropForeignKeyOperation>().Count());
Assert.Equal(1, operations.OfType<DropIndexOperation>().Count());
Assert.Equal(1, operations.OfType<CreateIndexOperation>().Count());
var addForeignKeyOperation = operations.OfType<AddForeignKeyOperation>().Single();
Assert.Equal("ordering.Orders", addForeignKeyOperation.PrincipalTable);
Assert.Equal("OrderId", addForeignKeyOperation.PrincipalColumns.Single());
Assert.Equal("dbo.OrderLines", addForeignKeyOperation.DependentTable);
Assert.Equal("OrderId", addForeignKeyOperation.DependentColumns.Single());
Assert.False(addForeignKeyOperation.CascadeDelete);
}
public void Can_detect_changed_columns()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<MigrationsCustomer>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<MigrationsCustomer>().Property(c => c.FullName).HasMaxLength(25).IsUnicode(false);
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(1, operations.Count());
var column = operations.OfType<AlterColumnOperation>().Single().Column;
Assert.Equal(25, column.MaxLength);
if (DatabaseProvider != DatabaseProvider.SqlServerCe)
{
Assert.False(column.IsUnicode.Value);
}
var inverse = (AlterColumnOperation)operations.OfType<AlterColumnOperation>().Single().Inverse;
Assert.NotNull(inverse);
Assert.Equal("FullName", inverse.Column.Name);
if (DatabaseProvider != DatabaseProvider.SqlServerCe)
{
Assert.Null(inverse.Column.MaxLength);
}
else
{
Assert.Equal(4000, inverse.Column.MaxLength);
}
Assert.Null(inverse.Column.IsUnicode);
}
public void Can_detect_removed_foreign_keys()
{
var modelBuilder = new DbModelBuilder();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder.Entity<Order>();
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model2.GetModel(), model1.GetModel());
Assert.Equal(4, operations.Count());
Assert.Equal(2, operations.OfType<DropTableOperation>().Count());
Assert.Equal(1, operations.OfType<DropIndexOperation>().Count());
// drop fks before indexes
Assert.True(
operations.Select(
(o, i) => new
{
o,
i
}).Single(a => a.o is DropForeignKeyOperation).i <
operations.Select(
(o, i) => new
{
o,
i
}).Single(a => a.o is DropIndexOperation).i);
var dropForeignKeyOperation = operations.OfType<DropForeignKeyOperation>().Single();
Assert.Equal("ordering.Orders", dropForeignKeyOperation.PrincipalTable);
Assert.Equal("dbo.OrderLines", dropForeignKeyOperation.DependentTable);
Assert.Equal("OrderId", dropForeignKeyOperation.DependentColumns.Single());
var inverse = (AddForeignKeyOperation)dropForeignKeyOperation.Inverse;
Assert.Equal("ordering.Orders", inverse.PrincipalTable);
Assert.Equal("OrderId", inverse.PrincipalColumns.Single());
Assert.Equal("dbo.OrderLines", inverse.DependentTable);
Assert.Equal("OrderId", inverse.DependentColumns.Single());
}
public void Can_detect_changed_columns_when_renamed()
{
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<MigrationsCustomer>();
var model1 = modelBuilder.Build(ProviderInfo);
modelBuilder
.Entity<MigrationsCustomer>()
.Property(c => c.FullName)
.HasMaxLength(25)
.HasColumnName("Foo");
var model2 = modelBuilder.Build(ProviderInfo);
var operations = new EdmModelDiffer().Diff(
model1.GetModel(), model2.GetModel());
Assert.Equal(2, operations.Count());
var alterColumnOperation
= (AlterColumnOperation)operations.Last();
Assert.Equal("Foo", alterColumnOperation.Column.Name);
var inverseAlterColumnOperation
= (AlterColumnOperation)alterColumnOperation.Inverse;
Assert.Equal("Foo", inverseAlterColumnOperation.Column.Name);
}
