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;
}
public void Properties_specified_by_string_are_shadow_properties_unless_already_defined_as_CLR_properties()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder.Entity <Quarks>(b =>
{
b.Property(e => e.Up);
b.Property <int>("Charm");
b.Property(typeof(int), "Top");
b.Property <int>("Up");
b.Property <string>("Gluon");
b.Property(typeof(string), "Photon");
});
var entityType = model.GetEntityType(typeof(Quarks));
Assert.False(entityType.GetProperty("Up").IsShadowProperty);
Assert.True(entityType.GetProperty("Charm").IsShadowProperty);
Assert.True(entityType.GetProperty("Top").IsShadowProperty);
Assert.True(entityType.GetProperty("Gluon").IsShadowProperty);
Assert.True(entityType.GetProperty("Photon").IsShadowProperty);
Assert.Equal(-1, entityType.GetProperty("Up").ShadowIndex);
Assert.Equal(0, entityType.GetProperty("Charm").ShadowIndex);
Assert.Equal(3, entityType.GetProperty("Top").ShadowIndex);
Assert.Equal(1, entityType.GetProperty("Gluon").ShadowIndex);
Assert.Equal(2, entityType.GetProperty("Photon").ShadowIndex);
}
public void Generate_entity_type_with_shadow_property()
{
var builder = new BasicModelBuilder();
builder.Entity <Customer>(b =>
{
b.Property <int>("Id");
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"");
b.Key(""Id"");
});
return builder.Model;",
stringBuilder.ToString());
GenerateAndValidateCode(builder.Model);
}
public void Generate_outputs_property_value_generation_settings()
{
var builder = new BasicModelBuilder();
builder.Entity <Customer>(b =>
{
b.Key(e => e.Id);
b.Property(e => e.Id).GenerateValuesOnAdd();
});
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"")
.GenerateValuesOnAdd();
b.Key(""Id"");
});
return builder.Model;",
stringBuilder.ToString());
}
public void Generate_entity_type_with_composite_key()
{
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 })
.Annotation("A1", "V1")
.Annotation("A2", "V2");
});
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"")
.Annotation(""A1"", ""V1"")
.Annotation(""A2"", ""V2"");
});
return builder.Model;",
stringBuilder.ToString());
GenerateAndValidateCode(builder.Model);
}
protected override void OnModelCreating(BasicModelBuilder modelBuilder)
{
modelBuilder.Entity <MappingQueryTestBase.MappedCustomer>(e =>
{
e.Property(c => c.CompanyName2).ForSqlServer(c => c.Column("CompanyName"));
e.ForSqlServer(t => t.Table("Customers", "dbo"));
});
}
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";
});
}
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";
});
}
private IModel CreateModel()
{
var model = new Model();
var builder = new BasicModelBuilder(model);
builder.Entity <Customer>().Property(s => s.CustomerID);
return(model);
}
public void Visit_with_unsupported_table_subordinate_operation()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("T1",
b =>
{
b.Property <int>("Id");
b.Key("Id");
});
modelBuilder.Entity("T2",
b =>
{
b.Property <int>("Id");
b.Property <int>("C");
b.Key("Id");
});
var addForeignKeyOperation
= new AddForeignKeyOperation("T2", "FK", new[] { "C" }, "T1", new[] { "Id" }, cascadeDelete: true);
var operations = PreProcess(modelBuilder, addForeignKeyOperation);
Assert.Equal(4, operations.Count);
Assert.IsType <RenameTableOperation>(operations[0]);
Assert.IsType <CreateTableOperation>(operations[1]);
Assert.IsType <CopyDataOperation>(operations[2]);
Assert.IsType <DropTableOperation>(operations[3]);
var renameTableOperation = (RenameTableOperation)operations[0];
Assert.Equal("T2", renameTableOperation.TableName);
Assert.Equal("__mig_tmp__T2", renameTableOperation.NewTableName);
var createTableOperation = (CreateTableOperation)operations[1];
Assert.Equal("T2", createTableOperation.Table.Name);
Assert.Equal(new[] { "Id", "C" }, createTableOperation.Table.Columns.Select(c => c.Name));
Assert.Equal(new[] { typeof(int), 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));
var copyDataOperation = (CopyDataOperation)operations[2];
Assert.Equal("__mig_tmp__T2", copyDataOperation.SourceTableName);
Assert.Equal(new[] { "Id", "C" }, copyDataOperation.SourceColumnNames);
Assert.Equal("T2", copyDataOperation.TargetTableName);
Assert.Equal(new[] { "Id", "C" }, copyDataOperation.TargetColumnNames);
var dropTableOperation = (DropTableOperation)operations[3];
Assert.Equal("__mig_tmp__T2", dropTableOperation.TableName);
}
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_table_name_with_dot()
{
var model = new Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity <Customer>().ToTable("my.table");
Assert.Equal("my.table", model.GetEntityType(typeof(Customer)).TableName());
}
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);
}
private static Property CreateDefaultValueGenProperty <T>()
{
var property = new BasicModelBuilder()
.Entity <Robot>()
.Property <T>(typeof(T).Name)
.GenerateValuesOnAdd()
.Metadata;
return(property);
}
private static Property CreateIdentityProperty <T>()
{
var property = new BasicModelBuilder()
.Entity <Robot>()
.Property <T>(typeof(T).Name)
.ForSqlServer(b => b.UseIdentity())
.Metadata;
return(property);
}
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.TryGetEntityType(typeof(Customer).FullName));
}
private static Property CreateModelSequenceProperty <T>()
{
var property = new BasicModelBuilder()
.ForSqlServer(b => b.UseSequence())
.Entity <Robot>()
.Property <T>(typeof(T).Name)
.GenerateValuesOnAdd()
.Metadata;
return(property);
}
public void Visit_with_rename_operation_followed_by_unsupported_subordinate_operation()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder.Entity("T1",
b =>
{
b.Property <int>("Id");
b.Key("Id");
});
modelBuilder.Entity("T2",
b =>
{
b.Property <int>("Id");
b.Property <int>("C");
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 addForeignKeyOperation
= new AddForeignKeyOperation("dbo2.T2", "FK", new[] { "C" }, "T1", new[] { "Id" }, cascadeDelete: true);
var operations = PreProcess(modelBuilder, moveTableOperation, renameTableOperation, addForeignKeyOperation);
Assert.Equal(3, operations.Count);
Assert.IsType <CreateTableOperation>(operations[0]);
Assert.IsType <CopyDataOperation>(operations[1]);
Assert.IsType <DropTableOperation>(operations[2]);
var createTableOperation = (CreateTableOperation)operations[0];
Assert.Equal("dbo2.T2", createTableOperation.Table.Name);
Assert.Equal(new[] { "Id", "C" }, createTableOperation.Table.Columns.Select(c => c.Name));
Assert.Equal(new[] { typeof(int), 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));
var copyDataOperation = (CopyDataOperation)operations[1];
Assert.Equal("dbo.T", copyDataOperation.SourceTableName);
Assert.Equal(new[] { "Id", "C" }, copyDataOperation.SourceColumnNames);
Assert.Equal("dbo2.T2", copyDataOperation.TargetTableName);
Assert.Equal(new[] { "Id", "C" }, copyDataOperation.TargetColumnNames);
var dropTableOperation = (DropTableOperation)operations[2];
Assert.Equal("dbo.T", dropTableOperation.TableName);
}
public void Can_set_entity_table_name_when_no_clr_type()
{
var model = new Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity(typeof(Customer).FullName)
.ToTable("foo");
Assert.Equal("foo", model.GetEntityType(typeof(Customer)).TableName());
}
public void Property_column_name_defaults_to_name()
{
var model = new Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity(typeof(Customer).FullName)
.Property <string>("Name");
Assert.Equal("Name", model.GetEntityType(typeof(Customer)).GetProperty("Name").ColumnName());
}
public void Can_create_default_sequence_with_basic_builder_using_nested_closure()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder
.ForRelational(b => { b.Sequence(); });
var sequence = modelBuilder.Model.Relational().TryGetSequence(Sequence.DefaultName);
ValidateDefaultSequence(sequence);
}
public void Can_set_property_annotation()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Property(c => c.Name).Annotation("foo", "bar");
Assert.Equal("bar", model.GetEntityType(typeof(Customer)).GetProperty("Name")["foo"]);
}
public void Can_set_property_column_name_when_no_clr_property()
{
var model = new Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Property <string>("Name").ColumnName("foo");
Assert.Equal("foo", model.GetEntityType(typeof(Customer)).GetProperty("Name").ColumnName());
}
public void Can_create_schema_named_sequence_with_basic_builder_using_nested_closure()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder
.ForRelational(b => { b.Sequence("Snook", "Tasty"); });
var sequence = modelBuilder.Model.Relational().TryGetSequence("Snook", "Tasty");
ValidateSchemaNamedSequence(sequence);
}
public void Can_set_property_annotation_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity(typeof(Customer).FullName)
.Property <string>("Name").Annotation("foo", "bar");
Assert.Equal("bar", model.GetEntityType(typeof(Customer)).GetProperty("Name")["foo"]);
}
public void Can_set_entity_table_name_and_schema()
{
var model = new Metadata.Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity <Customer>().ToTable("foo", "schema");
Assert.Equal("foo", model.GetEntityType(typeof(Customer)).TableName());
Assert.Equal("schema", model.GetEntityType(typeof(Customer)).Schema());
}
public void Can_create_named_sequence_with_basic_builder()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder
.ForRelational()
.Sequence("Snook");
var sequence = modelBuilder.Model.Relational().TryGetSequence("Snook");
ValidateNamedSequence(sequence);
}
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()
{
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 Throws_if_existing_property_is_not_DateTimeOffset()
{
var modelBuilder = new BasicModelBuilder();
Assert.Equal(
Strings.FormatBadTimestampType("Name", "Customer", "String"),
Assert.Throws <InvalidOperationException>(
() => modelBuilder
.Entity <Customer>()
.ForAzureTableStorage()
.Timestamp(e => e.Name)).Message);
}
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_add_index()
{
var model = new Model();
var modelBuilder = new BasicModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Index(ix => ix.Name);
var entityType = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entityType.Indexes.Count());
}
public void Can_set_table_name_with_basic_builder_using_nested_closure_non_generic()
{
var modelBuilder = new BasicModelBuilder();
modelBuilder
.Entity(typeof(Customer))
.ForAzureTableStorage(b => b.Table("Customizer"));
var entityType = modelBuilder.Model.GetEntityType(typeof(Customer));
Assert.Equal("Customer", entityType.SimpleName);
Assert.Equal("Customizer", entityType.AzureTableStorage().Table);
}
public void Can_add_multiple_properties_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").Annotation("foo", "bar");
});
Assert.Equal(2, model.GetEntityType(typeof(Customer)).Properties.Count());
}
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 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_value_generation_on_model()
{
var modelBuilder = new BasicModelBuilder();
var model = modelBuilder.Metadata;
Assert.Null(model.SqlServer().ValueGenerationStrategy);
Assert.Null(((IModel)model).SqlServer().ValueGenerationStrategy);
model.SqlServer().ValueGenerationStrategy = SqlServerValueGenerationStrategy.Sequence;
Assert.Equal(SqlServerValueGenerationStrategy.Sequence, model.SqlServer().ValueGenerationStrategy);
Assert.Equal(SqlServerValueGenerationStrategy.Sequence, ((IModel)model).SqlServer().ValueGenerationStrategy);
model.SqlServer().ValueGenerationStrategy = null;
Assert.Null(model.SqlServer().ValueGenerationStrategy);
Assert.Null(((IModel)model).SqlServer().ValueGenerationStrategy);
}
public void Can_get_and_set_default_sequence_schema_on_model()
{
var modelBuilder = new BasicModelBuilder();
var model = modelBuilder.Metadata;
Assert.Null(model.SqlServer().DefaultSequenceSchema);
Assert.Null(((IModel)model).SqlServer().DefaultSequenceSchema);
model.SqlServer().DefaultSequenceSchema = "Tasty.Snook";
Assert.Equal("Tasty.Snook", model.SqlServer().DefaultSequenceSchema);
Assert.Equal("Tasty.Snook", ((IModel)model).SqlServer().DefaultSequenceSchema);
model.SqlServer().DefaultSequenceSchema = null;
Assert.Null(model.SqlServer().DefaultSequenceSchema);
Assert.Null(((IModel)model).SqlServer().DefaultSequenceSchema);
}
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_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);
}
protected virtual void OnModelCreating(BasicModelBuilder modelBuilder)
{
}
public void Can_get_multiple_sequences_when_overridden()
{
var modelBuilder = new BasicModelBuilder();
var model = modelBuilder.Metadata;
model.Relational().AddOrReplaceSequence(new Sequence("Fibonacci", startValue: 1));
model.SqlServer().AddOrReplaceSequence(new Sequence("Fibonacci", startValue: 3));
model.SqlServer().AddOrReplaceSequence(new Sequence("Golomb"));
var sequences = model.SqlServer().Sequences;
Assert.Equal(2, sequences.Count);
Assert.Contains(sequences, s => s.Name == "Golomb");
var sequence = sequences.FirstOrDefault(s => s.Name == "Fibonacci");
Assert.NotNull(sequence);
Assert.Equal(3, sequence.StartValue);
}
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_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_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);
}
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;
}
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_add_and_replace_sequence_with_schema_name()
{
var modelBuilder = new BasicModelBuilder();
var model = modelBuilder.Metadata;
model.SqlServer().AddOrReplaceSequence(new Sequence("Foo", "Smoo"));
Assert.Null(model.Relational().TryGetSequence("Foo", "Smoo"));
Assert.Null(((IModel)model).Relational().TryGetSequence("Foo", "Smoo"));
Assert.Equal("Foo", model.SqlServer().TryGetSequence("Foo", "Smoo").Name);
Assert.Equal("Foo", ((IModel)model).SqlServer().TryGetSequence("Foo", "Smoo").Name);
var sequence = model.SqlServer().TryGetSequence("Foo", "Smoo");
Assert.Equal("Foo", sequence.Name);
Assert.Equal("Smoo", sequence.Schema);
Assert.Equal(10, sequence.IncrementBy);
Assert.Equal(1, sequence.StartValue);
Assert.Null(sequence.MinValue);
Assert.Null(sequence.MaxValue);
Assert.Same(typeof(long), sequence.Type);
model.SqlServer().AddOrReplaceSequence(new Sequence("Foo", "Smoo", 1729, 11, 2001, 2010, typeof(int)));
Assert.Null(model.Relational().TryGetSequence("Foo", "Smoo"));
sequence = model.SqlServer().TryGetSequence("Foo", "Smoo");
Assert.Equal("Foo", sequence.Name);
Assert.Equal("Smoo", sequence.Schema);
Assert.Equal(11, sequence.IncrementBy);
Assert.Equal(1729, sequence.StartValue);
Assert.Equal(2001, sequence.MinValue);
Assert.Equal(2010, sequence.MaxValue);
Assert.Same(typeof(int), sequence.Type);
}
private static IModel BuildModel()
{
var model = new Model();
var builder = new BasicModelBuilder(model);
builder.Annotation("ModelAnnotation1", "ModelValue1");
builder.Annotation("ModelAnnotation2", "ModelValue2");
var entityType1 = model.AddEntityType(typeof(KoolEntity1));
var property = entityType1.GetOrAddProperty("Id1", typeof(int));
entityType1.GetOrSetPrimaryKey(property);
entityType1.GetOrAddProperty("Id2", typeof(Guid));
entityType1.GetOrAddProperty("KoolEntity2Id", typeof(int));
var entityType2 = model.AddEntityType(typeof(KoolEntity2));
entityType2.GetOrAddProperty("KoolEntity1Id1", typeof(int));
entityType2.GetOrAddProperty("KoolEntity1Id2", typeof(Guid));
entityType2.GetOrAddProperty("KoolEntity3Id", typeof(int));
var entityType3 = model.AddEntityType(typeof(KoolEntity3));
entityType3.GetOrAddProperty("KoolEntity4Id", typeof(int));
var entityType4 = model.AddEntityType(typeof(KoolEntity4));
var entityType5 = model.AddEntityType(typeof(KoolEntity5));
var entityType6 = model.AddEntityType(typeof(KoolEntity6));
entityType6.GetOrAddProperty("Kool5Id", typeof(int));
for (var i = 7; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
Assert.NotNull(type);
model.AddEntityType(type);
}
for (var i = 2; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
var entityType = model.GetEntityType(type);
var id = entityType.GetOrAddProperty(entityType.ClrType.GetProperty("Id"));
entityType.GetOrSetPrimaryKey(id);
}
for (var i = 1; i <= 20; i++)
{
var type = Type.GetType("Microsoft.Data.Entity.FunctionalTests.Metadata.KoolEntity" + i);
var entityType = model.GetEntityType(type);
entityType["Annotation1"] = "Value1";
entityType["Annotation2"] = "Value2";
var foo = entityType.GetOrAddProperty(entityType.ClrType.GetProperty("Foo" + i));
foo["Foo" + i + "Annotation1"] = "Foo" + i + "Value1";
foo["Foo" + i + "Annotation2"] = "Foo" + i + "Value2";
var goo = entityType.GetOrAddProperty(entityType.ClrType.GetProperty("Goo" + i));
}
var fk11 = entityType1.GetOrAddForeignKey(new[] { entityType1.GetProperty("KoolEntity2Id") }, entityType2.GetPrimaryKey());
var fk21 = entityType2.GetOrAddForeignKey(new[] { entityType2.GetProperty("KoolEntity1Id1") }, entityType1.GetPrimaryKey());
var fk22 = entityType2.GetOrAddForeignKey(new[] { entityType2.GetProperty("KoolEntity3Id") }, entityType3.GetPrimaryKey());
var fk31 = entityType3.GetOrAddForeignKey(new[] { entityType3.GetProperty("KoolEntity4Id") }, entityType4.GetPrimaryKey());
var fk61 = entityType6.GetOrAddForeignKey(new[] { entityType6.GetProperty("Kool5Id") }, entityType5.GetPrimaryKey());
entityType1.AddNavigation("NavTo2", fk11, pointsToPrincipal: true);
entityType1.AddNavigation("NavTo2s", fk21, pointsToPrincipal: false);
entityType2.AddNavigation("NavTo1", fk21, pointsToPrincipal: true);
entityType2.AddNavigation("NavTo1s", fk11, pointsToPrincipal: false);
entityType2.AddNavigation("NavTo3", fk22, pointsToPrincipal: true);
entityType3.AddNavigation("NavTo2s", fk22, pointsToPrincipal: false);
entityType3.AddNavigation("NavTo4", fk31, pointsToPrincipal: true);
entityType4.AddNavigation("NavTo3s", fk31, pointsToPrincipal: false);
entityType5.AddNavigation("Kool6s", fk61, pointsToPrincipal: false);
entityType6.AddNavigation("Kool5", fk61, 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 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);
}
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 Can_get_multiple_sequences()
{
var modelBuilder = new BasicModelBuilder();
var model = modelBuilder.Metadata;
model.Relational().AddOrReplaceSequence(new Sequence("Fibonacci"));
model.SqlServer().AddOrReplaceSequence(new Sequence("Golomb"));
var sequences = model.SqlServer().Sequences;
Assert.Equal(2, sequences.Count);
Assert.Contains(sequences, s => s.Name == "Fibonacci");
Assert.Contains(sequences, s => s.Name == "Golomb");
}
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 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 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);
}
