public void Does_not_throw_when_navigation_is_added() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention); var referencedEntityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention); referencedEntityTypeBuilder.Ignore("Property", ConfigurationSource.Convention); entityTypeBuilder.Relationship(referencedEntityTypeBuilder, "Navigation", null, ConfigurationSource.Convention); new PropertyMappingValidationConvention().Apply(modelBuilder); }
private InternalIndexBuilder CreateInternalIndexBuilder() { var modelBuilder = new InternalModelBuilder(new Model()); var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit); return entityBuilder.HasIndex(new[] { Customer.IdProperty, Customer.NameProperty }, ConfigurationSource.Explicit); }
public void Does_not_throw_when_primitive_type_is_ignored() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Ignore("Property", ConfigurationSource.Convention); new RelationalPropertyMappingValidationConvention(new TestRelationalTypeMapper()).Apply(modelBuilder); }
public void Does_not_throw_when_primitive_type_is_added() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("Property", typeof(int), ConfigurationSource.Convention); new PropertyMappingValidationConvention().Apply(modelBuilder); }
public void Throws_when_primitive_type_is_not_added_or_ignored() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention); Assert.Equal(CoreStrings.PropertyNotAdded("Property", typeof(PrimitivePropertyEntity).FullName), Assert.Throws<InvalidOperationException>(() => new RelationalPropertyMappingValidationConvention(new TestRelationalTypeMapper()).Apply(modelBuilder)).Message); }
public void Does_not_throw_when_navigation_is_ignored() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention); entityTypeBuilder.Ignore("Navigation", ConfigurationSource.Convention); new PropertyMappingValidationConvention().Apply(modelBuilder); }
public void Throws_when_navigation_is_not_added_or_ignored() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention); Assert.Equal(CoreStrings.NavigationNotAdded("Navigation", typeof(NavigationEntity).FullName), Assert.Throws<InvalidOperationException>(() => new PropertyMappingValidationConvention().Apply(modelBuilder)).Message); }
public virtual void Does_not_throw_when_primitive_type_property_is_ignored() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(PrimitivePropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Ignore("Property", ConfigurationSource.Convention); CreateConvention().Apply(modelBuilder); }
public virtual void Throws_when_navigation_is_not_added_or_ignored() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationEntity), ConfigurationSource.Convention); Assert.Equal( CoreStrings.NavigationNotAdded(typeof(NavigationEntity).DisplayName(fullName: false), "Navigation", typeof(PrimitivePropertyEntity).Name), Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public void Throws_when_added_property_is_not_primitive_type() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("Property", typeof(NavigationAsProperty), ConfigurationSource.Convention); Assert.Equal(CoreStrings.PropertyNotMapped("Property", typeof(NonPrimitiveAsPropertyEntity).FullName), Assert.Throws<InvalidOperationException>(() => new PropertyMappingValidationConvention().Apply(modelBuilder)).Message); }
public void Throws_when_added_property_is_not_mapped_to_store_even_if_configured_to_use_column_type() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("Property", typeof(long), ConfigurationSource.Convention).Relational(ConfigurationSource.Convention).ColumnType("some_int_mapping"); Assert.Equal(CoreStrings.PropertyNotMapped("Property", typeof(NonPrimitiveAsPropertyEntity).FullName), Assert.Throws<InvalidOperationException>(() => new RelationalPropertyMappingValidationConvention(new TestRelationalTypeMapper()).Apply(modelBuilder)).Message); }
public void NotMappedAttribute_does_not_override_configuration_from_explicit_source() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityBuilder = modelBuilder.Entity(typeof(A), ConfigurationSource.Explicit); new NotMappedEntityTypeAttributeConvention().Apply(entityBuilder); Assert.Equal(1, modelBuilder.Metadata.EntityTypes.Count); }
public void NotMappedAttribute_overrides_configuration_from_convention_source() { var modelBuilder = new InternalModelBuilder(new Model()); var entityBuilder = modelBuilder.Entity(typeof(A), ConfigurationSource.Convention); new NotMappedEntityTypeAttributeConvention().Apply(entityBuilder); Assert.Equal(0, modelBuilder.Metadata.GetEntityTypes().Count()); }
public void Throws_when_added_property_is_not_mapped_to_store_even_if_configured_to_use_column_type() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("LongProperty", typeof(long), ConfigurationSource.Convention).Relational(ConfigurationSource.Convention).HasColumnType("some_int_mapping"); Assert.Equal(CoreStrings.PropertyNotMapped( typeof(NonPrimitiveAsPropertyEntity).DisplayName(fullName: false), "LongProperty", typeof(long).DisplayName(fullName: false)), Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public virtual void Throws_when_nonprimitive_value_type_property_is_not_added_or_ignored() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveValueTypePropertyEntity), ConfigurationSource.Convention); Assert.Equal( CoreStrings.PropertyNotAdded( typeof(NonPrimitiveValueTypePropertyEntity).DisplayName(fullName: false), "Property", typeof(CancellationToken).Name), Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public void Property_added_by_name_is_non_shadow_if_matches_Clr_property() { var model = new Model(); var modelBuilder = new InternalModelBuilder(model); var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit); var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention); var property = builder.Metadata; Assert.Equal(typeof(string), property.ClrType); Assert.False(property.IsShadowProperty); }
private static InternalEntityTypeBuilder CreateInternalEntityTypeBuilder <T>() { var modelBuilder = new InternalModelBuilder( new Model( new CoreConventionSetBuilder( new CoreConventionSetBuilderDependencies( new CoreTypeMapper(new CoreTypeMapperDependencies()))) .CreateConventionSet())); return(modelBuilder.Entity(typeof(T), ConfigurationSource.Explicit)); }
public virtual void Throws_when_keyless_type_property_is_not_added_or_ignored() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveReferenceTypePropertyEntity), ConfigurationSource.Convention); Assert.Equal( CoreStrings.PropertyNotAdded( typeof(NonPrimitiveReferenceTypePropertyEntity).ShortDisplayName(), nameof(NonPrimitiveReferenceTypePropertyEntity.Property), typeof(ICollection <Uri>).ShortDisplayName()), Assert.Throws <InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public virtual void Throws_when_interface_type_property_is_not_added_or_ignored() { var modelBuilder = new InternalModelBuilder(new Model()); modelBuilder.Entity(typeof(InterfaceNavigationEntity), ConfigurationSource.Convention); Assert.Equal(CoreStrings.InterfacePropertyNotAdded( typeof(InterfaceNavigationEntity).ShortDisplayName(), "Navigation", typeof(IList <INavigationEntity>).ShortDisplayName()), Assert.Throws <InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public virtual void Throws_when_added_property_is_not_of_primitive_type() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("Property", typeof(NavigationAsProperty), ConfigurationSource.Convention); Assert.Equal(CoreStrings.PropertyNotMapped( typeof(NonPrimitiveAsPropertyEntity).DisplayName(fullName: false), "Property", typeof(NavigationAsProperty).DisplayName(fullName: false)), Assert.Throws<InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public virtual void QueryFilter_containing_db_set_with_not_included_type() { var modelBuilder = new InternalModelBuilder(new Model()); Expression <Func <Blog, bool> > lambda = e => new MyContext().Set <Post>().Single().Id == e.Id; modelBuilder.Entity(typeof(Blog), ConfigurationSource.Explicit) .HasQueryFilter(lambda, ConfigurationSource.Explicit); Assert.Equal( CoreStrings.InvalidSetType(typeof(Post).ShortDisplayName()), Assert.Throws <InvalidOperationException>(() => RunConvention(modelBuilder)).Message); }
public void Cannot_set_required_to_false_if_nonnullable() { var modelBuilder = new InternalModelBuilder(new Model()); var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Convention); var builder = entityBuilder.Property(typeof(int), nameof(Customer.Id), ConfigurationSource.Convention); Assert.Null(builder.IsRequired(false, ConfigurationSource.DataAnnotation)); Assert.Equal( CoreStrings.CannotBeNullable(nameof(Customer.Id), typeof(Customer).Name, "int"), Assert.Throws <InvalidOperationException>(() => builder.IsRequired(false, ConfigurationSource.Explicit)).Message); }
private InternalEntityTypeBuilder CreateInternalEntityTypeBuilder <T>() { var conventionSet = new ConventionSet(); conventionSet.EntityTypeAddedConventions.Add(new PropertyDiscoveryConvention(CreateTypeMapper())); conventionSet.EntityTypeAddedConventions.Add(new KeyDiscoveryConvention()); var modelBuilder = new InternalModelBuilder(new Model(conventionSet)); return(modelBuilder.Entity(typeof(T), ConfigurationSource.Explicit)); }
private InternalEntityTypeBuilder CreateInternalEntityBuilder <T>() { var modelBuilder = new InternalModelBuilder(new Model()); var entityBuilder = modelBuilder.Entity(typeof(T), ConfigurationSource.Convention); var context = new ConventionContext <IConventionEntityTypeBuilder>(modelBuilder.Metadata.ConventionDispatcher); new PropertyDiscoveryConvention(CreateDependencies()) .ProcessEntityTypeAdded(entityBuilder, context); return(entityBuilder); }
public void Throws_when_added_property_is_not_mapped_to_store_even_if_configured_to_use_column_type() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("LongProperty", typeof(Tuple <long>), ConfigurationSource.Convention).Relational(ConfigurationSource.Convention).HasColumnType("some_int_mapping"); Assert.Equal( CoreStrings.PropertyNotMapped( typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(), "LongProperty", typeof(Tuple <long>).ShortDisplayName()), Assert.Throws <InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public void Does_not_throw_an_exception_when_key_is_referenced_by_foreign_key_and_defined_on_shadow_properties_which_are_not_defined_by_convention() { var modelBuilder = new InternalModelBuilder(new Model()); var principalEntityBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention); var referencedEntityBuilder = modelBuilder.Entity(typeof(ReferencedEntity), ConfigurationSource.Convention); principalEntityBuilder.Property("Foo", typeof(string), ConfigurationSource.DataAnnotation); referencedEntityBuilder.Property("Foo", typeof(string), ConfigurationSource.DataAnnotation); var properties = new List <string> { "Foo" }; referencedEntityBuilder.HasForeignKey( principalEntityBuilder, referencedEntityBuilder.GetOrCreateProperties(properties, ConfigurationSource.Convention), ConfigurationSource.Convention) .HasPrincipalKey(principalEntityBuilder.GetOrCreateProperties(properties, ConfigurationSource.Convention), ConfigurationSource.Convention); Assert.Same(modelBuilder, new KeyConvention().Apply(modelBuilder)); }
public void Does_not_throw_an_exception_when_key_is_defined_on_shadow_properties_which_are_not_defined_by_convention() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("Foo", typeof(string), ConfigurationSource.DataAnnotation); entityTypeBuilder.HasKey(new List <string> { "Foo" }, ConfigurationSource.Convention); Assert.Same(modelBuilder, new KeyConvention().Apply(modelBuilder)); }
private static InternalEntityTypeBuilder CreateInternalEntityBuilder <T>() { var modelBuilder = new InternalModelBuilder(new Model()); var entityBuilder = modelBuilder.Entity(typeof(T), ConfigurationSource.Convention); new PropertyDiscoveryConvention( TestServiceFactory.Instance.Create <InMemoryTypeMappingSource>(), new TestLogger <DbLoggerCategory.Model, TestLoggingDefinitions>()) .Apply(entityBuilder); return(entityBuilder); }
public virtual void Detects_shadow_key_referenced_by_foreign_key_by_convention() { var modelBuilder = new InternalModelBuilder(new Model()); var dependentEntityBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention); dependentEntityBuilder.Property("Id", typeof(int), ConfigurationSource.Convention); dependentEntityBuilder.PrimaryKey( new List <string> { "Id" }, ConfigurationSource.Convention); var principalEntityBuilder = modelBuilder.Entity(typeof(ReferencedEntity), ConfigurationSource.Convention); principalEntityBuilder.Property("Id", typeof(int), ConfigurationSource.Convention); principalEntityBuilder.PrimaryKey( new List <string> { "Id" }, ConfigurationSource.Convention); dependentEntityBuilder.Property("Foo", typeof(string), ConfigurationSource.Convention); principalEntityBuilder.Property("ReferencedFoo", typeof(string), ConfigurationSource.Convention); dependentEntityBuilder.HasForeignKey( principalEntityBuilder, dependentEntityBuilder.GetOrCreateProperties( new List <string> { "Foo" }, ConfigurationSource.Convention), principalEntityBuilder.HasKey(new[] { "ReferencedFoo" }, ConfigurationSource.Convention).Metadata, ConfigurationSource.Convention); VerifyError( CoreStrings.ReferencedShadowKey( typeof(SampleEntity).Name, typeof(ReferencedEntity).Name, "{'Foo' : string}", "{'Id' : int}"), modelBuilder.Metadata); }
public void OnKeyAdded_calls_apply_on_conventions_in_order(bool useBuilder) { var conventions = new ConventionSet(); InternalKeyBuilder keyBuilder = null; var convention = new Mock <IKeyConvention>(); convention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b => { Assert.NotNull(b); keyBuilder = new InternalKeyBuilder(b.Metadata, b.ModelBuilder); return(keyBuilder); }); conventions.KeyAddedConventions.Add(convention.Object); var nullConvention = new Mock <IKeyConvention>(); nullConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b => { Assert.Same(keyBuilder, b); return(null); }); conventions.KeyAddedConventions.Add(nullConvention.Object); var extraConvention = new Mock <IKeyConvention>(); extraConvention.Setup(c => c.Apply(It.IsAny <InternalKeyBuilder>())).Returns <InternalKeyBuilder>(b => { Assert.False(true); return(null); }); conventions.KeyAddedConventions.Add(extraConvention.Object); var builder = new InternalModelBuilder(new Model(conventions)); var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention); if (useBuilder) { Assert.Null(entityBuilder.HasKey(new List <string> { "OrderId" }, ConfigurationSource.Convention)); } else { var property = entityBuilder.Property("OrderId", ConfigurationSource.Convention).Metadata; property.IsNullable = false; Assert.Null(entityBuilder.Metadata.AddKey(property)); } Assert.NotNull(keyBuilder); }
private static InternalEntityTypeBuilder CreateInternalEntityBuilder <T>(params Action <InternalEntityTypeBuilder>[] onEntityAdded) { var conventions = new ConventionSet(); if (onEntityAdded != null) { conventions.EntityTypeAddedConventions.Add(new TestModelChangeListener(onEntityAdded)); } var modelBuilder = new InternalModelBuilder(new Model(), conventions); var entityBuilder = modelBuilder.Entity(typeof(T), ConfigurationSource.Convention); return(entityBuilder); }
public void OnNavigationRemoved_calls_apply_on_conventions_in_order() { var conventions = new ConventionSet(); InternalEntityTypeBuilder dependentEntityTypeBuilderFromConvention = null; InternalEntityTypeBuilder principalEntityBuilderFromConvention = null; var convention = new Mock <INavigationRemovedConvention>(); convention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <string>())).Returns((InternalEntityTypeBuilder s, InternalEntityTypeBuilder t, string n) => { dependentEntityTypeBuilderFromConvention = s; principalEntityBuilderFromConvention = t; Assert.Equal(nameof(OrderDetails.Order), n); return(false); }); conventions.NavigationRemovedConventions.Add(convention.Object); var extraConvention = new Mock <INavigationRemovedConvention>(); extraConvention.Setup(c => c.Apply(It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <InternalEntityTypeBuilder>(), It.IsAny <string>())).Returns((InternalEntityTypeBuilder s, InternalEntityTypeBuilder t, string n) => { Assert.False(true); return(false); }); conventions.NavigationRemovedConventions.Add(extraConvention.Object); var builder = new InternalModelBuilder(new Model(), conventions); var principalEntityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention); var dependentEntityBuilder = builder.Entity(typeof(OrderDetails), ConfigurationSource.Convention); var relationshipBuilder = dependentEntityBuilder.Relationship(principalEntityBuilder, nameof(OrderDetails.Order), nameof(Order.OrderDetails), ConfigurationSource.Convention); relationshipBuilder.DependentToPrincipal(null, ConfigurationSource.Convention); Assert.NotNull(relationshipBuilder); Assert.Same(dependentEntityTypeBuilderFromConvention, dependentEntityBuilder); Assert.Same(principalEntityBuilderFromConvention, principalEntityBuilder); }
public void Throws_an_exception_when_shadow_key_is_defined_by_convention() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("Foo", typeof(string), ConfigurationSource.Convention); entityTypeBuilder.HasKey(new List <string> { "Foo" }, ConfigurationSource.Convention); Assert.Equal(CoreStrings.ShadowKey("{'Foo'}", typeof(SampleEntity).Name, "{'Foo'}"), Assert.Throws <InvalidOperationException>(() => new KeyConvention().Apply(modelBuilder)).Message); }
public virtual void Detects_non_owner_navigation_to_owned_entity_type() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention); entityTypeBuilder.PrimaryKey(new[] { nameof(SampleEntity.Id) }, ConfigurationSource.Convention); var ownershipBuilder = entityTypeBuilder.Owns( typeof(ReferencedEntity), nameof(SampleEntity.ReferencedEntity), ConfigurationSource.Convention); var ownedTypeBuilder = ownershipBuilder.Metadata.DeclaringEntityType.Builder; ownedTypeBuilder.PrimaryKey(ownershipBuilder.Metadata.Properties.Select(p => p.Name).ToList(), ConfigurationSource.Convention); var anotherEntityTypeBuilder = modelBuilder.Entity(typeof(AnotherSampleEntity), ConfigurationSource.Convention); anotherEntityTypeBuilder.PrimaryKey(new[] { nameof(AnotherSampleEntity.Id) }, ConfigurationSource.Convention); anotherEntityTypeBuilder.Navigation(ownedTypeBuilder, nameof(AnotherSampleEntity.ReferencedEntity), ConfigurationSource.Convention) .RelatedEntityTypes(anotherEntityTypeBuilder.Metadata, ownedTypeBuilder.Metadata, ConfigurationSource.Convention); VerifyError( CoreStrings.InverseToOwnedType( nameof(AnotherSampleEntity), nameof(SampleEntity.ReferencedEntity), nameof(ReferencedEntity), nameof(SampleEntity)), modelBuilder.Metadata); }
public void Throws_when_added_property_is_not_mapped_to_store() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property(typeof(Tuple <long>), "LongProperty", ConfigurationSource.Explicit); entityTypeBuilder.Ignore(nameof(NonPrimitiveAsPropertyEntity.Property), ConfigurationSource.Explicit); Assert.Equal( CoreStrings.PropertyNotMapped( typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(), "LongProperty", typeof(Tuple <long>).ShortDisplayName()), Assert.Throws <InvalidOperationException>(() => CreatePropertyMappingValidator()(modelBuilder.Metadata)).Message); }
private void ApplyOnRelatedEntityTypes(InternalModelBuilder modelBuilder, EntityType entityType) { var relatedEntityTypes = entityType.GetReferencingForeignKeys().Select(fk => fk.DeclaringEntityType) .Concat(entityType.GetForeignKeys().Select(fk => fk.PrincipalEntityType)) .Distinct() .ToList(); foreach (var relatedEntityType in relatedEntityTypes) { var relatedEntityTypeBuilder = modelBuilder.Entity(relatedEntityType.Name, ConfigurationSource.Convention); Apply(relatedEntityTypeBuilder); } }
public virtual void Throws_when_added_property_is_not_of_primitive_type() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonPrimitiveAsPropertyEntity), ConfigurationSource.Convention); entityTypeBuilder.Property("Property", typeof(NavigationAsProperty), ConfigurationSource.Convention); Assert.Equal(CoreStrings.PropertyNotMapped( typeof(NonPrimitiveAsPropertyEntity).ShortDisplayName(), "Property", typeof(NavigationAsProperty).ShortDisplayName()), Assert.Throws <InvalidOperationException>(() => CreateConvention().Apply(modelBuilder)).Message); }
public void ReferencedKey_does_not_return_same_instance_if_no_navigations_or_foreign_key() { var modelBuilder = new InternalModelBuilder(new Model(), null); var customerEntityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit); customerEntityBuilder.Key(new[] { Customer.IdProperty, Customer.UniqueProperty }, ConfigurationSource.Explicit); var orderEntityBuilder = modelBuilder.Entity(typeof(Order), ConfigurationSource.Explicit); orderEntityBuilder.Key(new[] { Order.IdProperty }, ConfigurationSource.Explicit); var relationshipBuilder = orderEntityBuilder.Relationship(typeof(Customer), typeof(Order), null, null, ConfigurationSource.DataAnnotation, true, true) .ReferencedKey(typeof(Order), new[] { Order.CustomerIdProperty.Name, Order.CustomerUniqueProperty.Name }, ConfigurationSource.DataAnnotation); Assert.NotNull(relationshipBuilder); Assert.Same(relationshipBuilder, relationshipBuilder.ReferencedKey(typeof(Order), new[] { Order.CustomerIdProperty.Name, Order.CustomerUniqueProperty.Name }, ConfigurationSource.DataAnnotation)); Assert.NotSame(relationshipBuilder, customerEntityBuilder.Relationship(typeof(Order), typeof(Customer), null, null, ConfigurationSource.DataAnnotation, true, true) .ReferencedKey(typeof(Order).FullName, new[] { Order.CustomerIdProperty.Name, Order.CustomerUniqueProperty.Name }, ConfigurationSource.Convention)); Assert.Null(relationshipBuilder.ReferencedKey(typeof(Order), new[] { Order.CustomerIdProperty }, ConfigurationSource.Convention)); Assert.Equal(2, customerEntityBuilder.Metadata.ForeignKeys.Count); }
public void Can_only_override_lower_source_Required() { var modelBuilder = new InternalModelBuilder(new Model(), null); var customerEntityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit); customerEntityBuilder.Key(new[] { Customer.IdProperty, Customer.UniqueProperty }, ConfigurationSource.Explicit); var orderEntityBuilder = modelBuilder.Entity(typeof(Order), ConfigurationSource.Explicit); var relationshipBuilder = orderEntityBuilder.Relationship(typeof(Customer), typeof(Order), null, null, ConfigurationSource.Convention, true, true); Assert.Null(relationshipBuilder.Metadata.IsRequired); Assert.False(((IForeignKey)relationshipBuilder.Metadata).IsRequired); Assert.True(relationshipBuilder.Required(true, ConfigurationSource.Convention)); Assert.True(((IForeignKey)relationshipBuilder.Metadata).IsRequired); Assert.True(relationshipBuilder.Required(false, ConfigurationSource.DataAnnotation)); Assert.False(((IForeignKey)relationshipBuilder.Metadata).IsRequired); Assert.False(relationshipBuilder.Required(true, ConfigurationSource.Convention)); Assert.False(((IForeignKey)relationshipBuilder.Metadata).IsRequired); }
public void Property_added_by_name_is_shadow_even_if_matches_Clr_type() { var model = new Model(); var modelBuilder = new InternalModelBuilder(model); var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit); var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention); var property = builder.Metadata; Assert.Equal(typeof(string), property.ClrType); Assert.True(property.IsShadowProperty); Assert.Null(property.GetClrTypeConfigurationSource()); Assert.Null(property.GetIsShadowPropertyConfigurationSource()); }
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder) { Check.NotNull(modelBuilder, nameof(modelBuilder)); foreach (var entityType in modelBuilder.Metadata.GetEntityTypes()) { var unmappedProperty = entityType.GetProperties().FirstOrDefault(p => !IsMappedPrimitiveProperty(((IProperty)p).ClrType)); if (unmappedProperty != null) { throw new InvalidOperationException(CoreStrings.PropertyNotMapped(unmappedProperty.Name, entityType.Name)); } if (entityType.HasClrType()) { var clrProperties = new HashSet<string>(); clrProperties.UnionWith(entityType.ClrType.GetRuntimeProperties() .Where(pi => pi.IsCandidateProperty()) .Select(pi => pi.Name)); clrProperties.ExceptWith(entityType.GetProperties().Select(p => p.Name)); clrProperties.ExceptWith(entityType.GetNavigations().Select(p => p.Name)); var entityTypeBuilder = modelBuilder.Entity(entityType.ClrType, ConfigurationSource.Convention); clrProperties.RemoveWhere(p => entityTypeBuilder.IsIgnored(p, ConfigurationSource.Convention)); if (clrProperties.Count > 0) { foreach (var clrProperty in clrProperties) { var actualProperty = entityType.ClrType.GetRuntimeProperty(clrProperty); var targetType = FindCandidateNavigationPropertyType(actualProperty); if (targetType != null) { if (!modelBuilder.IsIgnored(targetType.DisplayName(), ConfigurationSource.Convention)) { throw new InvalidOperationException(CoreStrings.NavigationNotAdded(actualProperty.Name, entityType.Name)); } } else { throw new InvalidOperationException(CoreStrings.PropertyNotAdded(actualProperty.Name, entityType.Name)); } } } } } return modelBuilder; }
public void OnEntityTypeIgnored_calls_apply_on_conventions_in_order(bool useBuilder) { var conventions = new ConventionSet(); InternalModelBuilder newModelBuilder = null; var convention = new Mock <IEntityTypeIgnoredConvention>(); convention.Setup(c => c.Apply(It.IsAny <InternalModelBuilder>(), It.IsAny <string>(), It.IsAny <Type>())) .Returns <InternalModelBuilder, string, Type>((b, n, t) => { Assert.NotNull(b); Assert.Equal(typeof(Order).DisplayName(), n); Assert.Same(typeof(Order), t); return(true); }); conventions.EntityTypeIgnoredConventions.Add(convention.Object); var haltingConvention = new Mock <IEntityTypeIgnoredConvention>(); haltingConvention.Setup(c => c.Apply(It.IsAny <InternalModelBuilder>(), It.IsAny <string>(), It.IsAny <Type>())) .Returns <InternalModelBuilder, string, Type>((b, n, t) => { newModelBuilder = new InternalModelBuilder(b.Metadata); return(false); }); conventions.EntityTypeIgnoredConventions.Add(haltingConvention.Object); var extraConvention = new Mock <IEntityTypeIgnoredConvention>(); extraConvention.Setup(c => c.Apply(It.IsAny <InternalModelBuilder>(), It.IsAny <string>(), It.IsAny <Type>())) .Returns <InternalModelBuilder, string, Type>((b, n, t) => { Assert.False(true); return(false); }); conventions.EntityTypeIgnoredConventions.Add(extraConvention.Object); var builder = new InternalModelBuilder(new Model(conventions)); if (useBuilder) { builder.Entity(typeof(Order), ConfigurationSource.Convention); builder.Ignore(typeof(Order).DisplayName(), ConfigurationSource.Convention); } else { builder.Metadata.Ignore(typeof(Order), ConfigurationSource.Convention); } Assert.NotNull(newModelBuilder); }
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder) { Check.NotNull(modelBuilder, nameof(modelBuilder)); foreach (var entityType in modelBuilder.Metadata.GetEntityTypes()) { var unmappedProperty = entityType.GetProperties().FirstOrDefault(p => !IsMappedPrimitiveProperty(((IProperty)p).ClrType)); if (unmappedProperty != null) { throw new InvalidOperationException(CoreStrings.PropertyNotMapped(unmappedProperty.Name, entityType.Name)); } if (entityType.HasClrType()) { var clrProperties = new HashSet <string>(); clrProperties.UnionWith(entityType.ClrType.GetRuntimeProperties() .Where(pi => pi.IsCandidateProperty()) .Select(pi => pi.Name)); clrProperties.ExceptWith(entityType.GetProperties().Select(p => p.Name)); clrProperties.ExceptWith(entityType.GetNavigations().Select(p => p.Name)); var entityTypeBuilder = modelBuilder.Entity(entityType.ClrType, ConfigurationSource.Convention); clrProperties.RemoveWhere(p => entityTypeBuilder.IsIgnored(p, ConfigurationSource.Convention)); if (clrProperties.Count > 0) { foreach (var clrProperty in clrProperties) { var actualProperty = entityType.ClrType.GetRuntimeProperty(clrProperty); var targetType = FindCandidateNavigationPropertyType(actualProperty); if (targetType != null) { if (!modelBuilder.IsIgnored(targetType.DisplayName(), ConfigurationSource.Convention)) { throw new InvalidOperationException(CoreStrings.NavigationNotAdded(actualProperty.Name, entityType.Name)); } } else { throw new InvalidOperationException(CoreStrings.PropertyNotAdded(actualProperty.Name, entityType.Name)); } } } } } return(modelBuilder); }
public virtual void Pases_on_valid_owned_entity_types() { var modelBuilder = new InternalModelBuilder(new Model()); var entityTypeBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention); entityTypeBuilder.PrimaryKey(new[] { nameof(SampleEntity.Id) }, ConfigurationSource.Convention); var ownershipBuilder = entityTypeBuilder.Owns( typeof(ReferencedEntity), nameof(SampleEntity.ReferencedEntity), ConfigurationSource.Convention); var ownedTypeBuilder = ownershipBuilder.Metadata.DeclaringEntityType.Builder; ownedTypeBuilder.PrimaryKey(ownershipBuilder.Metadata.Properties.Select(p => p.Name).ToList(), ConfigurationSource.Convention); Validate(modelBuilder.Metadata); }
public void Throws_an_exception_when_shadow_key_is_referenced_by_foreign_key() { var modelBuilder = new InternalModelBuilder(new Model()); var principalEntityBuilder = modelBuilder.Entity(typeof(SampleEntity), ConfigurationSource.Convention); var referencedEntityBuilder = modelBuilder.Entity(typeof(ReferencedEntity), ConfigurationSource.Convention); referencedEntityBuilder.Property("Foo", typeof(string), ConfigurationSource.Convention); var properties = new List <string> { "Foo" }; referencedEntityBuilder.HasForeignKey( principalEntityBuilder, referencedEntityBuilder.GetOrCreateProperties(properties, ConfigurationSource.Convention), ConfigurationSource.Convention); Assert.Equal(CoreStrings.ReferencedShadowKeyWithoutNavigations( "{'Foo'}", typeof(SampleEntity).Name, "{'Foo'}", typeof(ReferencedEntity).Name), Assert.Throws <InvalidOperationException>(() => new KeyConvention().Apply(modelBuilder)).Message); }
private static InternalModelBuilder BuildModel() { var modelBuilder = new InternalModelBuilder(new Model()); var principalType = modelBuilder.Entity(typeof(PrincipalEntity), ConfigurationSource.Explicit); principalType.PrimaryKey(new[] { nameof(PrincipalEntity.PeeKay) }, ConfigurationSource.Explicit); var dependentType = modelBuilder.Entity(typeof(DependentEntity), ConfigurationSource.Explicit); dependentType.PrimaryKey(new[] { nameof(DependentEntity.KayPee) }, ConfigurationSource.Explicit); var principalTypeWithCompositeKey = modelBuilder.Entity(typeof(PrincipalEntityWithCompositeKey), ConfigurationSource.Explicit); principalTypeWithCompositeKey.PrimaryKey(new[] { PrincipalEntityWithCompositeKey.IdProperty, PrincipalEntityWithCompositeKey.NameProperty }, ConfigurationSource.Explicit); principalTypeWithCompositeKey.Property(PrincipalEntityWithCompositeKey.NameProperty, ConfigurationSource.Explicit).IsRequired(true, ConfigurationSource.Explicit); var dependentTypeWithCompositeKey = modelBuilder.Entity(typeof(DependentEntityWithCompositeKey), ConfigurationSource.Explicit); dependentTypeWithCompositeKey.PrimaryKey(new[] { nameof(DependentEntityWithCompositeKey.NotId), nameof(DependentEntityWithCompositeKey.NotName) }, ConfigurationSource.Explicit); return(modelBuilder); }
public virtual void QueryFilter_containing_db_set_of_incorrect_type() { var modelBuilder = new InternalModelBuilder(new Model()); modelBuilder.SharedTypeEntity("Post1", typeof(Post), ConfigurationSource.Explicit); Expression <Func <Blog, bool> > lambda = e => new MyContext().Set <Blog>("Post1").Single().Id == e.Id; modelBuilder.Entity(typeof(Blog), ConfigurationSource.Explicit) .HasQueryFilter(lambda, ConfigurationSource.Explicit); Assert.Equal( CoreStrings.DbSetIncorrectGenericType("Post1", typeof(Post).ShortDisplayName(), typeof(Blog).ShortDisplayName()), Assert.Throws <InvalidOperationException>(() => RunConvention(modelBuilder)).Message); }
private InternalEntityTypeBuilder CreateInternalEntityTypeBuilder <T>() { var conventionSet = new ConventionSet(); conventionSet.EntityTypeAddedConventions.Add( new PropertyDiscoveryConvention( new TestRelationalTypeMappingSource( TestServiceFactory.Instance.Create <TypeMappingSourceDependencies>(), TestServiceFactory.Instance.Create <RelationalTypeMappingSourceDependencies>()))); var modelBuilder = new InternalModelBuilder(new Model(conventionSet)); return(modelBuilder.Entity(typeof(T), ConfigurationSource.Explicit)); }
public void Can_only_override_existing_ClrType_value_explicitly() { var model = new Model(); model.AddEntityType(typeof(Customer)).AddProperty(Customer.NameProperty); var modelBuilder = new InternalModelBuilder(model, new ConventionSet()); var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Explicit); var builder = entityBuilder.Property(Customer.NameProperty.Name, ConfigurationSource.Convention); Assert.True(builder.ClrType(typeof(string), ConfigurationSource.DataAnnotation)); Assert.False(builder.ClrType(typeof(int), ConfigurationSource.DataAnnotation)); Assert.Equal(typeof(string), builder.Metadata.ClrType); Assert.True(builder.ClrType(typeof(int), ConfigurationSource.Explicit)); Assert.Equal(typeof(int), builder.Metadata.ClrType); }
public void OnEntityTypeAdded_calls_apply_on_conventions_in_order(bool useBuilder) { var conventions = new ConventionSet(); InternalEntityTypeBuilder entityTypeBuilder = null; var convention = new Mock<IEntityTypeConvention>(); convention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b => { Assert.NotNull(b); entityTypeBuilder = new InternalEntityTypeBuilder(b.Metadata, b.ModelBuilder); return entityTypeBuilder; }); conventions.EntityTypeAddedConventions.Add(convention.Object); var nullConvention = new Mock<IEntityTypeConvention>(); nullConvention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b => { Assert.Same(entityTypeBuilder, b); return null; }); conventions.EntityTypeAddedConventions.Add(nullConvention.Object); var extraConvention = new Mock<IEntityTypeConvention>(); extraConvention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>())).Returns<InternalEntityTypeBuilder>(b => { Assert.False(true); return null; }); conventions.EntityTypeAddedConventions.Add(extraConvention.Object); var builder = new InternalModelBuilder(new Model(conventions)); if (useBuilder) { Assert.Null(builder.Entity(typeof(Order), ConfigurationSource.Convention)); } else { Assert.Null(builder.Metadata.AddEntityType(typeof(Order), ConfigurationSource.Convention)); } Assert.NotNull(entityTypeBuilder); }
public void OnPropertyAdded_calls_apply_on_conventions_in_order() { var conventions = new ConventionSet(); InternalPropertyBuilder propertyBuilder = null; var convention = new Mock<IPropertyConvention>(); convention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b => { Assert.NotNull(b); propertyBuilder = new InternalPropertyBuilder(b.Metadata, b.ModelBuilder, ConfigurationSource.Convention); return propertyBuilder; }); conventions.PropertyAddedConventions.Add(convention.Object); var nullConvention = new Mock<IPropertyConvention>(); nullConvention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b => { Assert.Same(propertyBuilder, b); return null; }); conventions.PropertyAddedConventions.Add(nullConvention.Object); var extraConvention = new Mock<IPropertyConvention>(); extraConvention.Setup(c => c.Apply(It.IsAny<InternalPropertyBuilder>())).Returns<InternalPropertyBuilder>(b => { Assert.False(true); return null; }); conventions.PropertyAddedConventions.Add(extraConvention.Object); var builder = new InternalModelBuilder(new Model(), conventions); var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention); var explicitKeyBuilder = entityBuilder.Property(typeof(int), "OrderId", ConfigurationSource.Convention); Assert.Null(explicitKeyBuilder); Assert.NotNull(propertyBuilder); }
public virtual InternalModelBuilder Apply(InternalModelBuilder modelBuilder) { foreach (var entityType in modelBuilder.Metadata.EntityTypes) { var entityTypeBuilder = modelBuilder.Entity(entityType.Name, ConfigurationSource.Convention); foreach (var key in entityType.GetDeclaredKeys()) { if (key.Properties.Any(p => ((IProperty)p).IsShadowProperty && entityTypeBuilder.CanRemoveProperty(p, ConfigurationSource.Convention))) { string message; var referencingFk = modelBuilder.Metadata.FindReferencingForeignKeys(key).FirstOrDefault(); if (referencingFk != null) { message = CoreStrings.ReferencedShadowKey( Property.Format(key.Properties), entityType.Name, Property.Format(key.Properties), Property.Format(referencingFk.Properties), referencingFk.DeclaringEntityType.Name); } else { message = CoreStrings.ShadowKey( Property.Format(key.Properties), entityType.Name, Property.Format(key.Properties)); } throw new InvalidOperationException(message); } } } return modelBuilder; }
public void OnForeignKeyAdded_calls_apply_on_conventions_in_order() { var conventions = new ConventionSet(); InternalRelationshipBuilder relationshipBuilder = null; var convention = new Mock<IForeignKeyConvention>(); convention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>())).Returns<InternalRelationshipBuilder>(b => { Assert.NotNull(b); relationshipBuilder = new InternalRelationshipBuilder(b.Metadata, b.ModelBuilder, null); return relationshipBuilder; }); conventions.ForeignKeyAddedConventions.Add(convention.Object); var nullConvention = new Mock<IForeignKeyConvention>(); nullConvention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>())).Returns<InternalRelationshipBuilder>(b => { Assert.Same(relationshipBuilder, b); return null; }); conventions.ForeignKeyAddedConventions.Add(nullConvention.Object); var extraConvention = new Mock<IForeignKeyConvention>(); extraConvention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>())).Returns<InternalRelationshipBuilder>(b => { Assert.False(true); return null; }); conventions.ForeignKeyAddedConventions.Add(extraConvention.Object); var builder = new InternalModelBuilder(new Model(), conventions); var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention); entityBuilder.PrimaryKey(new[] { "OrderId" }, ConfigurationSource.Convention); Assert.Null(entityBuilder.Relationship(typeof(Order), typeof(Order), null, null, ConfigurationSource.Convention)); Assert.NotNull(relationshipBuilder); }
public void OnForeignKeyRemoved_calls_apply_on_conventions_in_order() { var conventions = new ConventionSet(); var foreignKeyRemoved = false; var convention = new Mock<IForeignKeyRemovedConvention>(); convention.Setup(c => c.Apply(It.IsAny<InternalEntityTypeBuilder>(), It.IsAny<ForeignKey>())).Callback(() => foreignKeyRemoved = true); conventions.ForeignKeyRemovedConventions.Add(convention.Object); var builder = new InternalModelBuilder(new Model(), conventions); var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention); var foreignKey = new ForeignKey( new[] { entityBuilder.Property("FK", typeof(int), ConfigurationSource.Convention).Metadata }, entityBuilder.HasKey(new[] { "OrderId" }, ConfigurationSource.Convention).Metadata, entityBuilder.Metadata, entityBuilder.Metadata); var conventionDispatcher = new ConventionDispatcher(conventions); conventionDispatcher.OnForeignKeyRemoved(entityBuilder, foreignKey); Assert.True(foreignKeyRemoved); }
public void OnNavigationAdded_calls_apply_on_conventions_in_order() { var conventions = new ConventionSet(); InternalRelationshipBuilder relationshipBuilder = null; var orderIgnored = false; var orderDetailsIgnored = false; var convention = new Mock<INavigationConvention>(); convention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>(), It.IsAny<Navigation>())).Returns((InternalRelationshipBuilder b, Navigation n) => { Assert.NotNull(b); relationshipBuilder = new InternalRelationshipBuilder(b.Metadata, b.ModelBuilder, ConfigurationSource.Convention); return relationshipBuilder; }); conventions.NavigationAddedConventions.Add(convention.Object); var nullConvention = new Mock<INavigationConvention>(); nullConvention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>(), It.IsAny<Navigation>())).Returns((InternalRelationshipBuilder b, Navigation n) => { Assert.Same(relationshipBuilder, b); if (n.Name == "Order") { orderIgnored = true; } if (n.Name == "OrderDetails") { orderDetailsIgnored = true; } return null; }); conventions.NavigationAddedConventions.Add(nullConvention.Object); var extraConvention = new Mock<INavigationConvention>(); extraConvention.Setup(c => c.Apply(It.IsAny<InternalRelationshipBuilder>(), It.IsAny<Navigation>())).Returns((InternalRelationshipBuilder b, Navigation n) => { Assert.False(true); return null; }); conventions.NavigationAddedConventions.Add(extraConvention.Object); var builder = new InternalModelBuilder(new Model(), conventions); var entityBuilder = builder.Entity(typeof(Order), ConfigurationSource.Convention); entityBuilder.PrimaryKey(new[] { "OrderId" }, ConfigurationSource.Convention); Assert.Null(entityBuilder.Relationship(typeof(Order), typeof(OrderDetails), "Order", "OrderDetails", ConfigurationSource.Convention, isUnique: true)); Assert.True(orderIgnored); Assert.False(orderDetailsIgnored); Assert.NotNull(relationshipBuilder); }
private static InternalModelBuilder BuildModel() { var modelBuilder = new InternalModelBuilder(new Model()); var principalType = modelBuilder.Entity(typeof(PrincipalEntity), ConfigurationSource.Explicit); principalType.PrimaryKey(new[] { nameof(PrincipalEntity.PeeKay) }, ConfigurationSource.Explicit); var dependentType = modelBuilder.Entity(typeof(DependentEntity), ConfigurationSource.Explicit); dependentType.PrimaryKey(new[] { nameof(DependentEntity.KayPee) }, ConfigurationSource.Explicit); var principalTypeWithCompositeKey = modelBuilder.Entity(typeof(PrincipalEntityWithCompositeKey), ConfigurationSource.Explicit); principalTypeWithCompositeKey.PrimaryKey(new[] { PrincipalEntityWithCompositeKey.IdProperty, PrincipalEntityWithCompositeKey.NameProperty }, ConfigurationSource.Explicit); principalTypeWithCompositeKey.Property(PrincipalEntityWithCompositeKey.NameProperty, ConfigurationSource.Explicit).IsRequired(true, ConfigurationSource.Explicit); var dependentTypeWithCompositeKey = modelBuilder.Entity(typeof(DependentEntityWithCompositeKey), ConfigurationSource.Explicit); dependentTypeWithCompositeKey.PrimaryKey(new[] { nameof(DependentEntityWithCompositeKey.NotId), nameof(DependentEntityWithCompositeKey.NotName) }, ConfigurationSource.Explicit); return modelBuilder; }
public void Cannot_set_required_to_false_if_nonnullable() { var modelBuilder = new InternalModelBuilder(new Model()); var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Convention); var builder = entityBuilder.Property(nameof(Customer.Id), ConfigurationSource.Convention); builder.HasClrType(typeof(int), ConfigurationSource.Convention); Assert.False(builder.IsRequired(false, ConfigurationSource.DataAnnotation)); Assert.Equal(CoreStrings.CannotBeNullable(nameof(Customer.Id), typeof(Customer).Name, typeof(int).Name), Assert.Throws<InvalidOperationException>(() => builder.IsRequired(false, ConfigurationSource.Explicit)).Message); }
public void Does_not_throw_when_non_candidate_property_is_not_added() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(NonCandidatePropertyEntity), ConfigurationSource.Convention); new PropertyMappingValidationConvention().Apply(modelBuilder); }
private InternalPropertyBuilder CreateInternalPropertyBuilder() { var modelBuilder = new InternalModelBuilder(new Model()); var entityBuilder = modelBuilder.Entity(typeof(Customer), ConfigurationSource.Convention); return entityBuilder.Property(Customer.NameProperty, ConfigurationSource.Convention); }
public void Does_not_throw_when_clr_type_is_not_set_for_shadow_property() { var modelBuilder = new InternalModelBuilder(new Model(), new ConventionSet()); var entityTypeBuilder = modelBuilder.Entity(typeof(NavigationAsProperty), ConfigurationSource.Convention); entityTypeBuilder.Property("ShadowPropertyOfNullType", ConfigurationSource.Convention); new PropertyMappingValidationConvention().Apply(modelBuilder); }