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); }