public virtual void Finds_existing_navigation_to_principal_and_uses_associated_FK()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Customer>();
modelBuilder
.Entity<Order>().HasOne(o => o.Customer).WithMany()
.ForeignKey(c => c.CustomerId);
modelBuilder.Ignore<OrderDetails>();
modelBuilder.Ignore<CustomerDetails>();
var dependentType = model.GetEntityType(typeof(Order));
var principalType = model.GetEntityType(typeof(Customer));
var principalKey = principalType.GetKeys().Single();
var dependentKey = dependentType.GetKeys().Single();
modelBuilder.Entity<Order>().HasOne(e => e.Customer).WithMany(e => e.Orders);
var newFk = dependentType.Navigations.Single().ForeignKey;
Assert.Equal(nameof(Order.CustomerId), newFk.Properties.Single().Name);
Assert.Same(newFk, principalType.Navigations.Single().ForeignKey);
Assert.Empty(principalType.GetForeignKeys());
Assert.Same(principalKey, principalType.GetKeys().Single());
Assert.Same(dependentKey, dependentType.GetKeys().Single());
Assert.Same(principalKey, principalType.GetPrimaryKey());
Assert.Same(dependentKey, dependentType.GetPrimaryKey());
}
public virtual void Replaces_existing_navigation_to_principal()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<CustomerDetails>().Reference(c => c.Customer).InverseReference();
modelBuilder.Ignore<Order>();
var dependentType = model.GetEntityType(typeof(CustomerDetails));
var principalType = model.GetEntityType(typeof(Customer));
var expectedPrincipalProperties = principalType.Properties.ToList();
var expectedDependentProperties = dependentType.Properties.ToList();
var principalKey = principalType.GetKeys().Single();
var dependentKey = dependentType.GetKeys().Single();
modelBuilder.Entity<Customer>().Reference(e => e.Details).InverseReference(e => e.Customer);
var fk = dependentType.GetForeignKeys().Single();
Assert.Same(fk.DependentToPrincipal, dependentType.Navigations.Single());
Assert.Same(fk.PrincipalToDependent, principalType.Navigations.Single());
AssertEqual(expectedPrincipalProperties, principalType.Properties);
AssertEqual(expectedDependentProperties, dependentType.Properties);
Assert.Empty(principalType.GetForeignKeys());
Assert.Same(principalKey, principalType.GetKeys().Single());
Assert.Same(dependentKey, dependentType.GetKeys().Single());
Assert.Same(principalKey, principalType.GetPrimaryKey());
Assert.Same(dependentKey, dependentType.GetPrimaryKey());
}
public void OneToMany_finds_existing_nav_to_principal_and_uses_associated_FK()
{
var model = new Model();
var modelBuilder = new ModelBuilder(new ConventionSet(), model);
modelBuilder.Entity<Customer>().Key(c => c.Id);
modelBuilder.Entity<Order>().Metadata.AddForeignKey(
model.GetEntityType(typeof(Order)).GetProperty("CustomerId"),
model.GetEntityType(typeof(Customer)).GetPrimaryKey());
var dependentType = model.GetEntityType(typeof(Order));
var principalType = model.GetEntityType(typeof(Customer));
var fk = dependentType.GetForeignKeys().Single();
var navigation = dependentType.AddNavigation("Customer", fk, true);
var principalPropertyCount = principalType.PropertyCount;
var dependentPropertyCount = dependentType.PropertyCount;
var principalKey = principalType.GetKeys().Single();
var dependentKey = dependentType.GetKeys().Single();
modelBuilder.Entity(typeof(Customer)).Collection(typeof(Order), "Orders").InverseReference("Customer");
Assert.Same(fk, dependentType.GetForeignKeys().Single());
Assert.Same(navigation, dependentType.Navigations.Single());
Assert.Equal("Orders", principalType.Navigations.Single().Name);
Assert.Same(fk, dependentType.Navigations.Single().ForeignKey);
Assert.Same(fk, principalType.Navigations.Single().ForeignKey);
Assert.Equal(principalPropertyCount, principalType.PropertyCount);
Assert.Equal(dependentPropertyCount, dependentType.PropertyCount);
Assert.Empty(principalType.GetForeignKeys());
Assert.Same(principalKey, principalType.GetKeys().Single());
Assert.Same(dependentKey, dependentType.GetKeys().Single());
Assert.Same(principalKey, principalType.GetPrimaryKey());
Assert.Same(dependentKey, dependentType.GetPrimaryKey());
}
public virtual void Finds_existing_navigation_to_principal_and_uses_associated_FK()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Customer>();
modelBuilder
.Entity<Order>().Reference(c => c.Customer).InverseCollection()
.ForeignKey(c => c.CustomerId);
modelBuilder.Ignore<OrderDetails>();
modelBuilder.Ignore<CustomerDetails>();
var dependentType = model.GetEntityType(typeof(Order));
var principalType = model.GetEntityType(typeof(Customer));
var fk = dependentType.GetForeignKeys().Single();
var navigation = dependentType.GetNavigation("Customer");
var principalKey = principalType.GetKeys().Single();
var dependentKey = dependentType.GetKeys().Single();
modelBuilder.Entity<Customer>().Collection(e => e.Orders).InverseReference(e => e.Customer);
Assert.Equal(1, dependentType.GetForeignKeys().Count());
Assert.Equal("Orders", principalType.Navigations.Single().Name);
Assert.Same(fk.PrincipalKey, principalType.Navigations.Single().ForeignKey.PrincipalKey);
AssertEqual(new[] { "AlternateKey", principalKey.Properties.Single().Name, Customer.NameProperty.Name }, principalType.Properties.Select(p => p.Name));
AssertEqual(new[] { "AnotherCustomerId", fk.Properties.Single().Name, dependentKey.Properties.Single().Name }, dependentType.Properties.Select(p => p.Name));
Assert.Empty(principalType.GetForeignKeys());
Assert.Same(principalKey, principalType.GetKeys().Single());
Assert.Same(dependentKey, dependentType.GetKeys().Single());
Assert.Same(principalKey, principalType.GetPrimaryKey());
Assert.Same(dependentKey, dependentType.GetPrimaryKey());
}
public virtual void Finds_existing_navigations_and_uses_associated_FK()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Customer>();
modelBuilder
.Entity<CustomerDetails>().HasOne(d => d.Customer).WithOne(c => c.Details)
.ForeignKey<CustomerDetails>(c => c.Id);
modelBuilder.Ignore<Order>();
var dependentType = model.GetEntityType(typeof(CustomerDetails));
var principalType = model.GetEntityType(typeof(Customer));
var fk = dependentType.GetForeignKeys().Single();
var navToPrincipal = dependentType.GetNavigation(nameof(CustomerDetails.Customer));
var navToDependent = principalType.GetNavigation(nameof(Customer.Details));
var principalKey = principalType.GetKeys().Single();
var dependentKey = dependentType.GetKeys().Single();
modelBuilder.Entity<Customer>().HasOne(e => e.Details).WithOne(e => e.Customer);
Assert.Equal(1, dependentType.GetForeignKeys().Count());
Assert.Same(navToPrincipal, dependentType.Navigations.Single());
Assert.Same(navToDependent, principalType.Navigations.Single());
Assert.Same(fk.PrincipalKey, principalType.Navigations.Single().ForeignKey.PrincipalKey);
AssertEqual(new[] { "AlternateKey", principalKey.Properties.Single().Name, Customer.NameProperty.Name }, principalType.Properties.Select(p => p.Name));
AssertEqual(new[] { dependentKey.Properties.Single().Name }, dependentType.Properties.Select(p => p.Name));
Assert.Empty(principalType.GetForeignKeys());
Assert.Same(principalKey, principalType.GetKeys().Single());
Assert.Same(dependentKey, dependentType.GetKeys().Single());
Assert.Same(principalKey, principalType.GetPrimaryKey());
Assert.Same(dependentKey, dependentType.GetPrimaryKey());
}
private static void AddNavigationToPrincipal(Microsoft.Data.Entity.Metadata.Model model, Type type, string fk, string navigation)
{
model.GetEntityType(type)
.AddNavigation(
navigation,
model.GetEntityType(type).ForeignKeys.Single(
f => f.Properties.Count == 1 && f.Properties.Single().Name == fk),
pointsToPrincipal: true);
}
public virtual void NotMappedAttribute_removes_ambiguity_in_conventional_relationship_building()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Book>();
Assert.Contains("Details", model.GetEntityType(typeof(Book)).Navigations.Select(nav => nav.Name));
Assert.Contains("AnotherBook", model.GetEntityType(typeof(BookDetails)).Navigations.Select(nav => nav.Name));
Assert.DoesNotContain("Book", model.GetEntityType(typeof(BookDetails)).Navigations.Select(nav => nav.Name));
}
private static void AddNavigationToDependent(Microsoft.Data.Entity.Metadata.Model model, Type type, Type dependentType, string fk1, string fk2, string navigation)
{
model.GetEntityType(type)
.AddNavigation(
navigation,
model.GetEntityType(dependentType).ForeignKeys.Single(
f => f.Properties.Count == 2 &&
f.Properties.Any(p => p.Name == fk1) &&
f.Properties.Any(p => p.Name == fk2)),
pointsToPrincipal: false);
}
public virtual void InversePropertyAttribute_removes_ambiguity_in_conventional_relationalship_building()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Book>();
Assert.Contains("Book", model.GetEntityType(typeof(BookLabel)).Navigations.Select(nav => nav.Name));
Assert.Equal("Label", model.GetEntityType(typeof(BookLabel)).FindNavigation("Book").ForeignKey.PrincipalToDependent.Name);
Assert.Contains("AlternateLabel", model.GetEntityType(typeof(Book)).Navigations.Select(nav => nav.Name));
Assert.Null(model.GetEntityType(typeof(Book)).FindNavigation("AlternateLabel").ForeignKey.PrincipalToDependent);
}
public virtual void ForeignKeyAttribute_creates_two_relationships_if_applied_on_property_on_both_side()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Post>();
Assert.Null(model.GetEntityType(typeof(Post)).FindNavigation("Author").ForeignKey.PrincipalToDependent);
Assert.Equal("AuthorCode", model.GetEntityType(typeof(Post)).FindNavigation("Author").ForeignKey.Properties.First().Name);
Assert.Null(model.GetEntityType(typeof(Author)).FindNavigation("Post").ForeignKey.PrincipalToDependent);
Assert.Equal("PostNumber", model.GetEntityType(typeof(Author)).FindNavigation("Post").ForeignKey.Properties.First().Name);
}
public void Can_get_entity_by_type()
{
var model = new Model();
var entityType = new EntityType(typeof(Customer));
model.AddEntityType(entityType);
Assert.Same(entityType, model.GetEntityType(typeof(Customer)));
Assert.Same(entityType, model.TryGetEntityType(typeof(Customer)));
Assert.Null(model.TryGetEntityType(typeof(string)));
Assert.Equal(
Strings.FormatEntityTypeNotFound("String"),
Assert.Throws<ModelItemNotFoundException>(() => model.GetEntityType(typeof(string))).Message);
}
public virtual void ForeignKeyAttribute_does_not_set_foreign_key_properties_when_names_on_property_and_navigation_do_not_match()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Author>();
Assert.Equal("AuthorId", model.GetEntityType(typeof(AuthorDetails)).FindNavigation("Author").ForeignKey.Properties.First().Name);
}
public virtual void ForeignKeyAttribute_does_not_set_foreign_key_properties_when_applied_on_properties_for_composite_foreign_key()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<PostDetails>();
Assert.Equal("AuthorId", model.GetEntityType(typeof(PostDetails)).FindNavigation("Author").ForeignKey.Properties.First().Name);
}
public virtual void Can_get_entity_builder_for_clr_type()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
var entityBuilder = modelBuilder.Entity<Customer>();
Assert.NotNull(entityBuilder);
Assert.Equal(typeof(Customer).FullName, model.GetEntityType(typeof(Customer)).Name);
}
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 virtual void Can_set_entity_key_from_clr_property()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Customer>().HasKey(b => b.Id);
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entity.GetPrimaryKey().Properties.Count);
Assert.Equal(Customer.IdProperty.Name, entity.GetPrimaryKey().Properties.First().Name);
}
public void Can_set_entity_key_from_clr_property()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity<Customer>().Key(e => e.Id);
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entity.GetKey().Properties.Count());
Assert.Equal("Id", entity.GetKey().Properties.First().Name);
}
public void Can_set_composite_entity_key_from_clr_properties()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Key(e => new { e.Id, e.Name });
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entity.GetKey().Properties.Count());
Assert.Equal("Id", entity.GetKey().Properties.First().Name);
Assert.Equal("Name", entity.GetKey().Properties.Last().Name);
}
public virtual void Finds_existing_navigations_and_uses_associated_FK()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Customer>()
.HasMany(e => e.Orders).WithOne(e => e.Customer)
.ForeignKey(e => e.CustomerId);
modelBuilder.Entity<Order>();
modelBuilder.Ignore<OrderDetails>();
modelBuilder.Ignore<CustomerDetails>();
var dependentType = model.GetEntityType(typeof(Order));
var principalType = model.GetEntityType(typeof(Customer));
var fk = dependentType.GetForeignKeys().Single();
var navToPrincipal = dependentType.GetOrAddNavigation("Customer", fk, pointsToPrincipal: true);
var navToDependent = principalType.GetOrAddNavigation("Orders", fk, pointsToPrincipal: false);
var principalKey = principalType.GetKeys().Single();
var dependentKey = dependentType.GetKeys().Single();
modelBuilder.Entity<Order>().HasOne(e => e.Customer).WithMany(e => e.Orders);
Assert.Same(fk, dependentType.GetForeignKeys().Single());
Assert.Same(navToPrincipal, dependentType.Navigations.Single());
Assert.Same(navToDependent, principalType.Navigations.Single());
Assert.Same(fk, dependentType.Navigations.Single().ForeignKey);
Assert.Same(fk, principalType.Navigations.Single().ForeignKey);
AssertEqual(new[] { "AlternateKey", principalKey.Properties.Single().Name, Customer.NameProperty.Name }, principalType.Properties.Select(p => p.Name));
AssertEqual(new[] { "AnotherCustomerId", fk.Properties.Single().Name, dependentKey.Properties.Single().Name }, dependentType.Properties.Select(p => p.Name));
Assert.Empty(principalType.GetForeignKeys());
Assert.Same(principalKey, principalType.GetKeys().Single());
Assert.Same(dependentKey, dependentType.GetKeys().Single());
Assert.Same(principalKey, principalType.GetPrimaryKey());
Assert.Same(dependentKey, dependentType.GetPrimaryKey());
}
public virtual void Replaces_existing_navigation_to_principal()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<CustomerDetails>().HasOne(c => c.Customer).WithOne();
modelBuilder.Ignore<Order>();
var dependentType = model.GetEntityType(typeof(CustomerDetails));
var principalType = model.GetEntityType(typeof(Customer));
var principalKey = principalType.GetKeys().Single();
var dependentKey = dependentType.GetKeys().Single();
modelBuilder.Entity<Customer>().HasOne(e => e.Details).WithOne(e => e.Customer);
var fk = dependentType.GetForeignKeys().Single();
Assert.Empty(principalType.GetForeignKeys());
Assert.Same(fk.DependentToPrincipal, dependentType.Navigations.Single());
Assert.Same(fk.PrincipalToDependent, principalType.Navigations.Single());
Assert.Same(principalKey, principalType.GetKeys().Single());
Assert.Same(dependentKey, dependentType.GetKeys().Single());
Assert.Same(principalKey, principalType.GetPrimaryKey());
Assert.Same(dependentKey, dependentType.GetPrimaryKey());
}
public void Can_add_index_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity("Customer", b =>
{
b.Property <string>("Name");
b.Indexes(ixs => ixs.Index("Name"));
});
var entityType = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entityType.Indexes.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_set_entity_key_from_property_name_when_no_clr_property()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity<Customer>(b =>
{
b.Property<int>("Id");
b.Key("Id");
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entity.GetKey().Properties.Count());
Assert.Equal("Id", entity.GetKey().Properties.First().Name);
}
public void Can_set_use_of_store_sequence_with_name_and_block_size()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Property(c => c.Name).UseStoreSequence("UltrasonicTarsier", 17);
var property = model.GetEntityType(typeof(Customer)).GetProperty("Name");
Assert.Equal(ValueGenerationOnAdd.Server, property.ValueGenerationOnAdd);
Assert.Equal(ValueGenerationOnSave.None, property.ValueGenerationOnSave);
Assert.Equal("UltrasonicTarsier", property["StoreSequenceName"]);
Assert.Equal("17", property["StoreSequenceBlockSize"]);
}
public void Can_set_entity_key_from_property_name_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity("Customer", b =>
{
b.Property <int>("Id");
b.Key("Id");
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entity.GetKey().Properties.Count());
Assert.Equal("Id", entity.GetKey().Properties.First().Name);
}
public void Can_create_a_model_builder_with_given_conventions_and_model()
{
var convention = new TestConvention();
var conventions = new ConventionSet();
conventions.EntityTypeAddedConventions.Add(convention);
var model = new Model();
var modelBuilder = new ModelBuilder(conventions, model);
Assert.Same(model, modelBuilder.Model);
modelBuilder.Entity<Random>();
Assert.True(convention.Applied);
Assert.NotNull(model.GetEntityType(typeof(Random)));
}
public void Can_set_composite_entity_key_from_property_names_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity("Customer", ps =>
{
ps.Property <int>("Id");
ps.Property <string>("Name");
ps.Key("Id", "Name");
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entity.GetKey().Properties.Count());
Assert.Equal("Id", entity.GetKey().Properties.First().Name);
Assert.Equal("Name", entity.GetKey().Properties.Last().Name);
}
public void Can_set_entity_key_with_annotations()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Key(k => k.Properties(e => new { e.Id, e.Name })
.Annotation("A1", "V1")
.Annotation("A2", "V2"));
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entity.GetKey().Properties.Count());
Assert.Equal(new[] { "Id", "Name" }, entity.GetKey().Properties.Select(p => p.Name));
Assert.Equal("V1", entity.GetKey()["A1"]);
Assert.Equal("V2", entity.GetKey()["A2"]);
}
public void Can_set_composite_entity_key_from_property_names_when_mixed_properties()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity <Customer>(b =>
{
b.Property(e => e.Id);
b.Property <string>("Name");
b.Key("Id", "Name");
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entity.GetKey().Properties.Count());
Assert.Equal("Id", entity.GetKey().Properties.First().Name);
Assert.Equal("Name", entity.GetKey().Properties.Last().Name);
}
public virtual void Can_set_entity_key_from_property_name_when_no_clr_property()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Customer>(b =>
{
b.Property<int>(Customer.IdProperty.Name + 1);
b.Ignore(p => p.Details);
b.Ignore(p => p.Orders);
b.HasKey(Customer.IdProperty.Name + 1);
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(1, entity.GetPrimaryKey().Properties.Count);
Assert.Equal(Customer.IdProperty.Name + 1, entity.GetPrimaryKey().Properties.First().Name);
}
public void Can_add_foreign_key_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Key(c => c.Id);
modelBuilder.Entity("Order", b =>
{
b.Property <int>("CustomerId");
b.ForeignKeys(fks => fks.ForeignKey("Customer", "CustomerId"));
});
var entityType = model.GetEntityType(typeof(Order));
Assert.Equal(1, entityType.ForeignKeys.Count());
}
public void Can_add_multiple_indexes()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder
.Entity <Customer>()
.Indexes(ixs =>
{
ixs.Index(ix => ix.Id).IsUnique();
ixs.Index(ix => ix.Name).Annotation("A1", "V1");
});
var entityType = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entityType.Indexes.Count());
Assert.True(entityType.Indexes.First().IsUnique);
Assert.False(entityType.Indexes.Last().IsUnique);
Assert.Equal("V1", entityType.Indexes.Last()["A1"]);
}
public void Can_set_entity_key_with_annotations_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity("Customer", ps =>
{
ps.Property <int>("Id");
ps.Property <string>("Name");
ps.Key(k => k.Properties("Id", "Name")
.Annotation("A1", "V1")
.Annotation("A2", "V2"));
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entity.GetKey().Properties.Count());
Assert.Equal(new[] { "Id", "Name" }, entity.GetKey().Properties.Select(p => p.Name));
Assert.Equal("V1", entity.GetKey()["A1"]);
Assert.Equal("V2", entity.GetKey()["A2"]);
}
public void Can_add_multiple_foreign_keys()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity <Customer>().Key(c => c.Id);
modelBuilder
.Entity <Order>()
.ForeignKeys(
fks =>
{
fks.ForeignKey <Customer>(c => c.CustomerId);
fks.ForeignKey <Customer>(c => c.CustomerId).IsUnique();
});
var entityType = model.GetEntityType(typeof(Order));
Assert.Equal(2, entityType.ForeignKeys.Count());
Assert.True(entityType.ForeignKeys.Last().IsUnique);
}
public void Can_add_multiple_indexes_when_no_clr_type()
{
var model = new Model();
var modelBuilder = new ModelBuilder(model);
modelBuilder.Entity("Customer", ps =>
{
ps.Property <int>("Id");
ps.Property <string>("Name");
ps.Indexes(ixs =>
{
ixs.Index("Id").IsUnique();
ixs.Index("Name").Annotation("A1", "V1");
});
});
var entityType = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entityType.Indexes.Count());
Assert.True(entityType.Indexes.First().IsUnique);
Assert.False(entityType.Indexes.Last().IsUnique);
Assert.Equal("V1", entityType.Indexes.Last()["A1"]);
}
private static IModel BuildModel(
bool createProducts = true, bool createCategory = true,
bool createFeaturedProductCategory = true, bool createFeaturedProduct = true)
{
var model = new Model();
var builder = TestHelpers.Instance.CreateConventionBuilder(model);
builder.Entity<Product>();
builder.Entity<Category>();
var categoryType = model.GetEntityType(typeof(Category));
var productType = model.GetEntityType(typeof(Product));
var categoryFk = productType.GetOrAddForeignKey(productType.GetProperty("CategoryId"), categoryType.GetPrimaryKey(), categoryType);
var featuredProductFk = categoryType.GetOrAddForeignKey(categoryType.GetProperty("FeaturedProductId"), productType.GetPrimaryKey(), productType);
featuredProductFk.IsUnique = true;
if (createProducts)
{
categoryType.AddNavigation("Products", categoryFk, pointsToPrincipal: false);
}
if (createCategory)
{
productType.AddNavigation("Category", categoryFk, pointsToPrincipal: true);
}
if (createFeaturedProductCategory)
{
productType.AddNavigation("FeaturedProductCategory", featuredProductFk, pointsToPrincipal: false);
}
if (createFeaturedProduct)
{
categoryType.AddNavigation("FeaturedProduct", featuredProductFk, pointsToPrincipal: true);
}
return model;
}
public virtual void Can_set_composite_entity_key_from_property_names_when_mixed_properties()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Ignore<CustomerDetails>();
modelBuilder.Ignore<Order>();
modelBuilder.Entity<Customer>(b =>
{
b.Property<string>(Customer.NameProperty.Name + "Shadow");
b.HasKey(Customer.IdProperty.Name, Customer.NameProperty.Name + "Shadow");
});
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entity.GetPrimaryKey().Properties.Count);
Assert.Equal(Customer.IdProperty.Name, entity.GetPrimaryKey().Properties.First().Name);
Assert.Equal(Customer.NameProperty.Name + "Shadow", entity.GetPrimaryKey().Properties.Last().Name);
}
public virtual void Can_set_composite_entity_key_from_clr_properties()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder
.Entity<Customer>()
.HasKey(e => new { e.Id, e.Name });
var entity = model.GetEntityType(typeof(Customer));
Assert.Equal(2, entity.GetPrimaryKey().Properties.Count);
Assert.Equal(Customer.IdProperty.Name, entity.GetPrimaryKey().Properties.First().Name);
Assert.Equal(Customer.NameProperty.Name, entity.GetPrimaryKey().Properties.Last().Name);
}
public virtual void Can_add_multiple_indexes()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
var entityBuilder = modelBuilder.Entity<Customer>();
var firstIndexBuilder = entityBuilder.Index(ix => ix.Id).Unique();
var secondIndexBuilder = entityBuilder.Index(ix => ix.Name).Annotation("A1", "V1");
var entityType = (IEntityType)model.GetEntityType(typeof(Customer));
Assert.Equal(2, entityType.GetIndexes().Count());
Assert.True(firstIndexBuilder.Metadata.IsUnique);
Assert.False(((IIndex)secondIndexBuilder.Metadata).IsUnique);
Assert.Equal("V1", secondIndexBuilder.Metadata["A1"]);
}
public virtual void Can_add_index_when_no_clr_property()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder
.Entity<Customer>(b =>
{
b.Property<int>("Index");
b.Index("Index");
});
var entityType = model.GetEntityType(typeof(Customer));
var index = entityType.Indexes.Single();
Assert.Equal("Index", index.Properties.Single().Name);
}
public virtual void Can_add_index()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder
.Entity<Customer>()
.Index(ix => ix.Name);
var entityType = model.GetEntityType(typeof(Customer));
var index = entityType.Indexes.Single();
Assert.Equal(Customer.NameProperty.Name, index.Properties.Single().Name);
}
public virtual void Can_set_max_length_for_properties()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Quarks>(b =>
{
b.Property(e => e.Up).HasMaxLength(0);
b.Property(e => e.Down).HasMaxLength(100);
b.Property<int>("Charm").HasMaxLength(0);
b.Property<string>("Strange").HasMaxLength(100);
b.Property<int>("Top").HasMaxLength(0);
b.Property<string>("Bottom").HasMaxLength(100);
});
var entityType = model.GetEntityType(typeof(Quarks));
Assert.Null(entityType.GetProperty(Customer.IdProperty.Name).GetMaxLength());
Assert.Equal(0, entityType.GetProperty("Up").GetMaxLength());
Assert.Equal(100, entityType.GetProperty("Down").GetMaxLength());
Assert.Equal(0, entityType.GetProperty("Charm").GetMaxLength());
Assert.Equal(100, entityType.GetProperty("Strange").GetMaxLength());
Assert.Equal(0, entityType.GetProperty("Top").GetMaxLength());
Assert.Equal(100, entityType.GetProperty("Bottom").GetMaxLength());
}
public virtual void Properties_can_be_set_to_be_store_computed()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Quarks>(b =>
{
b.HasKey(e => e.Id);
b.Property(e => e.Up).ValueGeneratedOnAddOrUpdate();
b.Property(e => e.Down).ValueGeneratedNever();
b.Property<int>("Charm").ValueGeneratedOnAdd();
b.Property<string>("Strange").ValueGeneratedNever();
b.Property<int>("Top").ValueGeneratedOnAddOrUpdate();
b.Property<string>("Bottom").ValueGeneratedNever();
});
var entityType = model.GetEntityType(typeof(Quarks));
Assert.Equal(ValueGenerated.OnAdd, entityType.GetProperty(Customer.IdProperty.Name).ValueGenerated);
Assert.Equal(ValueGenerated.OnAddOrUpdate, entityType.GetProperty("Up").ValueGenerated);
Assert.Equal(ValueGenerated.Never, entityType.GetProperty("Down").ValueGenerated);
Assert.Equal(ValueGenerated.OnAdd, entityType.GetProperty("Charm").ValueGenerated);
Assert.Equal(ValueGenerated.Never, entityType.GetProperty("Strange").ValueGenerated);
Assert.Equal(ValueGenerated.OnAddOrUpdate, entityType.GetProperty("Top").ValueGenerated);
Assert.Equal(ValueGenerated.Never, entityType.GetProperty("Bottom").ValueGenerated);
}
public virtual void Properties_can_be_set_to_generate_values_on_Add()
{
var model = new Model();
var modelBuilder = CreateModelBuilder(model);
modelBuilder.Entity<Quarks>(b =>
{
b.Property(e => e.Id).Metadata.RequiresValueGenerator = false;
b.Property(e => e.Up).Metadata.RequiresValueGenerator = true;
b.Property(e => e.Down).Metadata.RequiresValueGenerator = true;
b.Property<int>("Charm").Metadata.RequiresValueGenerator = true;
b.Property<string>("Strange").Metadata.RequiresValueGenerator = false;
b.Property<int>("Top").Metadata.RequiresValueGenerator = true;
b.Property<string>("Bottom").Metadata.RequiresValueGenerator = false;
});
var entityType = model.GetEntityType(typeof(Quarks));
Assert.Equal(false, entityType.GetProperty(Customer.IdProperty.Name).RequiresValueGenerator);
Assert.Equal(true, entityType.GetProperty("Up").RequiresValueGenerator);
Assert.Equal(true, entityType.GetProperty("Down").RequiresValueGenerator);
Assert.Equal(true, entityType.GetProperty("Charm").RequiresValueGenerator);
Assert.Equal(false, entityType.GetProperty("Strange").RequiresValueGenerator);
Assert.Equal(true, entityType.GetProperty("Top").RequiresValueGenerator);
Assert.Equal(false, entityType.GetProperty("Bottom").RequiresValueGenerator);
}
