protected Model CreateModel()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity<MappingQueryTestBase.MappedCustomer>(e =>
{
e.Key(c => c.CustomerID);
e.Property(c => c.CompanyName2).Metadata.Relational().Column = "Broken";
e.Metadata.Relational().Table = "Broken";
e.Metadata.Relational().Schema = "wrong";
});
modelBuilder.Entity<MappingQueryTestBase.MappedEmployee>(e =>
{
e.Key(em => em.EmployeeID);
e.Property(em => em.City2).Metadata.Relational().Column = "City";
e.Metadata.Relational().Table = "Employees";
e.Metadata.Relational().Schema = "dbo";
});
modelBuilder.Entity<MappingQueryTestBase.MappedOrder>(e =>
{
e.Key(o => o.OrderID);
e.Property(em => em.ShipVia2).Metadata.Relational().Column = "ShipVia";
e.Metadata.Relational().Table = "Orders";
e.Metadata.Relational().Schema = "dbo";
});
OnModelCreating(modelBuilder);
return model;
}
protected override void OnModelCreating(BasicModelBuilder modelBuilder)
{
modelBuilder.Entity<MappingQueryTestBase.MappedCustomer>(e =>
{
e.Property(c => c.CompanyName2).Metadata.SqlServer().Column = "CompanyName";
e.Metadata.SqlServer().Table = "Customers";
e.Metadata.SqlServer().Schema = "dbo";
});
}
public void Can_get_entity_builder_for_entity_type_name()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer).FullName);
Assert.NotNull(entityBuilder);
Assert.NotNull(model.FindEntityType(typeof(Customer).FullName));
}
public void Can_get_entity_builder_for_clr_type_non_generic()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
var entityBuilder = modelBuilder.Entity(typeof(Customer));
Assert.NotNull(entityBuilder);
Assert.Equal(typeof(Customer).FullName, model.GetEntityType(typeof(Customer)).Name);
}
public void Can_set_entity_key_from_clr_property()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity<Customer>().Key(e => e.Id);
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entity.GetPrimaryKey().Properties.Count());
Assert.Equal("Id", entity.GetPrimaryKey().Properties.First().Name);
}
public void Can_set_entity_key_from_CLR_property_non_generic()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity(typeof(Customer), b =>
{
b.Property<int>("Id");
b.Key("Id");
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entity.GetPrimaryKey().Properties.Count());
Assert.Equal("Id", entity.GetPrimaryKey().Properties.First().Name);
}
public void Can_get_and_set_schema_name()
{
var modelBuilder = new BasicModelBuilder();
var entityType = modelBuilder
.Entity<Customer>()
.Metadata;
Assert.Null(entityType.Relational().Schema);
Assert.Null(((IEntityType)entityType).Relational().Schema);
entityType.Relational().Schema = "db0";
Assert.Equal("db0", entityType.Relational().Schema);
Assert.Equal("db0", ((IEntityType)entityType).Relational().Schema);
entityType.Relational().Schema = null;
Assert.Null(entityType.Relational().Schema);
Assert.Null(((IEntityType)entityType).Relational().Schema);
}
public void Can_get_and_set_column_name()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Equal("Name", property.SqlServer().Column);
Assert.Equal("Name", ((IProperty)property).SqlServer().Column);
property.Relational().Column = "Eman";
Assert.Equal("Name", property.Name);
Assert.Equal("Name", ((IProperty)property).Name);
Assert.Equal("Eman", property.Relational().Column);
Assert.Equal("Eman", ((IProperty)property).Relational().Column);
Assert.Equal("Eman", property.SqlServer().Column);
Assert.Equal("Eman", ((IProperty)property).SqlServer().Column);
property.SqlServer().Column = "MyNameIs";
Assert.Equal("Name", property.Name);
Assert.Equal("Name", ((IProperty)property).Name);
Assert.Equal("Eman", property.Relational().Column);
Assert.Equal("Eman", ((IProperty)property).Relational().Column);
Assert.Equal("MyNameIs", property.SqlServer().Column);
Assert.Equal("MyNameIs", ((IProperty)property).SqlServer().Column);
property.SqlServer().Column = null;
Assert.Equal("Name", property.Name);
Assert.Equal("Name", ((IProperty)property).Name);
Assert.Equal("Eman", property.Relational().Column);
Assert.Equal("Eman", ((IProperty)property).Relational().Column);
Assert.Equal("Eman", property.SqlServer().Column);
Assert.Equal("Eman", ((IProperty)property).SqlServer().Column);
}
public void Indexes_are_not_matched_if_different_clustered_flag()
{
var sourceModelBuilder = new BasicModelBuilder();
sourceModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P1");
b.Key("Id");
b.Index("P1").ForSqlServer().Clustered(false);
});
var targetModelBuilder = new BasicModelBuilder();
targetModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P1");
b.Key("Id");
b.Index("P1").ForSqlServer().Clustered();
});
var operations = new SqlServerModelDiffer(new SqlServerDatabaseBuilder(new SqlServerTypeMapper())).Diff(
sourceModelBuilder.Model, targetModelBuilder.Model);
Assert.Equal(2, operations.Count);
Assert.IsType <DropIndexOperation>(operations[0]);
Assert.IsType <CreateIndexOperation>(operations[1]);
var dropIndexOperation = (DropIndexOperation)operations[0];
var createIndexOperation = (CreateIndexOperation)operations[1];
Assert.Equal("IX_A_P1", dropIndexOperation.IndexName);
Assert.Equal("IX_A_P1", createIndexOperation.IndexName);
Assert.True(createIndexOperation.IsClustered);
}
public void Indexes_are_not_not_clustered_by_default_but_can_be_made_clustered()
{
var sourceModelBuilder = new BasicModelBuilder();
sourceModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P1");
b.Key("Id");
b.Index("P1").ForSqlServer();
});
var targetModelBuilder = new BasicModelBuilder();
targetModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P1");
b.Key("Id");
b.Index("P1").ForSqlServer().Clustered();
});
var operations = Diff(sourceModelBuilder.Model, targetModelBuilder.Model);
Assert.Equal(2, operations.Count);
Assert.IsType <DropIndexOperation>(operations[0]);
Assert.IsType <CreateIndexOperation>(operations[1]);
var dropIndexOperation = (DropIndexOperation)operations[0];
var createIndexOperation = (CreateIndexOperation)operations[1];
Assert.Equal("IX_A_P1", dropIndexOperation.IndexName);
Assert.Equal("IX_A_P1", createIndexOperation.IndexName);
Assert.True(createIndexOperation.IsClustered);
}
public void Process_with_alter_column_operation_resets_unique_constraints_on_column()
{
var sourceModel = new Model();
var sourceModelBuilder = new BasicModelBuilder(sourceModel);
sourceModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
var p = b.Property <string>("P").Metadata;
b.Key("Id");
b.Metadata.AddKey(p);
});
var inOperations = new MigrationOperationCollection();
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("P", typeof(int)),
isDestructiveChange: false);
inOperations.Add(alterColumnOperation);
var operations = Process(inOperations, sourceModel);
Assert.Equal(3, operations.Count);
Assert.IsType <DropUniqueConstraintOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
Assert.IsType <AddUniqueConstraintOperation>(operations[2]);
var dropUniqueConstraintOperation = (DropUniqueConstraintOperation)operations[0];
var addUniqueConstraintOperation = (AddUniqueConstraintOperation)operations[2];
Assert.Equal("UC_A_P", dropUniqueConstraintOperation.UniqueConstraintName);
Assert.Equal("UC_A_P", addUniqueConstraintOperation.UniqueConstraintName);
Assert.Equal(new[] { "P" }, addUniqueConstraintOperation.ColumnNames.AsEnumerable());
}
public void Process_with_alter_column_operation_resets_indexes()
{
var sourceModel = new Model();
var sourceModelBuilder = new BasicModelBuilder(sourceModel);
sourceModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id");
b.Index("P");
});
var inOperations = new MigrationOperationCollection();
var alterColumnOperation
= new AlterColumnOperation(
"A",
new Column("P", typeof(int)),
isDestructiveChange: false);
inOperations.Add(alterColumnOperation);
var operations = Process(inOperations, sourceModel);
Assert.Equal(3, operations.Count);
Assert.IsType <DropIndexOperation>(operations[0]);
Assert.Same(alterColumnOperation, operations[1]);
Assert.IsType <CreateIndexOperation>(operations[2]);
var dropIndexOperation = (DropIndexOperation)operations[0];
var createIndexOperation = (CreateIndexOperation)operations[2];
Assert.Equal("IX_A_P", dropIndexOperation.IndexName);
Assert.Equal("IX_A_P", createIndexOperation.IndexName);
Assert.Equal(new[] { "P" }, createIndexOperation.ColumnNames.AsEnumerable());
}
public void Generate_entity_type_with_multiple_properties_with_annotations()
{
var builder = new BasicModelBuilder();
builder.Entity <Customer>(b =>
{
b.Property(e => e.Id)
.Annotation("A1", "V1")
.Annotation("A2", "V2");
b.Property(e => e.Name)
.Annotation("A1", "V1")
.Annotation("A2", "V2");
b.Key(e => e.Id);
});
var stringBuilder = new IndentedStringBuilder();
new CSharpModelCodeGenerator().Generate(builder.Model, stringBuilder);
Assert.Equal(
@"var builder = new BasicModelBuilder();
builder.Entity(""Microsoft.Data.Entity.Commands.Tests.Migrations.CSharpModelCodeGeneratorTest+Customer"", b =>
{
b.Property<int>(""Id"")
.Annotation(""A1"", ""V1"")
.Annotation(""A2"", ""V2"");
b.Property<string>(""Name"")
.Annotation(""A1"", ""V1"")
.Annotation(""A2"", ""V2"");
b.Key(""Id"");
});
return builder.Model;",
stringBuilder.ToString());
GenerateAndValidateCode(builder.Model);
}
public void Visit_with_create_table_operation_followed_by_unsupported_table_subordinate_operation()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("T1",
b =>
{
b.Property <int>("Id");
b.Key("Id");
});
var operation
= new CreateTableOperation(
new Table("T2", new[]
{
new Column("C", typeof(int))
}));
var addForeignKeyOperation
= new AddForeignKeyOperation("T2", "FK", new[] { "C" }, "T1", new[] { "Id" }, cascadeDelete: true);
var operations = PreProcess(modelBuilder, operation, addForeignKeyOperation);
Assert.Equal(1, operations.Count);
Assert.IsType <CreateTableOperation>(operations[0]);
var createTableOperation = (CreateTableOperation)operations[0];
Assert.NotSame(operation, createTableOperation);
Assert.NotSame(operation.Table, createTableOperation.Table);
Assert.Equal("T2", createTableOperation.Table.Name);
Assert.Equal(new[] { "C" }, createTableOperation.Table.Columns.Select(c => c.Name));
Assert.Equal(new[] { typeof(int) }, createTableOperation.Table.Columns.Select(c => c.ClrType));
Assert.Equal(1, createTableOperation.Table.ForeignKeys.Count);
Assert.Equal("FK", createTableOperation.Table.ForeignKeys[0].Name);
Assert.Equal("T1", createTableOperation.Table.ForeignKeys[0].ReferencedTable.Name);
Assert.Equal(new[] { "C" }, createTableOperation.Table.ForeignKeys[0].Columns.Select(c => c.Name));
Assert.Equal(new[] { "Id" }, createTableOperation.Table.ForeignKeys[0].ReferencedColumns.Select(c => c.Name));
}
public void Can_get_and_set_table_name()
{
var modelBuilder = new BasicModelBuilder();
var entityType = modelBuilder
.Entity<Customer>()
.Metadata;
Assert.Equal("Customer", entityType.SqlServer().Table);
Assert.Equal("Customer", ((IEntityType)entityType).SqlServer().Table);
entityType.Relational().Table = "Customizer";
Assert.Equal("Customer", entityType.DisplayName());
Assert.Equal("Customer", ((IEntityType)entityType).DisplayName());
Assert.Equal("Customizer", entityType.Relational().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).Relational().Table);
Assert.Equal("Customizer", entityType.SqlServer().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).SqlServer().Table);
entityType.SqlServer().Table = "Custardizer";
Assert.Equal("Customer", entityType.DisplayName());
Assert.Equal("Customer", ((IEntityType)entityType).DisplayName());
Assert.Equal("Customizer", entityType.Relational().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).Relational().Table);
Assert.Equal("Custardizer", entityType.SqlServer().Table);
Assert.Equal("Custardizer", ((IEntityType)entityType).SqlServer().Table);
entityType.SqlServer().Table = null;
Assert.Equal("Customer", entityType.DisplayName());
Assert.Equal("Customer", ((IEntityType)entityType).DisplayName());
Assert.Equal("Customizer", entityType.Relational().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).Relational().Table);
Assert.Equal("Customizer", entityType.SqlServer().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).SqlServer().Table);
}
public void Can_get_and_set_table_name()
{
var modelBuilder = new BasicModelBuilder();
var entityType = modelBuilder
.Entity <Customer>()
.Metadata;
Assert.Equal("Customer", entityType.SqlServer().Table);
Assert.Equal("Customer", ((IEntityType)entityType).SqlServer().Table);
entityType.Relational().Table = "Customizer";
Assert.Equal("Customer", entityType.SimpleName);
Assert.Equal("Customer", ((IEntityType)entityType).SimpleName);
Assert.Equal("Customizer", entityType.Relational().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).Relational().Table);
Assert.Equal("Customizer", entityType.SqlServer().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).SqlServer().Table);
entityType.SqlServer().Table = "Custardizer";
Assert.Equal("Customer", entityType.SimpleName);
Assert.Equal("Customer", ((IEntityType)entityType).SimpleName);
Assert.Equal("Customizer", entityType.Relational().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).Relational().Table);
Assert.Equal("Custardizer", entityType.SqlServer().Table);
Assert.Equal("Custardizer", ((IEntityType)entityType).SqlServer().Table);
entityType.SqlServer().Table = null;
Assert.Equal("Customer", entityType.SimpleName);
Assert.Equal("Customer", ((IEntityType)entityType).SimpleName);
Assert.Equal("Customizer", entityType.Relational().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).Relational().Table);
Assert.Equal("Customizer", entityType.SqlServer().Table);
Assert.Equal("Customizer", ((IEntityType)entityType).SqlServer().Table);
}
public void Generate_when_alter_column_operation_with_nullable()
{
var model = new Entity.Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity("E",
b =>
{
b.Property <int>("Id");
b.Property <int?>("Foo");
b.Key("Id");
b.ForRelational().Table("MyTable", "dbo");
});
var operation = new AlterColumnOperation(
"dbo.MyTable",
OperationFactory().Column(model.GetEntityType("E").GetProperty("Foo")),
isDestructiveChange: false);
Assert.Equal(
@"ALTER TABLE ""dbo"".""MyTable"" ALTER COLUMN ""Foo"" integer NULL",
Generate(operation, model));
}
public void Visit_with_rename_operation_followed_by_supported_table_subordinate_operation()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("T",
b =>
{
b.Property <int>("Id");
b.Key("Id");
// TODO: SQLite-specific. Issue #875
b.ForRelational().Table("T", "dbo");
});
var moveTableOperation = new MoveTableOperation("dbo.T", "dbo2");
var renameTableOperation = new RenameTableOperation("dbo2.T", "T2");
var addColumnOperation = new AddColumnOperation("dbo2.T2", new Column("C", typeof(string)));
var operations = PreProcess(modelBuilder, moveTableOperation, renameTableOperation, addColumnOperation);
Assert.Equal(3, operations.Count);
Assert.Same(moveTableOperation, operations[0]);
Assert.Same(renameTableOperation, operations[1]);
Assert.Same(addColumnOperation, operations[2]);
}
public void Sequences_are_matched_if_named_on_matching_properties_of_fuzzy_matched_entity_types()
{
var sourceModelBuilder = new BasicModelBuilder();
sourceModelBuilder.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <int>("P1").ForSqlServer().UseSequence("S1");
b.Key("Id").ForSqlServer().Name("PK");
});
var targetModelBuilder = new BasicModelBuilder();
targetModelBuilder.Entity("B",
b =>
{
b.Property <int>("Id");
b.Property <int>("P1").ForSqlServer().UseSequence("S2");
b.Property <string>("P2");
b.Key("Id").ForSqlServer().Name("PK");
});
var operations = new SqlServerModelDiffer(new SqlServerDatabaseBuilder(new SqlServerTypeMapper())).Diff(
sourceModelBuilder.Model, targetModelBuilder.Model);
Assert.Equal(3, operations.Count);
Assert.IsType <RenameSequenceOperation>(operations[0]);
Assert.IsType <RenameTableOperation>(operations[1]);
Assert.IsType <AddColumnOperation>(operations[2]);
var renameSequenceOperation = (RenameSequenceOperation)operations[0];
Assert.Equal("S1", renameSequenceOperation.SequenceName);
Assert.Equal("S2", renameSequenceOperation.NewSequenceName);
}
public void Diff_finds_altered_column_if_string_property_removed_from_primary_key()
{
var sourceModelBuilder = new BasicModelBuilder();
sourceModelBuilder
.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id", "P").ForRelational().Name("PK");
});
var targetModelBuilder = new BasicModelBuilder();
targetModelBuilder
.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id").ForRelational().Name("PK");
});
var operations = new SqlServerModelDiffer(new SqlServerDatabaseBuilder(new SqlServerTypeMapper())).Diff(
sourceModelBuilder.Model, targetModelBuilder.Model);
Assert.Equal(3, operations.Count);
Assert.IsType <DropPrimaryKeyOperation>(operations[0]);
Assert.IsType <AlterColumnOperation>(operations[1]);
Assert.IsType <AddPrimaryKeyOperation>(operations[2]);
var alterColumnOperation = (AlterColumnOperation)operations[1];
Assert.Equal("P", alterColumnOperation.NewColumn.Name);
Assert.Equal("nvarchar(max)", alterColumnOperation.NewColumn.DataType);
}
public void Generate_when_create_table_with_unique_constraints()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity("E",
b =>
{
b.Property <int>("Foo").ForRelational().DefaultValue(5);
var bar = b.Property <int?>("Bar").Metadata;
var c1 = b.Property <string>("C1").Metadata;
var c2 = b.Property <string>("C2").Metadata;
b.Key("Foo").ForRelational().Name("MyPK");
b.Metadata.AddKey(c1).Relational().Name = "MyUC0";
b.Metadata.AddKey(new[] { bar, c2 }).Relational().Name = "MyUC1";
b.ForRelational().Table("MyTable", "dbo");
});
var operation = OperationFactory().CreateTableOperation(model.GetEntityType("E"));
Assert.Equal(
@"CreateTable(""dbo.MyTable"",
c => new
{
Foo = c.Int(nullable: false, defaultValue: 5),
Bar = c.Int(),
C1 = c.String(),
C2 = c.String()
})
.PrimaryKey(""MyPK"", t => t.Foo)
.UniqueConstraint(""MyUC0"", t => t.C1)
.UniqueConstraint(""MyUC1"", t => new { t.Bar, t.C2 })",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
public void Process_with_alter_column_operation_and_timestamp_column()
{
var sourceModel = new Model();
var sourceModelBuilder = new BasicModelBuilder(sourceModel);
sourceModelBuilder.Entity("A",
b =>
{
b.Property <byte[]>("Id").ConcurrencyToken();
b.Property <string>("P");
b.Key("Id");
});
var inOperations = new MigrationOperationCollection();
inOperations.Add(
new AlterColumnOperation(
"A",
new Column("Id", typeof(byte[])),
isDestructiveChange: true));
var operations = Process(inOperations, sourceModel);
Assert.Equal(4, operations.Count);
Assert.IsType <DropPrimaryKeyOperation>(operations[0]);
Assert.IsType <DropColumnOperation>(operations[1]);
Assert.IsType <AddColumnOperation>(operations[2]);
Assert.IsType <AddPrimaryKeyOperation>(operations[3]);
var dropColumnOperation = (DropColumnOperation)operations[1];
var addColumnOperation = (AddColumnOperation)operations[2];
Assert.Equal("Id", dropColumnOperation.ColumnName);
Assert.Equal("Id", addColumnOperation.Column.Name);
Assert.False(addColumnOperation.Column.IsTimestamp);
}
public void Can_get_and_set_column_name()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity <Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Equal("Name", property.Relational().Column);
Assert.Equal("Name", ((IProperty)property).Relational().Column);
property.Relational().Column = "Eman";
Assert.Equal("Name", property.Name);
Assert.Equal("Name", ((IProperty)property).Name);
Assert.Equal("Eman", property.Relational().Column);
Assert.Equal("Eman", ((IProperty)property).Relational().Column);
property.Relational().Column = null;
Assert.Equal("Name", property.Relational().Column);
Assert.Equal("Name", ((IProperty)property).Relational().Column);
}
public void Can_get_and_set_column_default_value()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity <Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Null(property.Relational().DefaultValue);
Assert.Null(((IProperty)property).Relational().DefaultValue);
var guid = new Guid("{3FDFC4F5-AEAB-4D72-9C96-201E004349FA}");
property.Relational().DefaultValue = guid;
Assert.Equal(guid, property.Relational().DefaultValue);
Assert.Equal(guid, ((IProperty)property).Relational().DefaultValue);
property.Relational().DefaultValue = null;
Assert.Null(property.Relational().DefaultValue);
Assert.Null(((IProperty)property).Relational().DefaultValue);
}
public void Diff_finds_altered_column_if_string_property_added_to_primary_key()
{
var sourceModelBuilder = new BasicModelBuilder();
sourceModelBuilder
.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id").ForRelational().Name("PK");
});
var targetModelBuilder = new BasicModelBuilder();
targetModelBuilder
.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id", "P").ForRelational().Name("PK");
});
var operations = Diff(sourceModelBuilder.Model, targetModelBuilder.Model);
Assert.Equal(3, operations.Count);
Assert.IsType <DropPrimaryKeyOperation>(operations[0]);
Assert.IsType <AlterColumnOperation>(operations[1]);
Assert.IsType <AddPrimaryKeyOperation>(operations[2]);
var alterColumnOperation = (AlterColumnOperation)operations[1];
Assert.Equal("P", alterColumnOperation.NewColumn.Name);
Assert.Null(alterColumnOperation.NewColumn.DataType);
}
public void Properties_are_required_by_default_only_if_CLR_type_is_nullable()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity <Quarks>(b =>
{
b.Property(e => e.Up);
b.Property(e => e.Down);
b.Property <int>("Charm");
b.Property <string>("Strange");
b.Property(typeof(int), "Top");
b.Property(typeof(string), "Bottom");
});
var entityType = (IEntityType)model.GetEntityType(typeof(Quarks));
Assert.False(entityType.GetProperty("Up").IsNullable);
Assert.True(entityType.GetProperty("Down").IsNullable);
Assert.False(entityType.GetProperty("Charm").IsNullable);
Assert.True(entityType.GetProperty("Strange").IsNullable);
Assert.False(entityType.GetProperty("Top").IsNullable);
Assert.True(entityType.GetProperty("Bottom").IsNullable);
}
public void Properties_can_be_made_required()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity <Quarks>(b =>
{
b.Property(e => e.Up).Required();
b.Property(e => e.Down).Required();
b.Property <int>("Charm").Required();
b.Property <string>("Strange").Required();
b.Property(typeof(int), "Top").Required();
b.Property(typeof(string), "Bottom").Required();
});
var entityType = (IEntityType)model.GetEntityType(typeof(Quarks));
Assert.False(entityType.GetProperty("Up").IsNullable);
Assert.False(entityType.GetProperty("Down").IsNullable);
Assert.False(entityType.GetProperty("Charm").IsNullable);
Assert.False(entityType.GetProperty("Strange").IsNullable);
Assert.False(entityType.GetProperty("Top").IsNullable);
Assert.False(entityType.GetProperty("Bottom").IsNullable);
}
public void Generate_when_create_table_operation()
{
var model = new Entity.Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity("E",
b =>
{
b.Property <int>("Foo").ForRelational().DefaultValue(5);
b.Property <int?>("Bar");
b.ForRelational().Table("MyTable", "dbo");
b.Key("Foo", "Bar").ForRelational().Name("MyPK");
});
var operation = OperationFactory().CreateTableOperation(model.GetEntityType("E"));
Assert.Equal(
@"CREATE TABLE ""dbo"".""MyTable"" (
""Foo"" integer NOT NULL DEFAULT 5,
""Bar"" integer,
CONSTRAINT ""MyPK"" PRIMARY KEY (""Foo"", ""Bar"")
)",
Generate(operation, model));
}
public void Build_creates_sequence_with_defaults_specified_on_property()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A",
b =>
{
b.Property <int>("Id").ForSqlServer().UseSequence();
b.Key("Id");
b.ForSqlServer().Table("T", "dbo");
});
var databaseBuilder = new SqlServerDatabaseBuilder(new SqlServerTypeMapper());
var database = databaseBuilder.GetDatabase(modelBuilder.Model);
Assert.Equal(1, database.Sequences.Count);
var sequence = database.Sequences[0];
Assert.Equal("EntityFrameworkDefaultSequence", sequence.Name);
Assert.Equal("bigint", sequence.DataType);
Assert.Equal(1, sequence.StartWith);
Assert.Equal(10, sequence.IncrementBy);
}
public void Can_get_and_set_index_clustering()
{
var modelBuilder = new BasicModelBuilder();
var index = modelBuilder
.Entity<Customer>()
.Index(e => e.Id)
.Metadata;
Assert.Null(index.SqlServer().IsClustered);
Assert.Null(((IIndex)index).SqlServer().IsClustered);
index.SqlServer().IsClustered = true;
Assert.True(index.SqlServer().IsClustered.Value);
Assert.True(((IIndex)index).SqlServer().IsClustered.Value);
index.SqlServer().IsClustered = null;
Assert.Null(index.SqlServer().IsClustered);
Assert.Null(((IIndex)index).SqlServer().IsClustered);
}
public void Diff_finds_altered_columns_if_string_property_removed_from_foreign_key()
{
var sourceModelBuilder = new BasicModelBuilder();
sourceModelBuilder
.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P1");
b.Key("Id", "P1");
});
sourceModelBuilder
.Entity("B",
b =>
{
b.Property <int>("Id");
b.Property <string>("P2");
b.Key("Id");
b.ForeignKey("A", "Id", "P2");
});
var targetModelBuilder = new BasicModelBuilder();
targetModelBuilder
.Entity("A",
b =>
{
b.Property <int>("Id");
b.Property <string>("P1");
b.Key("Id");
});
targetModelBuilder
.Entity("B",
b =>
{
b.Property <int>("Id");
b.Property <string>("P2");
b.Key("Id");
b.ForeignKey("A", "Id");
});
var operations = new SqlServerModelDiffer(new SqlServerDatabaseBuilder(new SqlServerTypeMapper())).Diff(
sourceModelBuilder.Model, targetModelBuilder.Model);
Assert.Equal(6, operations.Count);
Assert.IsType <DropForeignKeyOperation>(operations[0]);
Assert.IsType <DropPrimaryKeyOperation>(operations[1]);
Assert.IsType <AlterColumnOperation>(operations[2]);
Assert.IsType <AlterColumnOperation>(operations[3]);
Assert.IsType <AddPrimaryKeyOperation>(operations[4]);
Assert.IsType <AddForeignKeyOperation>(operations[5]);
var alterColumnOperation1 = (AlterColumnOperation)operations[2];
var alterColumnOperation2 = (AlterColumnOperation)operations[3];
Assert.Equal("P1", alterColumnOperation1.NewColumn.Name);
Assert.Equal("P2", alterColumnOperation2.NewColumn.Name);
Assert.Equal("nvarchar(max)", alterColumnOperation1.NewColumn.DataType);
Assert.Equal("nvarchar(max)", alterColumnOperation2.NewColumn.DataType);
}
public void Can_add_index_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity(typeof(Customer).FullName, b =>
{
b.Property<string>("Name");
b.Index("Name");
});
var entityType = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entityType.Indexes.Count());
}
public void Throws_setting_sequence_generation_for_invalid_type()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Equal(
Strings.SequenceBadType("Name", typeof(Customer).FullName, "String"),
Assert.Throws<ArgumentException>(
() => property.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Sequence).Message);
}
protected Model CreateModel()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
OnModelCreating(modelBuilder);
modelBuilder.Entity <Customer>(e =>
{
e.Key(c => c.CustomerID);
e.Property(c => c.CompanyName);
e.Property(c => c.ContactName);
e.Property(c => c.ContactTitle);
e.Property(c => c.Address);
e.Property(c => c.City);
e.Property(c => c.Region);
e.Property(c => c.PostalCode);
e.Property(c => c.Country);
e.Property(c => c.Phone);
e.Property(c => c.Fax);
});
modelBuilder.Entity <Employee>(e =>
{
e.Key(em => em.EmployeeID);
e.Property(em => em.City);
e.Property(em => em.Country);
e.Property(em => em.FirstName);
e.Property(em => em.ReportsTo);
e.Property <string>("Title");
});
modelBuilder.Entity <Product>(e =>
{
e.Key(p => p.ProductID);
e.Property(p => p.ProductName);
});
modelBuilder.Entity <Order>(e =>
{
e.Key(o => o.OrderID);
e.Property(o => o.OrderDate);
e.ForeignKey <Customer>(o => o.CustomerID);
});
modelBuilder.Entity <OrderDetail>(e =>
{
e.Key(od => new { od.OrderID, od.ProductID });
e.Property(od => od.UnitPrice);
e.Property(od => od.Quantity);
e.Property(od => od.Discount);
e.ForeignKey <Product>(od => od.ProductID);
e.ForeignKey <Order>(od => od.OrderID);
});
// TODO: Use FAPIS when avail.
var productType = model.GetEntityType(typeof(Product));
var customerType = model.GetEntityType(typeof(Customer));
var orderType = model.GetEntityType(typeof(Order));
var orderDetailType = model.GetEntityType(typeof(OrderDetail));
var customerIdFk = orderType.ForeignKeys.Single();
var productIdFk = orderDetailType.ForeignKeys.Single(fk => fk.ReferencedEntityType == productType);
var orderIdFk = orderDetailType.ForeignKeys.Single(fk => fk.ReferencedEntityType == orderType);
productType.AddNavigation("OrderDetails", productIdFk, pointsToPrincipal: false);
customerType.AddNavigation("Orders", customerIdFk, pointsToPrincipal: false);
orderType.AddNavigation("Customer", customerIdFk, pointsToPrincipal: true);
orderType.AddNavigation("OrderDetails", orderIdFk, pointsToPrincipal: false);
orderDetailType.AddNavigation("Product", productIdFk, pointsToPrincipal: true);
orderDetailType.AddNavigation("Order", orderIdFk, pointsToPrincipal: true);
return(model);
}
public void TryGetSequence_with_schema_returns_sequence_model_is_marked_for_sequence_generation_and_model_has_name()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Id)
.Metadata;
modelBuilder.Model.SqlServer().AddOrReplaceSequence(new Sequence("DaneelOlivaw", "R"));
modelBuilder.Model.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Sequence;
modelBuilder.Model.SqlServer().DefaultSequenceName = "DaneelOlivaw";
modelBuilder.Model.SqlServer().DefaultSequenceSchema = "R";
property.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Default;
Assert.Equal("DaneelOlivaw", property.SqlServer().TryGetSequence().Name);
Assert.Equal("DaneelOlivaw", ((IProperty)property).SqlServer().TryGetSequence().Name);
Assert.Equal("R", property.SqlServer().TryGetSequence().Schema);
Assert.Equal("R", ((IProperty)property).SqlServer().TryGetSequence().Schema);
}
public void TryGetSequence_returns_sequence_property_is_marked_for_sequence_generation()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Id)
.Metadata;
modelBuilder.Model.SqlServer().AddOrReplaceSequence(new Sequence("DaneelOlivaw"));
property.SqlServer().SequenceName = "DaneelOlivaw";
property.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Sequence;
Assert.Equal("DaneelOlivaw", property.SqlServer().TryGetSequence().Name);
Assert.Equal("DaneelOlivaw", ((IProperty)property).SqlServer().TryGetSequence().Name);
}
public void TryGetSequence_returns_null_if_property_is_not_configured_for_sequence_value_generation()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Id)
.Metadata;
modelBuilder.Model.SqlServer().AddOrReplaceSequence(new Sequence("DaneelOlivaw"));
Assert.Null(property.SqlServer().TryGetSequence());
Assert.Null(((IProperty)property).SqlServer().TryGetSequence());
property.SqlServer().SequenceName = "DaneelOlivaw";
Assert.Null(property.SqlServer().TryGetSequence());
Assert.Null(((IProperty)property).SqlServer().TryGetSequence());
modelBuilder.Model.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Identity;
Assert.Null(property.SqlServer().TryGetSequence());
Assert.Null(((IProperty)property).SqlServer().TryGetSequence());
modelBuilder.Model.SqlServer().ValueGenerationStrategy = null;
property.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Identity;
Assert.Null(property.SqlServer().TryGetSequence());
Assert.Null(((IProperty)property).SqlServer().TryGetSequence());
}
public void Can_get_and_set_sequence_schema_on_property()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Id)
.Metadata;
Assert.Null(property.SqlServer().SequenceSchema);
Assert.Null(((IProperty)property).SqlServer().SequenceSchema);
property.SqlServer().SequenceSchema = "Tasty";
Assert.Equal("Tasty", property.SqlServer().SequenceSchema);
Assert.Equal("Tasty", ((IProperty)property).SqlServer().SequenceSchema);
property.SqlServer().SequenceSchema = null;
Assert.Null(property.SqlServer().SequenceSchema);
Assert.Null(((IProperty)property).SqlServer().SequenceSchema);
}
public void Visit_with_consecutive_alter_column_operations()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("A", b =>
{
b.Property <string>("Id");
b.Key("Id");
b.Index("Id").IsClustered(false);
});
modelBuilder.Entity("B", b =>
{
b.Property <string>("Id");
b.Key("Id");
b.ForeignKey("A", "Id");
b.Index("Id").IsClustered(false);
});
modelBuilder.Entity("A", b => b.ForeignKey("B", "Id"));
var alterColumnOperation0
= new AlterColumnOperation(
"B",
new Column("Id", typeof(int))
{
IsNullable = false
}, true);
var alterColumnOperation1
= new AlterColumnOperation(
"A",
new Column("Id", typeof(int))
{
IsNullable = false
}, true);
var operations = PreProcess(modelBuilder, alterColumnOperation0, alterColumnOperation1);
Assert.Equal(14, operations.Count);
Assert.IsType <DropIndexOperation>(operations[0]);
Assert.IsType <DropIndexOperation>(operations[1]);
Assert.IsType <DropForeignKeyOperation>(operations[2]);
Assert.IsType <DropForeignKeyOperation>(operations[3]);
Assert.IsType <DropPrimaryKeyOperation>(operations[4]);
Assert.IsType <DropPrimaryKeyOperation>(operations[5]);
Assert.Same(alterColumnOperation0, operations[6]);
Assert.Same(alterColumnOperation1, operations[7]);
Assert.IsType <AddPrimaryKeyOperation>(operations[8]);
Assert.IsType <AddPrimaryKeyOperation>(operations[9]);
Assert.IsType <AddForeignKeyOperation>(operations[10]);
Assert.IsType <AddForeignKeyOperation>(operations[11]);
Assert.IsType <CreateIndexOperation>(operations[12]);
Assert.IsType <CreateIndexOperation>(operations[13]);
var dropIndexOperation0 = (DropIndexOperation)operations[0];
var dropIndexOperation1 = (DropIndexOperation)operations[1];
var dropForeignKeyOperation0 = (DropForeignKeyOperation)operations[2];
var dropForeignKeyOperation1 = (DropForeignKeyOperation)operations[3];
var dropPrimaryKeyOperation0 = (DropPrimaryKeyOperation)operations[4];
var dropPrimaryKeyOperation1 = (DropPrimaryKeyOperation)operations[5];
var addPrimaryKeyOperation0 = (AddPrimaryKeyOperation)operations[8];
var addPrimaryKeyOperation1 = (AddPrimaryKeyOperation)operations[9];
var addForeignKeyOperation0 = (AddForeignKeyOperation)operations[10];
var addForeignKeyOperation1 = (AddForeignKeyOperation)operations[11];
var createIndexOperation0 = (CreateIndexOperation)operations[12];
var createIndexOperation1 = (CreateIndexOperation)operations[13];
Assert.Equal("IX_B_Id", dropIndexOperation0.IndexName);
Assert.Equal("IX_A_Id", dropIndexOperation1.IndexName);
Assert.Equal("FK_B_A_Id", dropForeignKeyOperation0.ForeignKeyName);
Assert.Equal("FK_A_B_Id", dropForeignKeyOperation1.ForeignKeyName);
Assert.Equal("PK_B", dropPrimaryKeyOperation0.PrimaryKeyName);
Assert.Equal("PK_A", dropPrimaryKeyOperation1.PrimaryKeyName);
Assert.Equal("PK_B", addPrimaryKeyOperation0.PrimaryKeyName);
Assert.Equal(new[] { "Id" }, addPrimaryKeyOperation0.ColumnNames);
Assert.Equal("PK_A", addPrimaryKeyOperation1.PrimaryKeyName);
Assert.Equal(new[] { "Id" }, addPrimaryKeyOperation1.ColumnNames);
Assert.Equal("FK_B_A_Id", addForeignKeyOperation0.ForeignKeyName);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation0.ColumnNames);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation0.ReferencedColumnNames);
Assert.Equal("FK_A_B_Id", addForeignKeyOperation1.ForeignKeyName);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation1.ColumnNames);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation1.ReferencedColumnNames);
Assert.Equal("IX_B_Id", createIndexOperation0.IndexName);
Assert.Equal(new[] { "Id" }, createIndexOperation0.ColumnNames);
Assert.Equal("IX_A_Id", createIndexOperation1.IndexName);
Assert.Equal(new[] { "Id" }, createIndexOperation1.ColumnNames);
}
public void Throws_setting_identity_generation_for_nullable_byte_property()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.NullableByte)
.Metadata;
Assert.Equal(
Strings.IdentityBadType("NullableByte", typeof(Customer).FullName, "Nullable`1"),
Assert.Throws<ArgumentException>(
() => property.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Identity).Message);
}
public void Can_get_and_set_column_key_name()
{
var modelBuilder = new BasicModelBuilder();
var key = modelBuilder
.Entity<Customer>()
.Key(e => e.Id)
.Metadata;
Assert.Null(key.Relational().Name);
Assert.Null(((IKey)key).Relational().Name);
Assert.Null(key.SqlServer().Name);
Assert.Null(((IKey)key).SqlServer().Name);
key.Relational().Name = "PrimaryKey";
Assert.Equal("PrimaryKey", key.Relational().Name);
Assert.Equal("PrimaryKey", ((IKey)key).Relational().Name);
Assert.Equal("PrimaryKey", key.SqlServer().Name);
Assert.Equal("PrimaryKey", ((IKey)key).SqlServer().Name);
key.SqlServer().Name = "PrimarySchool";
Assert.Equal("PrimaryKey", key.Relational().Name);
Assert.Equal("PrimaryKey", ((IKey)key).Relational().Name);
Assert.Equal("PrimarySchool", key.SqlServer().Name);
Assert.Equal("PrimarySchool", ((IKey)key).SqlServer().Name);
key.SqlServer().Name = null;
Assert.Equal("PrimaryKey", key.Relational().Name);
Assert.Equal("PrimaryKey", ((IKey)key).Relational().Name);
Assert.Equal("PrimaryKey", key.SqlServer().Name);
Assert.Equal("PrimaryKey", ((IKey)key).SqlServer().Name);
}
public void Can_get_and_set_column_type()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Null(property.Relational().ColumnType);
Assert.Null(((IProperty)property).Relational().ColumnType);
Assert.Null(property.SqlServer().ColumnType);
Assert.Null(((IProperty)property).SqlServer().ColumnType);
property.Relational().ColumnType = "nvarchar(max)";
Assert.Equal("nvarchar(max)", property.Relational().ColumnType);
Assert.Equal("nvarchar(max)", ((IProperty)property).Relational().ColumnType);
Assert.Equal("nvarchar(max)", property.SqlServer().ColumnType);
Assert.Equal("nvarchar(max)", ((IProperty)property).SqlServer().ColumnType);
property.SqlServer().ColumnType = "nvarchar(verstappen)";
Assert.Equal("nvarchar(max)", property.Relational().ColumnType);
Assert.Equal("nvarchar(max)", ((IProperty)property).Relational().ColumnType);
Assert.Equal("nvarchar(verstappen)", property.SqlServer().ColumnType);
Assert.Equal("nvarchar(verstappen)", ((IProperty)property).SqlServer().ColumnType);
property.SqlServer().ColumnType = null;
Assert.Equal("nvarchar(max)", property.Relational().ColumnType);
Assert.Equal("nvarchar(max)", ((IProperty)property).Relational().ColumnType);
Assert.Equal("nvarchar(max)", property.SqlServer().ColumnType);
Assert.Equal("nvarchar(max)", ((IProperty)property).SqlServer().ColumnType);
}
public void Can_add_multiple_indexes_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity(typeof(Customer).FullName, b =>
{
b.Property<int>("Id");
b.Property<string>("Name");
b.Index("Id").IsUnique();
b.Index("Name").Annotation("A1", "V1");
});
var entityType = (IEntityType)model.GetEntityType(typeof(Customer));
Assert.Equal(2, entityType.GetIndexes().Count());
Assert.True(entityType.GetIndexes().First().IsUnique);
Assert.False(entityType.GetIndexes().Last().IsUnique);
Assert.Equal("V1", entityType.GetIndexes().Last()["A1"]);
}
protected static Model CreateModel()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity <Customer>(b =>
{
b.Key(c => c.CustomerID);
b.Property(c => c.CompanyName);
b.Property(c => c.ContactName);
b.Property(c => c.ContactTitle);
b.Property(c => c.Address);
b.Property(c => c.City);
b.Property(c => c.Region);
b.Property(c => c.PostalCode);
b.Property(c => c.Country);
b.Property(c => c.Phone);
b.Property(c => c.Fax);
});
modelBuilder.Entity <Employee>(b =>
{
b.Key(e => e.EmployeeID);
b.Property(e => e.City);
b.Property(e => e.Country);
b.Property(e => e.FirstName);
b.Property(e => e.ReportsTo);
b.Property <string>("Title");
});
modelBuilder.Entity <Product>(b =>
{
b.Key(e => e.ProductID);
b.Property(c => c.ProductName);
});
modelBuilder.Entity <Order>(ps =>
{
ps.Key(o => o.OrderID);
ps.Property(o => o.CustomerID);
ps.Property(o => o.OrderDate);
});
modelBuilder.Entity <OrderDetail>(b =>
{
b.Key(od => new { od.OrderID, od.ProductID });
b.Property(od => od.UnitPrice);
b.Property(od => od.Quantity);
b.Property(od => od.Discount);
b.ForeignKey <Product>(od => od.ProductID);
});
// TODO: Use FAPIS when avail.
var productType = model.GetEntityType(typeof(Product));
var orderDetailType = model.GetEntityType(typeof(OrderDetail));
var productIdFk = orderDetailType.ForeignKeys.Single();
orderDetailType.AddNavigation(new Navigation(productIdFk, "Product", pointsToPrincipal: true));
productType.AddNavigation(new Navigation(productIdFk, "OrderDetails", pointsToPrincipal: false));
return(model);
}
public void Can_get_and_set_column_foreign_key_name()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder
.Entity<Customer>()
.Key(e => e.Id);
var foreignKey = modelBuilder
.Entity<Order>()
.ForeignKey<Customer>(e => e.CustomerId)
.Metadata;
Assert.Null(foreignKey.Relational().Name);
Assert.Null(((IForeignKey)foreignKey).Relational().Name);
Assert.Null(foreignKey.SqlServer().Name);
Assert.Null(((IForeignKey)foreignKey).SqlServer().Name);
foreignKey.Relational().Name = "FK";
Assert.Equal("FK", foreignKey.Relational().Name);
Assert.Equal("FK", ((IForeignKey)foreignKey).Relational().Name);
Assert.Equal("FK", foreignKey.SqlServer().Name);
Assert.Equal("FK", ((IForeignKey)foreignKey).SqlServer().Name);
foreignKey.SqlServer().Name = "KFC";
Assert.Equal("FK", foreignKey.Relational().Name);
Assert.Equal("FK", ((IForeignKey)foreignKey).Relational().Name);
Assert.Equal("KFC", foreignKey.SqlServer().Name);
Assert.Equal("KFC", ((IForeignKey)foreignKey).SqlServer().Name);
foreignKey.SqlServer().Name = null;
Assert.Equal("FK", foreignKey.Relational().Name);
Assert.Equal("FK", ((IForeignKey)foreignKey).Relational().Name);
Assert.Equal("FK", foreignKey.SqlServer().Name);
Assert.Equal("FK", ((IForeignKey)foreignKey).SqlServer().Name);
}
public void Generate_entity_type_with_multiple_foreign_keys_with_annotations()
{
var builder = new BasicModelBuilder();
builder.Entity <Customer>(b =>
{
b.Property(e => e.Id);
b.Property(e => e.Name);
b.Key(e => new { e.Id, e.Name });
});
builder.Entity <Order>(b =>
{
b.Property(e => e.Id);
b.Property(e => e.CustomerId);
b.Property(e => e.CustomerName);
b.Property(e => e.ProductId);
b.Key(e => e.Id);
});
builder.Entity <Product>(b =>
{
b.Property(e => e.Id);
b.Key(e => e.Id);
});
builder.Entity <Order>(b =>
{
b.ForeignKey <Customer>(e => new { e.CustomerId, e.CustomerName })
.Annotation("A1", "V1")
.Annotation("A2", "V2");
b.ForeignKey <Product>(e => e.ProductId)
.Annotation("A3", "V3")
.Annotation("A4", "V4");
});
var stringBuilder = new IndentedStringBuilder();
new CSharpModelCodeGenerator().Generate(builder.Model, stringBuilder);
Assert.Equal(
@"var builder = new BasicModelBuilder();
builder.Entity(""Microsoft.Data.Entity.Commands.Tests.Migrations.CSharpModelCodeGeneratorTest+Customer"", b =>
{
b.Property<int>(""Id"");
b.Property<string>(""Name"");
b.Key(""Id"", ""Name"");
});
builder.Entity(""Microsoft.Data.Entity.Commands.Tests.Migrations.CSharpModelCodeGeneratorTest+Order"", b =>
{
b.Property<int>(""CustomerId"");
b.Property<string>(""CustomerName"");
b.Property<int>(""Id"");
b.Property<int>(""ProductId"");
b.Key(""Id"");
b.ForeignKey(""Microsoft.Data.Entity.Commands.Tests.Migrations.CSharpModelCodeGeneratorTest+Customer"", ""CustomerId"", ""CustomerName"")
.Annotation(""A1"", ""V1"")
.Annotation(""A2"", ""V2"");
b.ForeignKey(""Microsoft.Data.Entity.Commands.Tests.Migrations.CSharpModelCodeGeneratorTest+Product"", ""ProductId"")
.Annotation(""A3"", ""V3"")
.Annotation(""A4"", ""V4"");
});
builder.Entity(""Microsoft.Data.Entity.Commands.Tests.Migrations.CSharpModelCodeGeneratorTest+Product"", b =>
{
b.Property<int>(""Id"");
b.Key(""Id"");
});
return builder.Model;",
stringBuilder.ToString());
}
public void Can_get_and_set_value_generation_on_nullable_property()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.NullableInt)
.Metadata;
Assert.Null(property.SqlServer().ValueGenerationStrategy);
Assert.Null(((IProperty)property).SqlServer().ValueGenerationStrategy);
Assert.Null(property.GenerateValueOnAdd);
Assert.False(((IProperty)property).IsValueGeneratedOnAdd);
property.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Sequence;
Assert.Equal(SqlServerValueGenerationStrategy.Sequence, property.SqlServer().ValueGenerationStrategy);
Assert.Equal(SqlServerValueGenerationStrategy.Sequence, ((IProperty)property).SqlServer().ValueGenerationStrategy);
Assert.Equal(true, property.GenerateValueOnAdd);
property.SqlServer().ValueGenerationStrategy = null;
Assert.Null(property.SqlServer().ValueGenerationStrategy);
Assert.Null(((IProperty)property).SqlServer().ValueGenerationStrategy);
Assert.Null(property.GenerateValueOnAdd);
}
public void Table_operation_order_is_retained()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("T1",
b =>
{
b.Property <int>("Id");
b.Property <string>("P");
b.Key("Id");
});
modelBuilder.Entity("T2",
b =>
{
b.Property <int>("Id");
b.Key("Id");
});
var createTableOperation
= new CreateTableOperation(
new Table("T3", new[]
{
new Column("C", typeof(int))
}));
var addForeignKeyOperation
= new AddForeignKeyOperation("T3", "FK", new[] { "C" }, "T1", new[] { "Id" }, cascadeDelete: true);
var addColumnOperation = new AddColumnOperation("T2", new Column("C", typeof(string)));
var dropColumOperation = new DropColumnOperation("T1", "P");
var operations = PreProcess(modelBuilder, createTableOperation, addForeignKeyOperation, addColumnOperation, dropColumOperation);
Assert.Equal(6, operations.Count);
Assert.IsType <CreateTableOperation>(operations[0]);
Assert.IsType <AddColumnOperation>(operations[1]);
Assert.IsType <RenameTableOperation>(operations[2]);
Assert.IsType <CreateTableOperation>(operations[3]);
Assert.IsType <CopyDataOperation>(operations[4]);
Assert.IsType <DropTableOperation>(operations[5]);
var createTableOperation1 = (CreateTableOperation)operations[0];
Assert.Equal("T3", createTableOperation1.Table.Name);
Assert.Equal(1, createTableOperation1.Table.ForeignKeys.Count);
Assert.Equal("FK", createTableOperation1.Table.ForeignKeys[0].Name);
Assert.Same(addColumnOperation, operations[1]);
var renameTableOperation = (RenameTableOperation)operations[2];
Assert.Equal("T1", renameTableOperation.TableName);
Assert.Equal("__mig_tmp__T1", renameTableOperation.NewTableName);
var createTableOperation2 = (CreateTableOperation)operations[3];
Assert.Equal("T1", createTableOperation2.Table.Name);
Assert.Equal(new[] { "Id" }, createTableOperation2.Table.Columns.Select(c => c.Name));
var copyDataOperation = (CopyDataOperation)operations[4];
Assert.Equal("__mig_tmp__T1", copyDataOperation.SourceTableName);
Assert.Equal(new[] { "Id" }, copyDataOperation.SourceColumnNames);
Assert.Equal("T1", copyDataOperation.TargetTableName);
Assert.Equal(new[] { "Id" }, copyDataOperation.TargetColumnNames);
var dropTableOperation = (DropTableOperation)operations[5];
Assert.Equal("__mig_tmp__T1", dropTableOperation.TableName);
}
public void Can_get_and_set_key_clustering()
{
var modelBuilder = new BasicModelBuilder();
var key = modelBuilder
.Entity<Customer>()
.Key(e => e.Id)
.Metadata;
Assert.Null(key.SqlServer().IsClustered);
Assert.Null(((IKey)key).SqlServer().IsClustered);
key.SqlServer().IsClustered = true;
Assert.True(key.SqlServer().IsClustered.Value);
Assert.True(((IKey)key).SqlServer().IsClustered.Value);
key.SqlServer().IsClustered = null;
Assert.Null(key.SqlServer().IsClustered);
Assert.Null(((IKey)key).SqlServer().IsClustered);
}
private static IModel CreateModel()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity<Test>(b =>
{
b.Key(c => c.Id);
b.Property(c => c.Name);
});
return model;
}
public void Can_get_and_set_column_default_value()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Null(property.Relational().DefaultValue);
Assert.Null(((IProperty)property).Relational().DefaultValue);
Assert.Null(property.SqlServer().DefaultValue);
Assert.Null(((IProperty)property).SqlServer().DefaultValue);
property.Relational().DefaultValue = new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 };
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, property.Relational().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, ((IProperty)property).Relational().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, property.SqlServer().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, ((IProperty)property).SqlServer().DefaultValue);
property.SqlServer().DefaultValue = new Byte[] { 69, 70, 32, 83, 79, 67, 75, 83 };
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, property.Relational().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, ((IProperty)property).Relational().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 83, 79, 67, 75, 83 }, property.SqlServer().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 83, 79, 67, 75, 83 }, ((IProperty)property).SqlServer().DefaultValue);
property.SqlServer().DefaultValue = null;
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, property.Relational().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, ((IProperty)property).Relational().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, property.SqlServer().DefaultValue);
Assert.Equal(new Byte[] { 69, 70, 32, 82, 79, 67, 75, 83 }, ((IProperty)property).SqlServer().DefaultValue);
}
public void Can_add_multiple_indexes()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity<Customer>(b =>
{
b.Index(ix => ix.Id).IsUnique();
b.Index(ix => ix.Name).Annotation("A1", "V1");
});
var entityType = (IEntityType)model.GetEntityType(typeof(Customer));
Assert.Equal(2, entityType.GetIndexes().Count());
Assert.True(entityType.GetIndexes().First().IsUnique);
Assert.False(entityType.GetIndexes().Last().IsUnique);
Assert.Equal("V1", entityType.GetIndexes().Last()["A1"]);
}
public void Can_get_and_set_column_default_expression()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Name)
.Metadata;
Assert.Null(property.Relational().DefaultExpression);
Assert.Null(((IProperty)property).Relational().DefaultExpression);
Assert.Null(property.SqlServer().DefaultExpression);
Assert.Null(((IProperty)property).SqlServer().DefaultExpression);
property.Relational().DefaultExpression = "newsequentialid()";
Assert.Equal("newsequentialid()", property.Relational().DefaultExpression);
Assert.Equal("newsequentialid()", ((IProperty)property).Relational().DefaultExpression);
Assert.Equal("newsequentialid()", property.SqlServer().DefaultExpression);
Assert.Equal("newsequentialid()", ((IProperty)property).SqlServer().DefaultExpression);
property.SqlServer().DefaultExpression = "expressyourself()";
Assert.Equal("newsequentialid()", property.Relational().DefaultExpression);
Assert.Equal("newsequentialid()", ((IProperty)property).Relational().DefaultExpression);
Assert.Equal("expressyourself()", property.SqlServer().DefaultExpression);
Assert.Equal("expressyourself()", ((IProperty)property).SqlServer().DefaultExpression);
property.SqlServer().DefaultExpression = null;
Assert.Equal("newsequentialid()", property.Relational().DefaultExpression);
Assert.Equal("newsequentialid()", ((IProperty)property).Relational().DefaultExpression);
Assert.Equal("newsequentialid()", property.SqlServer().DefaultExpression);
Assert.Equal("newsequentialid()", ((IProperty)property).SqlServer().DefaultExpression);
}
public void Process_with_consecutive_alter_column_operations()
{
var sourceModel = new Model();
var sourceModelBuilder = new BasicModelBuilder(sourceModel);
sourceModelBuilder.Entity("A", b =>
{
b.Property <string>("Id");
b.Key("Id");
b.Index("Id").ForSqlServer().Clustered(false);
});
sourceModelBuilder.Entity("B", b =>
{
b.Property <string>("Id");
b.Key("Id");
b.ForeignKey("A", "Id");
b.Index("Id").ForSqlServer().Clustered(false);
});
sourceModelBuilder.Entity("A", b => b.ForeignKey("B", "Id"));
var inOperations = new MigrationOperationCollection();
var alterColumnOperation0
= new AlterColumnOperation(
"B",
new Column("Id", typeof(int))
{
IsNullable = false
},
isDestructiveChange: false);
var alterColumnOperation1
= new AlterColumnOperation(
"A",
new Column("Id", typeof(int))
{
IsNullable = false
},
isDestructiveChange: false);
inOperations.Add(alterColumnOperation0);
inOperations.Add(alterColumnOperation1);
var operations = Process(inOperations, sourceModel);
Assert.Equal(14, operations.Count);
Assert.IsType <DropIndexOperation>(operations[0]);
Assert.IsType <DropIndexOperation>(operations[1]);
Assert.IsType <DropForeignKeyOperation>(operations[2]);
Assert.IsType <DropForeignKeyOperation>(operations[3]);
Assert.IsType <DropPrimaryKeyOperation>(operations[4]);
Assert.IsType <DropPrimaryKeyOperation>(operations[5]);
Assert.Same(alterColumnOperation0, operations[6]);
Assert.Same(alterColumnOperation1, operations[7]);
Assert.IsType <AddPrimaryKeyOperation>(operations[8]);
Assert.IsType <AddPrimaryKeyOperation>(operations[9]);
Assert.IsType <AddForeignKeyOperation>(operations[10]);
Assert.IsType <AddForeignKeyOperation>(operations[11]);
Assert.IsType <CreateIndexOperation>(operations[12]);
Assert.IsType <CreateIndexOperation>(operations[13]);
var dropIndexOperation0 = (DropIndexOperation)operations[0];
var dropIndexOperation1 = (DropIndexOperation)operations[1];
var dropForeignKeyOperation0 = (DropForeignKeyOperation)operations[2];
var dropForeignKeyOperation1 = (DropForeignKeyOperation)operations[3];
var dropPrimaryKeyOperation0 = (DropPrimaryKeyOperation)operations[4];
var dropPrimaryKeyOperation1 = (DropPrimaryKeyOperation)operations[5];
var addPrimaryKeyOperation0 = (AddPrimaryKeyOperation)operations[8];
var addPrimaryKeyOperation1 = (AddPrimaryKeyOperation)operations[9];
var addForeignKeyOperation0 = (AddForeignKeyOperation)operations[10];
var addForeignKeyOperation1 = (AddForeignKeyOperation)operations[11];
var createIndexOperation0 = (CreateIndexOperation)operations[12];
var createIndexOperation1 = (CreateIndexOperation)operations[13];
Assert.Equal("IX_B_Id", dropIndexOperation0.IndexName);
Assert.Equal("IX_A_Id", dropIndexOperation1.IndexName);
Assert.Equal("FK_B_A_Id", dropForeignKeyOperation0.ForeignKeyName);
Assert.Equal("FK_A_B_Id", dropForeignKeyOperation1.ForeignKeyName);
Assert.Equal("PK_B", dropPrimaryKeyOperation0.PrimaryKeyName);
Assert.Equal("PK_A", dropPrimaryKeyOperation1.PrimaryKeyName);
Assert.Equal("PK_B", addPrimaryKeyOperation0.PrimaryKeyName);
Assert.Equal(new[] { "Id" }, addPrimaryKeyOperation0.ColumnNames.AsEnumerable());
Assert.Equal("PK_A", addPrimaryKeyOperation1.PrimaryKeyName);
Assert.Equal(new[] { "Id" }, addPrimaryKeyOperation1.ColumnNames.AsEnumerable());
Assert.Equal("FK_B_A_Id", addForeignKeyOperation0.ForeignKeyName);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation0.ColumnNames.AsEnumerable());
Assert.Equal(new[] { "Id" }, addForeignKeyOperation0.ReferencedColumnNames.AsEnumerable());
Assert.Equal("FK_A_B_Id", addForeignKeyOperation1.ForeignKeyName);
Assert.Equal(new[] { "Id" }, addForeignKeyOperation1.ColumnNames.AsEnumerable());
Assert.Equal(new[] { "Id" }, addForeignKeyOperation1.ReferencedColumnNames.AsEnumerable());
Assert.Equal("IX_B_Id", createIndexOperation0.IndexName);
Assert.Equal(new[] { "Id" }, createIndexOperation0.ColumnNames.AsEnumerable());
Assert.Equal("IX_A_Id", createIndexOperation1.IndexName);
Assert.Equal(new[] { "Id" }, createIndexOperation1.ColumnNames.AsEnumerable());
}
private static IModel CreateCyclicFKModel()
{
var model = new Entity.Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity<FakeEntity>(b =>
{
b.Key(c => c.Id);
b.Property(c => c.Value);
});
modelBuilder.Entity<RelatedFakeEntity>(b =>
{
b.Key(c => c.Id);
b.ForeignKey<FakeEntity>(c => c.RelatedId);
});
modelBuilder
.Entity<FakeEntity>()
.ForeignKey<RelatedFakeEntity>(c => c.RelatedId);
return model;
}
public void Can_get_and_set_sequence_name_on_property()
{
var modelBuilder = new BasicModelBuilder();
var property = modelBuilder
.Entity<Customer>()
.Property(e => e.Id)
.Metadata;
Assert.Null(property.SqlServer().SequenceName);
Assert.Null(((IProperty)property).SqlServer().SequenceName);
property.SqlServer().SequenceName = "Snook";
Assert.Equal("Snook", property.SqlServer().SequenceName);
Assert.Equal("Snook", ((IProperty)property).SqlServer().SequenceName);
property.SqlServer().SequenceName = null;
Assert.Null(property.SqlServer().SequenceName);
Assert.Null(((IProperty)property).SqlServer().SequenceName);
}
public void Can_get_and_set_index_name()
{
var modelBuilder = new BasicModelBuilder();
var index = modelBuilder
.Entity<Customer>()
.Index(e => e.Id)
.Metadata;
Assert.Null(index.Relational().Name);
Assert.Null(((IIndex)index).Relational().Name);
Assert.Null(index.SqlServer().Name);
Assert.Null(((IIndex)index).SqlServer().Name);
index.Relational().Name = "MyIndex";
Assert.Equal("MyIndex", index.Relational().Name);
Assert.Equal("MyIndex", ((IIndex)index).Relational().Name);
Assert.Equal("MyIndex", index.SqlServer().Name);
Assert.Equal("MyIndex", ((IIndex)index).SqlServer().Name);
index.SqlServer().Name = "DexKnows";
Assert.Equal("MyIndex", index.Relational().Name);
Assert.Equal("MyIndex", ((IIndex)index).Relational().Name);
Assert.Equal("DexKnows", index.SqlServer().Name);
Assert.Equal("DexKnows", ((IIndex)index).SqlServer().Name);
index.SqlServer().Name = null;
Assert.Equal("MyIndex", index.Relational().Name);
Assert.Equal("MyIndex", ((IIndex)index).Relational().Name);
Assert.Equal("MyIndex", index.SqlServer().Name);
Assert.Equal("MyIndex", ((IIndex)index).SqlServer().Name);
}
