public void Constructor_throws_when_principal_and_depedent_property_count_do_not_match()
{
var dependentType = new Model().AddEntityType("D");
var principalType = new Model().AddEntityType("P");
var dependentProperty1 = dependentType.AddProperty("P1", typeof(int));
var dependentProperty2 = dependentType.AddProperty("P2", typeof(int));
var idProperty = principalType.AddProperty("Id", typeof(int));
principalType.GetOrSetPrimaryKey(idProperty);
Assert.Equal(
CoreStrings.ForeignKeyCountMismatch("{'P1', 'P2'}", "D", "{'Id'}", "P"),
Assert.Throws<InvalidOperationException>(
() => new ForeignKey(new[] { dependentProperty1, dependentProperty2 }, principalType.FindPrimaryKey(), dependentType, principalType)).Message);
}
public void Can_create_foreign_key()
{
var entityType = new Model().AddEntityType("E");
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(principalProp);
var foreignKey
= new ForeignKey(new[] { dependentProp }, entityType.FindPrimaryKey(), entityType, entityType)
{
IsUnique = true
};
Assert.Same(entityType, foreignKey.PrincipalEntityType);
Assert.Same(principalProp, foreignKey.PrincipalKey.Properties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.True(foreignKey.IsUnique.Value);
Assert.Same(entityType.FindPrimaryKey(), foreignKey.PrincipalKey);
}
public void IsRequired_false_for_composite_FK_by_default()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.FindPrimaryKey(), entityType, entityType);
Assert.Null(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
}
public void Can_create_foreign_key()
{
var entityType = new Model().AddEntityType("E");
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(principalProp);
var foreignKey
= new ForeignKey(new[] { dependentProp }, entityType.FindPrimaryKey(), entityType, entityType)
{
IsUnique = true
};
Assert.Same(entityType, foreignKey.PrincipalEntityType);
Assert.Same(principalProp, foreignKey.PrincipalKey.Properties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.True(foreignKey.IsUnique.Value);
Assert.Same(entityType.FindPrimaryKey(), foreignKey.PrincipalKey);
}
public void Can_create_foreign_key_with_non_pk_principal()
{
var entityType = new Model().AddEntityType("E");
var keyProp = entityType.AddProperty("Id", typeof(int));
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("U", typeof(int));
entityType.GetOrSetPrimaryKey(keyProp);
var principalKey = entityType.AddKey(principalProp);
var foreignKey = entityType.AddForeignKey(new[] { dependentProp }, principalKey, entityType);
foreignKey.IsUnique = false;
Assert.Same(entityType, foreignKey.PrincipalEntityType);
Assert.Same(principalProp, foreignKey.PrincipalKey.Properties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.False(foreignKey.IsUnique);
Assert.Same(principalKey, foreignKey.PrincipalKey);
}
public void Can_change_cascade_delete_flag()
{
var entityType = new Model().AddEntityType("E");
var keyProp = entityType.AddProperty("Id", typeof(int));
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("U", typeof(int));
entityType.GetOrSetPrimaryKey(keyProp);
var principalKey = entityType.AddKey(principalProp);
var foreignKey = entityType.AddForeignKey(new[] { dependentProp }, principalKey, entityType);
Assert.Equal(DeleteBehavior.Restrict, foreignKey.DeleteBehavior);
foreignKey.DeleteBehavior = DeleteBehavior.Cascade;
Assert.Equal(DeleteBehavior.Cascade, foreignKey.DeleteBehavior);
foreignKey.DeleteBehavior = DeleteBehavior.Restrict;
Assert.Equal(DeleteBehavior.Restrict, foreignKey.DeleteBehavior);
}
public void Constructor_throws_when_principal_and_depedent_property_types_do_not_match()
{
var dependentType = new Model().AddEntityType("D");
var principalType = new Model().AddEntityType("P");
var dependentProperty1 = dependentType.AddProperty("P1", typeof(int));
var dependentProperty2 = dependentType.AddProperty("P2", typeof(string));
var property2 = principalType.AddProperty("Id1", typeof(int));
var property3 = principalType.AddProperty("Id2", typeof(int));
principalType.GetOrSetPrimaryKey(new[]
{
property2,
property3
});
Assert.Equal(
CoreStrings.ForeignKeyTypeMismatch("{'P1', 'P2'}", "D", "{'Id1', 'Id2'}", "P"),
Assert.Throws <InvalidOperationException>(
() => new ForeignKey(new[] { dependentProperty1, dependentProperty2 }, principalType.FindPrimaryKey(), dependentType, principalType)).Message);
}
public void Can_create_foreign_key()
{
var entityType = new Model().AddEntityType("E");
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(principalProp);
var foreignKey = entityType.AddForeignKey(new[] { dependentProp }, entityType.FindPrimaryKey(), entityType, ConfigurationSource.Convention);
foreignKey.IsUnique = true;
Assert.Same(entityType, foreignKey.PrincipalEntityType);
Assert.Same(principalProp, foreignKey.PrincipalKey.Properties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.True(foreignKey.IsUnique);
Assert.Same(entityType.FindPrimaryKey(), foreignKey.PrincipalKey);
Assert.Equal(ConfigurationSource.Convention, foreignKey.GetConfigurationSource());
foreignKey.UpdateConfigurationSource(ConfigurationSource.DataAnnotation);
Assert.Equal(ConfigurationSource.DataAnnotation, foreignKey.GetConfigurationSource());
}
public void Setting_IsRequired_to_false_will_set_all_FK_properties_as_nullable()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int?));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.FindPrimaryKey(), entityType, entityType)
{
IsRequired = false
};
Assert.False(foreignKey.IsRequired.Value);
Assert.True(dependentProp1.IsNullable.Value);
Assert.True(dependentProp2.IsNullable.Value);
}
public void Can_create_foreign_key_with_non_pk_principal()
{
var entityType = new Model().AddEntityType("E");
var keyProp = entityType.AddProperty("Id", typeof(int));
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("U", typeof(int));
entityType.GetOrSetPrimaryKey(keyProp);
var principalKey = entityType.AddKey(principalProp);
var foreignKey
= new ForeignKey(new[] { dependentProp }, principalKey, entityType, entityType)
{
IsUnique = false
};
Assert.Same(entityType, foreignKey.PrincipalEntityType);
Assert.Same(principalProp, foreignKey.PrincipalKey.Properties.Single());
Assert.Same(dependentProp, foreignKey.Properties.Single());
Assert.False(foreignKey.IsUnique.Value);
Assert.Same(principalKey, foreignKey.PrincipalKey);
}
private ForeignKey CreateSelfRefFK(bool useAltKey = false)
{
var entityType = new Model().AddEntityType(typeof(SelfRef));
var pk = entityType.GetOrSetPrimaryKey(entityType.AddProperty(SelfRef.IdProperty));
var fkProp = entityType.AddProperty(SelfRef.SelfRefIdProperty);
var property = entityType.AddProperty("AltId", typeof(int));
var principalKey = useAltKey
? entityType.GetOrAddKey(property)
: pk;
var fk = entityType.AddForeignKey(new[] { fkProp }, principalKey, entityType);
fk.IsUnique = true;
fk.HasDependentToPrincipal("SelfRefPrincipal");
fk.HasPrincipalToDependent("SelfRefDependent");
return fk;
}
public void Setting_IsRequired_to_false_will_set_all_FK_properties_as_nullable()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int?));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.FindPrimaryKey(), entityType, entityType) { IsRequired = false };
Assert.False(foreignKey.IsRequired.Value);
Assert.True(dependentProp1.IsNullable.Value);
Assert.True(dependentProp2.IsNullable.Value);
}
public void IsRequired_false_when_any_part_of_composite_FK_is_nullable()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
dependentProp2.IsNullable = true;
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.FindPrimaryKey(), entityType, entityType);
Assert.False(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
dependentProp2.IsNullable = false;
Assert.True(foreignKey.IsRequired);
Assert.True(((IForeignKey)foreignKey).IsRequired);
}
public void IsRequired_false_for_composite_FK_by_default()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id1", typeof(int));
var property1 = entityType.AddProperty("Id2", typeof(string));
entityType.GetOrSetPrimaryKey(new[]
{
property,
property1
});
var dependentProp1 = entityType.AddProperty("P1", typeof(int));
var dependentProp2 = entityType.AddProperty("P2", typeof(string));
var foreignKey = new ForeignKey(new[] { dependentProp1, dependentProp2 }, entityType.FindPrimaryKey(), entityType, entityType);
Assert.Null(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
}
public void IsRequired_and_IsUnique_null_when_dependent_property_nullable_by_default()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(property);
var dependentProp = entityType.AddProperty("P", typeof(int?));
var foreignKey = new ForeignKey(new[] { dependentProp }, entityType.FindPrimaryKey(), entityType, entityType);
Assert.Null(foreignKey.IsRequired);
Assert.False(((IForeignKey)foreignKey).IsRequired);
Assert.Null(foreignKey.IsUnique);
Assert.False(((IForeignKey)foreignKey).IsUnique);
}
public void Can_change_cascade_delete_flag()
{
var entityType = new Model().AddEntityType("E");
var keyProp = entityType.AddProperty("Id", typeof(int));
var dependentProp = entityType.AddProperty("P", typeof(int));
var principalProp = entityType.AddProperty("U", typeof(int));
entityType.GetOrSetPrimaryKey(keyProp);
var principalKey = entityType.AddKey(principalProp);
var foreignKey
= new ForeignKey(new[] { dependentProp }, principalKey, entityType, entityType);
Assert.Null(foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.Restrict, ((IForeignKey)foreignKey).DeleteBehavior);
foreignKey.DeleteBehavior = DeleteBehavior.Cascade;
Assert.Equal(DeleteBehavior.Cascade, foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.Cascade, ((IForeignKey)foreignKey).DeleteBehavior);
foreignKey.DeleteBehavior = DeleteBehavior.Restrict;
Assert.Equal(DeleteBehavior.Restrict, foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.Restrict, ((IForeignKey)foreignKey).DeleteBehavior);
foreignKey.DeleteBehavior = null;
Assert.Null(foreignKey.DeleteBehavior);
Assert.Equal(DeleteBehavior.Restrict, ((IForeignKey)foreignKey).DeleteBehavior);
}
public void IsRequired_true_when_dependent_property_not_nullable()
{
var entityType = new Model().AddEntityType("E");
var property = entityType.AddProperty("Id", typeof(int));
entityType.GetOrSetPrimaryKey(property);
var dependentProp = entityType.AddProperty("P", typeof(int));
dependentProp.IsNullable = false;
var foreignKey = new ForeignKey(new[] { dependentProp }, entityType.FindPrimaryKey(), entityType, entityType);
Assert.True(foreignKey.IsRequired);
Assert.True(((IForeignKey)foreignKey).IsRequired);
}