public void Returns_same_builder_if_no_matching_clr_properties_found()
{
var relationshipBuilder = DependentType.Relationship(
PrincipalType,
"SomeNav",
null,
ConfigurationSource.Convention);
relationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
var fk = relationshipBuilder.Metadata;
Assert.Same(fk, DependentType.Metadata.GetForeignKeys().Single());
Assert.Null(fk.GetForeignKeyPropertiesConfigurationSource());
Assert.Equal("SomeNav" + PrimaryKey.Name, fk.Properties.Single().Name);
Assert.False(fk.IsUnique);
}
public void Does_not_match_properties_with_different_base_names()
{
DependentTypeWithCompositeKey.Property(DependentEntityWithCompositeKey.NavPropIdProperty, ConfigurationSource.Convention);
DependentTypeWithCompositeKey.Property(DependentEntityWithCompositeKey.PrincipalEntityWithCompositeKeyNameProperty, ConfigurationSource.Convention);
DependentTypeWithCompositeKey.Property(DependentEntityWithCompositeKey.IdProperty, ConfigurationSource.Convention);
var relationshipBuilder = DependentTypeWithCompositeKey.Relationship(
PrincipalTypeWithCompositeKey, "NavProp", null, ConfigurationSource.Convention);
relationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
var fk = relationshipBuilder.Metadata;
Assert.Same(fk, DependentTypeWithCompositeKey.Metadata.GetForeignKeys().Single());
Assert.Null(fk.GetForeignKeyPropertiesConfigurationSource());
Assert.Same(CompositePrimaryKey[0], fk.PrincipalKey.Properties[0]);
Assert.Same(CompositePrimaryKey[1], fk.PrincipalKey.Properties[1]);
}
public void Does_not_invert_if_both_entity_types_can_have_non_pk_fk_property()
{
DependentType.Property(DependentEntity.PeEKaYProperty, ConfigurationSource.Convention);
PrincipalType.Property(PrincipalEntity.DependentEntityKayPeeProperty, ConfigurationSource.Convention);
var relationshipBuilder = DependentType.Relationship(PrincipalType, ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.Same(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)newRelationshipBuilder.Metadata;
Assert.Same(DependentType.Metadata, fk.DeclaringEntityType);
Assert.Same(PrincipalType.Metadata.FindPrimaryKey(), fk.PrincipalKey);
Assert.True(fk.IsUnique);
Assert.False(fk.IsRequired);
}
public void Matches_Id_property()
{
var fkProperty = DependentType.Property(DependentEntity.IDProperty, ConfigurationSource.Convention).Metadata;
var relationshipBuilder = DependentType.Relationship(
PrincipalType,
"SomeNav",
null,
ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)DependentType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
}
public void Does_nothing_if_matching_shadow_property_added()
{
var relationshipBuilder = DependentType.Relationship(PrincipalType, "SomeNav", null, ConfigurationSource.Convention);
relationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
var fk = relationshipBuilder.Metadata;
Assert.Same(fk, DependentType.Metadata.GetForeignKeys().Single());
Assert.Null(fk.GetForeignKeyPropertiesConfigurationSource());
Assert.Equal("SomeNav" + PrimaryKey.Name, fk.Properties.Single().Name);
Assert.False(fk.IsUnique);
var property = DependentType.Property("SomeNavId", typeof(int?), ConfigurationSource.Convention);
Assert.Same(property, new ForeignKeyPropertyDiscoveryConvention().Apply(property));
Assert.Same(fk, DependentType.Metadata.GetForeignKeys().Single());
Assert.Equal("SomeNav" + PrimaryKey.Name, fk.Properties.Single().Name);
Assert.False(fk.IsUnique);
}
public void Throws_on_ambiguous_relationship()
{
DependentType.Property(DependentEntity.PrincipalEntityPeEKaYProperty, ConfigurationSource.Convention);
DependentType.Property(DependentEntity.PrincipalEntityIDProperty, ConfigurationSource.Convention);
DependentType.Property(DependentEntity.PeEKaYProperty, ConfigurationSource.Convention);
var relationshipBuilder = DependentType.Relationship(
PrincipalType,
"SomeNav",
null,
ConfigurationSource.Convention);
var convention = new ForeignKeyPropertyDiscoveryConvention();
var newRelationshipBuilder = convention.Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var otherRelationshipBuilder = DependentType.Relationship(
PrincipalType,
(string)null,
null,
ConfigurationSource.Convention);
var otherNewRelationshipBuilder = convention.Apply(otherRelationshipBuilder);
Assert.Same(otherRelationshipBuilder, otherNewRelationshipBuilder);
Assert.Equal(
CoreStrings.AmbiguousForeignKeyPropertyCandidates(
nameof(DependentEntity) + ".SomeNav",
nameof(PrincipalEntity),
nameof(DependentEntity),
nameof(PrincipalEntity),
"{'" + nameof(DependentEntity.PrincipalEntityPeEKaY) + "'}"),
Assert.Throws <InvalidOperationException>(() => convention.Apply(DependentType.Metadata.Model.Builder)).Message);
newRelationshipBuilder.Metadata.UpdateForeignKeyPropertiesConfigurationSource(ConfigurationSource.Explicit);
convention.Apply(DependentType.Metadata.Model.Builder);
}
public void Does_not_invert_if_dependent_entity_type_can_have_non_pk_fk_property()
{
var fkProperty = DependentType.Property(DependentEntity.PeEKaYProperty, ConfigurationSource.Convention).Metadata;
var relationshipBuilder = DependentType.Relationship(PrincipalType, ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.Same(DependentType.Metadata, newRelationshipBuilder.Metadata.DeclaringEntityType);
newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(newRelationshipBuilder);
var fk = (IForeignKey)DependentType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(DependentType.Metadata, fk.DeclaringEntityType);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
Assert.True(fk.IsUnique);
Assert.True(fk.IsRequired);
}
public void Sets_foreign_key_if_matching_non_shadow_property_added()
{
var relationshipBuilder = DependentType.Relationship(PrincipalType, "SomeNav", null, ConfigurationSource.Convention);
relationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
var fk = relationshipBuilder.Metadata;
Assert.Same(fk, DependentType.Metadata.GetForeignKeys().Single());
Assert.Null(fk.GetForeignKeyPropertiesConfigurationSource());
Assert.Equal("SomeNav" + PrimaryKey.Name, fk.Properties.Single().Name);
Assert.True(fk.Properties.Single().IsShadowProperty);
Assert.False(fk.IsUnique);
var property = DependentType.Property(DependentEntity.SomeNavIDProperty, ConfigurationSource.Convention);
Assert.Same(property, new ForeignKeyPropertyDiscoveryConvention().Apply(property));
var newFk = DependentType.Metadata.GetForeignKeys().Single();
Assert.NotSame(fk, newFk);
Assert.Equal(property.Metadata, newFk.Properties.Single());
}
public void Matches_dependent_PK_for_unique_FK_set_by_higher_source_than_convention()
{
var fkProperty = DependentType.Metadata.FindPrimaryKey().Properties.Single();
var relationshipBuilder = DependentType.Relationship(
PrincipalType,
"SomeNav",
"InverseReferenceNav",
ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.DataAnnotation)
.DependentEntityType(DependentType, ConfigurationSource.DataAnnotation);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)DependentType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
Assert.True(fk.IsUnique);
Assert.True(fk.IsRequired);
}
public void Does_not_invert_if_principal_entity_type_is_defining_the_dependent_entity_type()
{
PrincipalType.Property(nameof(PrincipalEntity.DependentEntityKayPee), ConfigurationSource.Convention);
PrincipalType.Metadata.Model.RemoveEntityType(typeof(DependentEntity));
var relationshipBuilder = PrincipalType.Owns(
typeof(DependentEntity), nameof(PrincipalEntity.InverseReferenceNav), ConfigurationSource.Convention);
var dependentTypeBuilder = relationshipBuilder.Metadata.DeclaringEntityType.Builder;
dependentTypeBuilder.PrimaryKey(new[] { nameof(DependentEntity.KayPee) }, ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.Same(dependentTypeBuilder.Metadata, newRelationshipBuilder.Metadata.DeclaringEntityType);
newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(newRelationshipBuilder);
var fk = (IForeignKey)dependentTypeBuilder.Metadata.GetForeignKeys().Single();
Assert.Same(dependentTypeBuilder.Metadata, fk.DeclaringEntityType);
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
Assert.True(fk.IsUnique);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual ConventionSet CreateConventionSet()
{
var conventionSet = new ConventionSet();
var propertyDiscoveryConvention = new PropertyDiscoveryConvention(Dependencies.TypeMapper);
var keyDiscoveryConvention = new KeyDiscoveryConvention();
var inversePropertyAttributeConvention = new InversePropertyAttributeConvention(Dependencies.TypeMapper);
var relationshipDiscoveryConvention = new RelationshipDiscoveryConvention(Dependencies.TypeMapper);
conventionSet.EntityTypeAddedConventions.Add(new NotMappedEntityTypeAttributeConvention());
conventionSet.EntityTypeAddedConventions.Add(new OwnedEntityTypeAttributeConvention());
conventionSet.EntityTypeAddedConventions.Add(new NotMappedMemberAttributeConvention());
conventionSet.EntityTypeAddedConventions.Add(new BaseTypeDiscoveryConvention());
conventionSet.EntityTypeAddedConventions.Add(propertyDiscoveryConvention);
conventionSet.EntityTypeAddedConventions.Add(keyDiscoveryConvention);
conventionSet.EntityTypeAddedConventions.Add(inversePropertyAttributeConvention);
conventionSet.EntityTypeAddedConventions.Add(relationshipDiscoveryConvention);
conventionSet.EntityTypeAddedConventions.Add(new DerivedTypeDiscoveryConvention());
conventionSet.EntityTypeIgnoredConventions.Add(inversePropertyAttributeConvention);
var foreignKeyIndexConvention = new ForeignKeyIndexConvention();
var valueGeneratorConvention = new ValueGeneratorConvention();
conventionSet.BaseEntityTypeChangedConventions.Add(propertyDiscoveryConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(keyDiscoveryConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(inversePropertyAttributeConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(relationshipDiscoveryConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(foreignKeyIndexConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(valueGeneratorConvention);
// An ambiguity might have been resolved
conventionSet.EntityTypeMemberIgnoredConventions.Add(inversePropertyAttributeConvention);
conventionSet.EntityTypeMemberIgnoredConventions.Add(relationshipDiscoveryConvention);
var keyAttributeConvention = new KeyAttributeConvention();
var foreignKeyPropertyDiscoveryConvention = new ForeignKeyPropertyDiscoveryConvention();
var backingFieldConvention = new BackingFieldConvention();
var concurrencyCheckAttributeConvention = new ConcurrencyCheckAttributeConvention();
var databaseGeneratedAttributeConvention = new DatabaseGeneratedAttributeConvention();
var requiredPropertyAttributeConvention = new RequiredPropertyAttributeConvention();
var maxLengthAttributeConvention = new MaxLengthAttributeConvention();
var stringLengthAttributeConvention = new StringLengthAttributeConvention();
var timestampAttributeConvention = new TimestampAttributeConvention();
conventionSet.PropertyAddedConventions.Add(backingFieldConvention);
conventionSet.PropertyAddedConventions.Add(concurrencyCheckAttributeConvention);
conventionSet.PropertyAddedConventions.Add(databaseGeneratedAttributeConvention);
conventionSet.PropertyAddedConventions.Add(requiredPropertyAttributeConvention);
conventionSet.PropertyAddedConventions.Add(maxLengthAttributeConvention);
conventionSet.PropertyAddedConventions.Add(stringLengthAttributeConvention);
conventionSet.PropertyAddedConventions.Add(timestampAttributeConvention);
conventionSet.PropertyAddedConventions.Add(keyDiscoveryConvention);
conventionSet.PropertyAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PropertyAddedConventions.Add(keyAttributeConvention);
conventionSet.PrimaryKeyChangedConventions.Add(valueGeneratorConvention);
conventionSet.KeyAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.KeyAddedConventions.Add(foreignKeyIndexConvention);
conventionSet.KeyRemovedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.KeyRemovedConventions.Add(foreignKeyIndexConvention);
conventionSet.KeyRemovedConventions.Add(keyDiscoveryConvention);
var cascadeDeleteConvention = new CascadeDeleteConvention();
conventionSet.ForeignKeyAddedConventions.Add(new ForeignKeyAttributeConvention(Dependencies.TypeMapper));
conventionSet.ForeignKeyAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.ForeignKeyAddedConventions.Add(keyDiscoveryConvention);
conventionSet.ForeignKeyAddedConventions.Add(valueGeneratorConvention);
conventionSet.ForeignKeyAddedConventions.Add(cascadeDeleteConvention);
conventionSet.ForeignKeyAddedConventions.Add(foreignKeyIndexConvention);
conventionSet.ForeignKeyRemovedConventions.Add(keyDiscoveryConvention);
conventionSet.ForeignKeyRemovedConventions.Add(valueGeneratorConvention);
conventionSet.ForeignKeyRemovedConventions.Add(foreignKeyIndexConvention);
conventionSet.ForeignKeyUniquenessChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.ForeignKeyUniquenessChangedConventions.Add(foreignKeyIndexConvention);
conventionSet.ForeignKeyOwnershipChangedConventions.Add(new NavigationEagerLoadingConvention());
conventionSet.ModelBuiltConventions.Add(new ModelCleanupConvention());
conventionSet.ModelBuiltConventions.Add(keyAttributeConvention);
conventionSet.ModelBuiltConventions.Add(new IgnoredMembersValidationConvention());
conventionSet.ModelBuiltConventions.Add(new PropertyMappingValidationConvention(Dependencies.TypeMapper));
conventionSet.ModelBuiltConventions.Add(new RelationshipValidationConvention());
conventionSet.ModelBuiltConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.ModelBuiltConventions.Add(new ChangeTrackingStrategyConvention());
conventionSet.ModelBuiltConventions.Add(new ConstructorBindingConvention(Dependencies.ConstructorBindingFactory));
conventionSet.NavigationAddedConventions.Add(backingFieldConvention);
conventionSet.NavigationAddedConventions.Add(new RequiredNavigationAttributeConvention());
conventionSet.NavigationAddedConventions.Add(inversePropertyAttributeConvention);
conventionSet.NavigationAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.NavigationAddedConventions.Add(relationshipDiscoveryConvention);
conventionSet.NavigationRemovedConventions.Add(relationshipDiscoveryConvention);
conventionSet.IndexAddedConventions.Add(foreignKeyIndexConvention);
conventionSet.IndexRemovedConventions.Add(foreignKeyIndexConvention);
conventionSet.IndexUniquenessChangedConventions.Add(foreignKeyIndexConvention);
conventionSet.PropertyNullabilityChangedConventions.Add(cascadeDeleteConvention);
conventionSet.PrincipalEndChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PropertyFieldChangedConventions.Add(keyDiscoveryConvention);
conventionSet.PropertyFieldChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PropertyFieldChangedConventions.Add(keyAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(concurrencyCheckAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(databaseGeneratedAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(requiredPropertyAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(maxLengthAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(stringLengthAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(timestampAttributeConvention);
return(conventionSet);
}
public void Matches_dependent_PK_for_unique_FK_set_by_higher_source_than_convention()
{
var fkProperty = DependentType.Metadata.FindPrimaryKey().Properties.Single();
var relationshipBuilder = DependentType.Relationship(
PrincipalType,
"SomeNav",
"InverseReferenceNav",
ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.DataAnnotation)
.DependentEntityType(DependentType, ConfigurationSource.DataAnnotation);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)DependentType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
Assert.True(fk.IsUnique);
Assert.True(fk.IsRequired);
}
public void Matches_composite_dependent_PK_for_unique_FK()
{
var fkProperty1 = DependentTypeWithCompositeKey.Metadata.FindPrimaryKey().Properties[0];
var fkProperty2 = DependentTypeWithCompositeKey.Metadata.FindPrimaryKey().Properties[1];
var relationshipBuilder = DependentTypeWithCompositeKey.Relationship(
PrincipalTypeWithCompositeKey,
"NavProp",
"InverseReferenceNav", ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.DataAnnotation)
.DependentEntityType(DependentTypeWithCompositeKey, ConfigurationSource.DataAnnotation);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)DependentTypeWithCompositeKey.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty1, fk.Properties[0]);
Assert.Same(fkProperty2, fk.Properties[1]);
Assert.Same(PrincipalTypeWithCompositeKey.Metadata.FindPrimaryKey(), fk.PrincipalKey);
Assert.True(fk.IsUnique);
Assert.True(fk.IsRequired);
}
public void Does_not_match_composite_dependent_PK_for_unique_FK_on_derived_type()
{
var modelBuilder = new InternalModelBuilder(new Model());
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 dependentTypeWithCompositeKeyBase = modelBuilder.Entity(typeof(DependentCompositeBase), ConfigurationSource.Explicit);
var dependentTypeWithCompositeKey = modelBuilder.Entity(typeof(DependentEntityWithCompositeKey), ConfigurationSource.Explicit);
dependentTypeWithCompositeKey.HasBaseType(dependentTypeWithCompositeKeyBase.Metadata, ConfigurationSource.Explicit);
dependentTypeWithCompositeKeyBase.PrimaryKey(new[] { nameof(DependentEntityWithCompositeKey.NotId), nameof(DependentEntityWithCompositeKey.NotName) }, ConfigurationSource.Explicit);
var relationshipBuilder = dependentTypeWithCompositeKey.Relationship(
principalTypeWithCompositeKey,
"NavProp",
"InverseReferenceNav", ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.DataAnnotation)
.DependentEntityType(dependentTypeWithCompositeKey, ConfigurationSource.DataAnnotation);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.Same(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)dependentTypeWithCompositeKey.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.NotEqual(dependentTypeWithCompositeKey.Metadata.FindPrimaryKey().Properties[0], fk.Properties[0]);
Assert.NotEqual(dependentTypeWithCompositeKey.Metadata.FindPrimaryKey().Properties[1], fk.Properties[1]);
Assert.Equal("NavProp" + CompositePrimaryKey[0].Name + "1", fk.Properties[0].Name);
Assert.Equal("NavProp" + CompositePrimaryKey[1].Name + "1", fk.Properties[1].Name);
Assert.Same(principalTypeWithCompositeKey.Metadata.FindPrimaryKey(), fk.PrincipalKey);
Assert.True(fk.IsUnique);
}
public void Does_not_invert_if_dependent_entity_type_can_have_non_pk_fk_property()
{
var fkProperty = DependentType.Property(DependentEntity.PeEKaYProperty, ConfigurationSource.Convention).Metadata;
var relationshipBuilder = DependentType.Relationship(PrincipalType, ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
Assert.Same(DependentType.Metadata, newRelationshipBuilder.Metadata.DeclaringEntityType);
newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(newRelationshipBuilder);
var fk = (IForeignKey)DependentType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
Assert.True(fk.IsUnique);
Assert.True(fk.IsRequired);
}
public void Does_not_invert_if_both_entity_types_can_have_non_pk_fk_property()
{
DependentType.Property(DependentEntity.PeEKaYProperty, ConfigurationSource.Convention);
PrincipalType.Property(PrincipalEntity.DependentEntityKayPeeProperty, ConfigurationSource.Convention);
var relationshipBuilder = DependentType.Relationship(PrincipalType, ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.Same(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)newRelationshipBuilder.Metadata;
Assert.Same(DependentType.Metadata, fk.DeclaringEntityType);
Assert.Same(PrincipalType.Metadata.FindPrimaryKey(), fk.PrincipalKey);
Assert.True(fk.IsUnique);
Assert.False(fk.IsRequired);
}
public void Matches_PK_name_properties()
{
var fkProperty1 = DependentTypeWithCompositeKey.Property(DependentEntityWithCompositeKey.IdProperty, ConfigurationSource.Convention);
var fkProperty2 = DependentTypeWithCompositeKey.Property(DependentEntityWithCompositeKey.NameProperty, ConfigurationSource.Convention);
fkProperty2.IsRequired(true, ConfigurationSource.Convention);
var relationshipBuilder = DependentTypeWithCompositeKey.Relationship(
PrincipalTypeWithCompositeKey,
"NavProp",
null,
ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)DependentTypeWithCompositeKey.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty1.Metadata, fk.Properties[0]);
Assert.Same(fkProperty2.Metadata, fk.Properties[1]);
Assert.Same(CompositePrimaryKey[0], fk.PrincipalKey.Properties[0]);
Assert.Same(CompositePrimaryKey[1], fk.PrincipalKey.Properties[1]);
}
// TODO: Issue #4440 For non-required FK, nullable property should be matched over any other
// [Fact]
public void Inverts_if_principal_entity_type_can_have_nullable_fk_property_for_non_required_relationship()
{
DependentType.Property(DependentEntity.PeEKaYProperty, ConfigurationSource.Convention);
var fkProperty = PrincipalType.Property(PrincipalEntity.DependentEntityKayPeeProperty, ConfigurationSource.Convention).Metadata;
var relationshipBuilder = DependentType.Relationship(PrincipalType, ConfigurationSource.Convention)
.IsUnique(true, ConfigurationSource.Convention)
.IsRequired(false, ConfigurationSource.DataAnnotation);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.Same(relationshipBuilder, newRelationshipBuilder);
Assert.Same(DependentType.Metadata, newRelationshipBuilder.Metadata.DeclaringEntityType);
var fk = (IForeignKey)PrincipalType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(DependentType.Metadata.FindPrimaryKey(), fk.PrincipalKey);
Assert.True(fk.IsUnique);
Assert.False(fk.IsRequired);
Assert.Empty(DependentType.Metadata.GetForeignKeys());
}
public void Matches_navigation_plus_PK_name_property()
{
var fkProperty = DependentType.Property(DependentEntity.SomeNavPeEKaYProperty, ConfigurationSource.Convention).Metadata;
DependentType.Property(DependentEntity.SomeNavIDProperty, ConfigurationSource.Convention);
DependentType.Property(DependentEntity.PrincipalEntityIDProperty, ConfigurationSource.Convention);
DependentType.Property(DependentEntity.PrincipalEntityPeEKaYProperty, ConfigurationSource.Convention);
DependentType.Property(DependentEntity.PeEKaYProperty, ConfigurationSource.Convention);
var relationshipBuilder = DependentType.Relationship(
PrincipalType,
"SomeNav",
null,
ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)DependentType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
Assert.False(fk.IsUnique);
Assert.True(fk.IsRequired);
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public virtual ConventionSet CreateConventionSet(DiagnosticsLoggers loggers)
{
var conventionSet = new ConventionSet();
var logger = loggers.GetLogger <DbLoggerCategory.Model>();
var propertyDiscoveryConvention
= new PropertyDiscoveryConvention(
Dependencies.TypeMappingSource, logger);
var keyDiscoveryConvention
= new KeyDiscoveryConvention(logger);
var inversePropertyAttributeConvention
= new InversePropertyAttributeConvention(Dependencies.MemberClassifier, logger);
var relationshipDiscoveryConvention
= new RelationshipDiscoveryConvention(Dependencies.MemberClassifier, logger);
var servicePropertyDiscoveryConvention
= new ServicePropertyDiscoveryConvention(Dependencies.TypeMappingSource, Dependencies.ParameterBindingFactories, logger);
conventionSet.EntityTypeAddedConventions.Add(new NotMappedEntityTypeAttributeConvention(logger));
conventionSet.EntityTypeAddedConventions.Add(new OwnedEntityTypeAttributeConvention(logger));
conventionSet.EntityTypeAddedConventions.Add(new NotMappedMemberAttributeConvention(logger));
conventionSet.EntityTypeAddedConventions.Add(new BaseTypeDiscoveryConvention(logger));
conventionSet.EntityTypeAddedConventions.Add(propertyDiscoveryConvention);
conventionSet.EntityTypeAddedConventions.Add(servicePropertyDiscoveryConvention);
conventionSet.EntityTypeAddedConventions.Add(keyDiscoveryConvention);
conventionSet.EntityTypeAddedConventions.Add(inversePropertyAttributeConvention);
conventionSet.EntityTypeAddedConventions.Add(relationshipDiscoveryConvention);
conventionSet.EntityTypeAddedConventions.Add(new DerivedTypeDiscoveryConvention(logger));
conventionSet.EntityTypeIgnoredConventions.Add(inversePropertyAttributeConvention);
conventionSet.EntityTypeRemovedConventions.Add(new OwnedTypesConvention(logger));
var foreignKeyIndexConvention = new ForeignKeyIndexConvention(logger);
var valueGeneratorConvention = new ValueGeneratorConvention(logger);
conventionSet.BaseEntityTypeChangedConventions.Add(propertyDiscoveryConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(servicePropertyDiscoveryConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(keyDiscoveryConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(inversePropertyAttributeConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(relationshipDiscoveryConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(foreignKeyIndexConvention);
conventionSet.BaseEntityTypeChangedConventions.Add(valueGeneratorConvention);
var foreignKeyPropertyDiscoveryConvention = new ForeignKeyPropertyDiscoveryConvention(logger);
conventionSet.EntityTypeMemberIgnoredConventions.Add(inversePropertyAttributeConvention);
conventionSet.EntityTypeMemberIgnoredConventions.Add(relationshipDiscoveryConvention);
conventionSet.EntityTypeMemberIgnoredConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.EntityTypeMemberIgnoredConventions.Add(servicePropertyDiscoveryConvention);
var keyAttributeConvention = new KeyAttributeConvention(logger);
var backingFieldConvention = new BackingFieldConvention(logger);
var concurrencyCheckAttributeConvention = new ConcurrencyCheckAttributeConvention(logger);
var databaseGeneratedAttributeConvention = new DatabaseGeneratedAttributeConvention(logger);
var requiredPropertyAttributeConvention = new RequiredPropertyAttributeConvention(logger);
var maxLengthAttributeConvention = new MaxLengthAttributeConvention(logger);
var stringLengthAttributeConvention = new StringLengthAttributeConvention(logger);
var timestampAttributeConvention = new TimestampAttributeConvention(logger);
conventionSet.PropertyAddedConventions.Add(backingFieldConvention);
conventionSet.PropertyAddedConventions.Add(concurrencyCheckAttributeConvention);
conventionSet.PropertyAddedConventions.Add(databaseGeneratedAttributeConvention);
conventionSet.PropertyAddedConventions.Add(requiredPropertyAttributeConvention);
conventionSet.PropertyAddedConventions.Add(maxLengthAttributeConvention);
conventionSet.PropertyAddedConventions.Add(stringLengthAttributeConvention);
conventionSet.PropertyAddedConventions.Add(timestampAttributeConvention);
conventionSet.PropertyAddedConventions.Add(keyAttributeConvention);
conventionSet.PropertyAddedConventions.Add(keyDiscoveryConvention);
conventionSet.PropertyAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PrimaryKeyChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PrimaryKeyChangedConventions.Add(valueGeneratorConvention);
conventionSet.KeyAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.KeyAddedConventions.Add(foreignKeyIndexConvention);
conventionSet.KeyRemovedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.KeyRemovedConventions.Add(foreignKeyIndexConvention);
conventionSet.KeyRemovedConventions.Add(keyDiscoveryConvention);
var cascadeDeleteConvention = new CascadeDeleteConvention(logger);
var foreignKeyAttributeConvention = new ForeignKeyAttributeConvention(Dependencies.MemberClassifier, logger);
conventionSet.ForeignKeyAddedConventions.Add(foreignKeyAttributeConvention);
conventionSet.ForeignKeyAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.ForeignKeyAddedConventions.Add(keyDiscoveryConvention);
conventionSet.ForeignKeyAddedConventions.Add(valueGeneratorConvention);
conventionSet.ForeignKeyAddedConventions.Add(cascadeDeleteConvention);
conventionSet.ForeignKeyAddedConventions.Add(foreignKeyIndexConvention);
conventionSet.ForeignKeyRemovedConventions.Add(keyDiscoveryConvention);
conventionSet.ForeignKeyRemovedConventions.Add(valueGeneratorConvention);
conventionSet.ForeignKeyRemovedConventions.Add(foreignKeyIndexConvention);
conventionSet.ForeignKeyUniquenessChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.ForeignKeyUniquenessChangedConventions.Add(keyDiscoveryConvention);
conventionSet.ForeignKeyUniquenessChangedConventions.Add(foreignKeyIndexConvention);
conventionSet.ForeignKeyRequirednessChangedConventions.Add(cascadeDeleteConvention);
conventionSet.ForeignKeyRequirednessChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.ForeignKeyOwnershipChangedConventions.Add(new NavigationEagerLoadingConvention(logger));
conventionSet.ForeignKeyOwnershipChangedConventions.Add(keyDiscoveryConvention);
conventionSet.ForeignKeyOwnershipChangedConventions.Add(relationshipDiscoveryConvention);
conventionSet.ModelBuiltConventions.Add(new ModelCleanupConvention(logger));
conventionSet.ModelBuiltConventions.Add(keyAttributeConvention);
conventionSet.ModelBuiltConventions.Add(foreignKeyAttributeConvention);
conventionSet.ModelBuiltConventions.Add(new ChangeTrackingStrategyConvention(logger));
conventionSet.ModelBuiltConventions.Add(new ConstructorBindingConvention(Dependencies.ConstructorBindingFactory, logger));
conventionSet.ModelBuiltConventions.Add(new TypeMappingConvention(Dependencies.TypeMappingSource, logger));
conventionSet.ModelBuiltConventions.Add(new IgnoredMembersValidationConvention(logger));
conventionSet.ModelBuiltConventions.Add(foreignKeyIndexConvention);
conventionSet.ModelBuiltConventions.Add(
new PropertyMappingValidationConvention(
Dependencies.TypeMappingSource,
Dependencies.MemberClassifier,
logger));
conventionSet.ModelBuiltConventions.Add(new RelationshipValidationConvention(logger));
conventionSet.ModelBuiltConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.ModelBuiltConventions.Add(servicePropertyDiscoveryConvention);
conventionSet.ModelBuiltConventions.Add(new CacheCleanupConvention(logger));
conventionSet.NavigationAddedConventions.Add(backingFieldConvention);
conventionSet.NavigationAddedConventions.Add(new RequiredNavigationAttributeConvention(logger));
conventionSet.NavigationAddedConventions.Add(inversePropertyAttributeConvention);
conventionSet.NavigationAddedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.NavigationAddedConventions.Add(relationshipDiscoveryConvention);
conventionSet.NavigationRemovedConventions.Add(relationshipDiscoveryConvention);
conventionSet.IndexAddedConventions.Add(foreignKeyIndexConvention);
conventionSet.IndexRemovedConventions.Add(foreignKeyIndexConvention);
conventionSet.IndexUniquenessChangedConventions.Add(foreignKeyIndexConvention);
conventionSet.PrincipalEndChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PropertyNullabilityChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PropertyFieldChangedConventions.Add(keyDiscoveryConvention);
conventionSet.PropertyFieldChangedConventions.Add(foreignKeyPropertyDiscoveryConvention);
conventionSet.PropertyFieldChangedConventions.Add(keyAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(concurrencyCheckAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(databaseGeneratedAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(requiredPropertyAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(maxLengthAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(stringLengthAttributeConvention);
conventionSet.PropertyFieldChangedConventions.Add(timestampAttributeConvention);
return(conventionSet);
}
public void Matches_Id_property()
{
var fkProperty = DependentType.Property(DependentEntity.IDProperty, ConfigurationSource.Convention).Metadata;
var relationshipBuilder = DependentType.Relationship(
PrincipalType,
"SomeNav",
null,
ConfigurationSource.Convention);
var newRelationshipBuilder = new ForeignKeyPropertyDiscoveryConvention().Apply(relationshipBuilder);
Assert.NotSame(relationshipBuilder, newRelationshipBuilder);
var fk = (IForeignKey)DependentType.Metadata.GetForeignKeys().Single();
Assert.Same(fk, newRelationshipBuilder.Metadata);
Assert.Same(fkProperty, fk.Properties.Single());
Assert.Same(PrimaryKey, fk.PrincipalKey.Properties.Single());
}
