public void HasColumnOrder_should_throw_when_argument_out_of_range()
{
var configuration = new PrimitivePropertyConfiguration<PrimitivePropertyConfiguration>(new PrimitivePropertyConfiguration());
Assert.Equal(
new ArgumentOutOfRangeException("columnOrder").Message,
Assert.Throws<ArgumentOutOfRangeException>(() => configuration.HasColumnOrder(-1)).Message);
}
public void Apply_should_ignore_attribute_if_already_set()
{
var propertyConfiguration = new PrimitivePropertyConfiguration { DatabaseGeneratedOption = DatabaseGeneratedOption.Computed };
new DatabaseGeneratedAttributeConvention.DatabaseGeneratedAttributeConventionImpl()
.Apply(new MockPropertyInfo(), propertyConfiguration, new DatabaseGeneratedAttribute(DatabaseGeneratedOption.None));
Assert.Equal(DatabaseGeneratedOption.Computed, propertyConfiguration.DatabaseGeneratedOption);
}
public void Apply_should_set_store_generated_pattern()
{
var propertyConfiguration = new PrimitivePropertyConfiguration();
new DatabaseGeneratedAttributeConvention()
.Apply(new MockPropertyInfo(), propertyConfiguration, new DatabaseGeneratedAttribute(DatabaseGeneratedOption.None));
Assert.Equal(DatabaseGeneratedOption.None, propertyConfiguration.DatabaseGeneratedOption);
}
internal override void CopyFrom(PrimitivePropertyConfiguration other)
{
base.CopyFrom(other);
var strConfigRhs = other as DateTimePropertyConfiguration;
if (strConfigRhs != null)
{
Precision = strConfigRhs.Precision;
}
}
internal override void CopyFrom(PrimitivePropertyConfiguration other)
{
base.CopyFrom(other);
var strConfigRhs = other as StringPropertyConfiguration;
if (strConfigRhs != null)
{
IsUnicode = strConfigRhs.IsUnicode;
}
}
public void HasDatabaseGeneratedOption_should_throw_when_argument_out_of_range()
{
var configuration = new PrimitivePropertyConfiguration<PrimitivePropertyConfiguration>(new PrimitivePropertyConfiguration());
Assert.Equal(
new ArgumentOutOfRangeException("databaseGeneratedOption").Message,
Assert.Throws<ArgumentOutOfRangeException>(() => configuration.HasDatabaseGeneratedOption((DatabaseGeneratedOption?)(-1))).
Message);
}
internal override void CopyFrom(PrimitivePropertyConfiguration other)
{
base.CopyFrom(other);
var strConfigRhs = other as BinaryPropertyConfiguration;
if (strConfigRhs != null)
{
IsRowVersion = strConfigRhs.IsRowVersion;
}
}
public void Apply_should_not_set_column_name_when_already_set()
{
var propertyConfiguration = new PrimitivePropertyConfiguration { ColumnName = "Bar" };
new ColumnAttributeConvention.ColumnAttributeConventionImpl()
.Apply(new MockPropertyInfo(), propertyConfiguration, new ColumnAttribute("Foo"));
Assert.Equal("Bar", propertyConfiguration.ColumnName);
}
public void Apply_should_set_concurrency_token()
{
var propertyConfiguration = new PrimitivePropertyConfiguration();
new ConcurrencyCheckAttributeConvention.ConcurrencyCheckAttributeConventionImpl()
.Apply(new MockPropertyInfo(), propertyConfiguration, new ConcurrencyCheckAttribute());
Assert.Equal(EdmConcurrencyMode.Fixed, propertyConfiguration.ConcurrencyMode);
}
public void Apply_should_set_column_name()
{
var propertyConfiguration = new PrimitivePropertyConfiguration();
new ColumnAttributeConvention.ColumnAttributeConventionImpl()
.Apply(new MockPropertyInfo(), propertyConfiguration, new ColumnAttribute("Foo"));
Assert.Equal("Foo", propertyConfiguration.ColumnName);
}
public void Apply_should_ignore_attribute_if_already_set()
{
var propertyConfiguration = new PrimitivePropertyConfiguration { ConcurrencyMode = EdmConcurrencyMode.None };
new ConcurrencyCheckAttributeConvention.ConcurrencyCheckAttributeConventionImpl()
.Apply(new MockPropertyInfo(), propertyConfiguration, new ConcurrencyCheckAttribute());
Assert.Equal(EdmConcurrencyMode.None, propertyConfiguration.ConcurrencyMode);
}
public override void FillFrom(PrimitivePropertyConfiguration other, bool inCSpace)
{
base.FillFrom(other, inCSpace);
var strConfigRhs = other as BinaryPropertyConfiguration;
if (strConfigRhs != null
&& IsRowVersion == null)
{
IsRowVersion = strConfigRhs.IsRowVersion;
}
}
public void HasParameterName_configures_when_unset()
{
var innerConfig = new PrimitivePropertyConfiguration();
var config = new LightweightPropertyConfiguration(new MockPropertyInfo(), () => innerConfig);
var result = config.HasParameterName("Parameter1");
Assert.Equal("Parameter1", innerConfig.ParameterName);
Assert.Same(config, result);
}
internal override void CopyFrom(PrimitivePropertyConfiguration other)
{
base.CopyFrom(other);
var lenConfigRhs = other as DecimalPropertyConfiguration;
if (lenConfigRhs != null)
{
Precision = lenConfigRhs.Precision;
Scale = lenConfigRhs.Scale;
}
}
internal override bool IsCompatible(PrimitivePropertyConfiguration other, bool inCSpace, out string errorMessage)
{
var dateRhs = other as DateTimePropertyConfiguration;
var baseIsCompatible = base.IsCompatible(other, inCSpace, out errorMessage);
var precisionIsCompatible = dateRhs == null || IsCompatible(c => c.Precision, dateRhs, ref errorMessage);
return baseIsCompatible &&
precisionIsCompatible;
}
internal override void FillFrom(PrimitivePropertyConfiguration other, bool inCSpace)
{
base.FillFrom(other, inCSpace);
var strConfigRhs = other as DateTimePropertyConfiguration;
if (strConfigRhs != null
&& Precision == null)
{
Precision = strConfigRhs.Precision;
}
}
internal override bool IsCompatible(PrimitivePropertyConfiguration other, bool inCSpace, out string errorMessage)
{
var stringRhs = other as StringPropertyConfiguration;
var baseIsCompatible = base.IsCompatible(other, inCSpace, out errorMessage);
var isUnicodeIsCompatible = stringRhs == null || IsCompatible(c => c.IsUnicode, stringRhs, ref errorMessage);
return baseIsCompatible &&
isUnicodeIsCompatible;
}
internal override void FillFrom(PrimitivePropertyConfiguration other, bool inCSpace)
{
base.FillFrom(other, inCSpace);
var strConfigRhs = other as StringPropertyConfiguration;
if (strConfigRhs != null
&& IsUnicode == null)
{
IsUnicode = strConfigRhs.IsUnicode;
}
}
public void HasParameterName_should_set_name_on_inner_configuration()
{
var innerConfiguration = CreateConfiguration();
var primitivePropertyConfiguration
= new PrimitivePropertyConfiguration<PrimitivePropertyConfiguration>(innerConfiguration);
primitivePropertyConfiguration.HasParameterName("Foo");
Assert.Equal("Foo", innerConfiguration.ParameterName);
}
internal override void MakeCompatibleWith(PrimitivePropertyConfiguration other, bool inCSpace)
{
DebugCheck.NotNull(other);
base.MakeCompatibleWith(other, inCSpace);
var stringPropertyConfiguration = other as StringPropertyConfiguration;
if (stringPropertyConfiguration == null) return;
if (stringPropertyConfiguration.IsUnicode != null) IsUnicode = null;
}
internal override void CopyFrom(PrimitivePropertyConfiguration other)
{
base.CopyFrom(other);
var lenConfigRhs = other as LengthPropertyConfiguration;
if (lenConfigRhs != null)
{
IsFixedLength = lenConfigRhs.IsFixedLength;
MaxLength = lenConfigRhs.MaxLength;
IsMaxLength = lenConfigRhs.IsMaxLength;
}
}
internal override void MakeCompatibleWith(PrimitivePropertyConfiguration other, bool inCSpace)
{
DebugCheck.NotNull(other);
base.MakeCompatibleWith(other, inCSpace);
var dateTimePropertyConfiguration = other as DateTimePropertyConfiguration;
if (dateTimePropertyConfiguration == null) return;
if (dateTimePropertyConfiguration.Precision != null) Precision = null;
}
public void Apply_invokes_action_when_no_predicates()
{
var actionInvoked = false;
var convention = new PropertyConvention(
Enumerable.Empty<Func<PropertyInfo, bool>>(),
c => actionInvoked = true);
var propertyInfo = new MockPropertyInfo();
var configuration = new PrimitivePropertyConfiguration();
convention.Apply(propertyInfo, () => configuration);
Assert.True(actionInvoked);
}
public void Apply_does_not_invoke_action_when_single_predicate_false()
{
var actionInvoked = false;
var convention = new PropertyConvention(
new Func<PropertyInfo, bool>[] { p => false },
c => actionInvoked = true);
var propertyInfo = new MockPropertyInfo();
var configuration = new PrimitivePropertyConfiguration();
convention.Apply(propertyInfo, () => configuration);
Assert.False(actionInvoked);
}
public static void ColumnName_is_set_on_internal_configuration()
{
var primitivePropertyConfiguration = new PrimitivePropertyConfiguration();
primitivePropertyConfiguration.ColumnName = "A";
Assert.Equal("A", primitivePropertyConfiguration.ColumnName);
var propertyMappingConfiguration =
new PropertyMappingConfiguration(primitivePropertyConfiguration);
propertyMappingConfiguration.HasColumnName("B");
Assert.Equal("B", primitivePropertyConfiguration.ColumnName);
}
public void HasColumnName_is_noop_when_set()
{
var innerConfig = new PrimitivePropertyConfiguration
{
ColumnName = "Column1"
};
var config = new LightweightPropertyConfiguration(new MockPropertyInfo(), () => innerConfig);
var result = config.HasColumnName("Column2");
Assert.Equal("Column1", innerConfig.ColumnName);
Assert.Same(config, result);
}
public void Apply_does_not_invoke_action_when_value_null()
{
var actionInvoked = false;
var convention = new PropertyConventionWithHaving<object>(
Enumerable.Empty<Func<PropertyInfo, bool>>(),
p => null,
(c, v) => actionInvoked = true);
var propertyInfo = new MockPropertyInfo();
var configuration = new PrimitivePropertyConfiguration();
convention.Apply(propertyInfo, () => configuration);
Assert.False(actionInvoked);
}
public void TimestampConvention_AppliesWhenTheAttributeIsAppliedToASingleProperty()
{
// Arrange
PropertyInfo property = CreateMockPropertyInfo("TestProperty");
EntityTypeConfiguration entityType = new EntityTypeConfiguration();
PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType);
entityType.ExplicitProperties.Add(property, primitiveProperty);
TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention();
// Act
convention.Apply(primitiveProperty, entityType);
// Assert
Assert.True(primitiveProperty.ConcurrencyToken);
}
public void TimestampConvention_DoesntApplyWhenTheAttributeIsAppliedOnANonEntityType()
{
// Arrange
PropertyInfo property = CreateMockPropertyInfo("TestProperty");
ComplexTypeConfiguration complexType = new ComplexTypeConfiguration();
PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, complexType);
complexType.ExplicitProperties.Add(property, primitiveProperty);
TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention();
// Act
convention.Apply(primitiveProperty, complexType);
// Assert
Assert.False(primitiveProperty.ConcurrencyToken);
}
public void AsTimeOfDay_Works()
{
// Arrange
MockType type = new MockType().Property(typeof(TimeSpan), "CreatedTime");
PropertyInfo property = type.GetProperty("CreatedTime");
_structuralType.Setup(t => t.ClrType).Returns(type);
// Act
PrimitivePropertyConfiguration propertyConfig = new PrimitivePropertyConfiguration(property, _structuralType.Object);
EdmPrimitiveTypeKind? typeKind = propertyConfig.AsTimeOfDay().TargetEdmTypeKind;
// Assert
Assert.NotNull(typeKind);
Assert.Equal(EdmPrimitiveTypeKind.TimeOfDay, typeKind);
}
private static IndexAnnotation GetIndexAnnotation(PrimitivePropertyConfiguration propertyConfiguration)
{
var configuration = typeof (PrimitivePropertyConfiguration)
.GetProperty("Configuration", BindingFlags.Instance | BindingFlags.NonPublic)
.GetValue(propertyConfiguration, null);
var annotations = (IDictionary<string, object>) configuration.GetType()
.GetProperty("Annotations", BindingFlags.Instance | BindingFlags.Public)
.GetValue(configuration, null);
object annotation;
if (!annotations.TryGetValue(IndexAnnotation.AnnotationName, out annotation))
return null;
return annotation as IndexAnnotation;
}
public void AsDate_Works()
{
// Arrange
MockType type = new MockType().Property(typeof(DateTime), "Birthday");
PropertyInfo property = type.GetProperty("Birthday");
_structuralType.Setup(t => t.ClrType).Returns(type);
// Act
PrimitivePropertyConfiguration propertyConfig = new PrimitivePropertyConfiguration(property, _structuralType.Object);
EdmPrimitiveTypeKind? typeKind = propertyConfig.AsDate().TargetEdmTypeKind;
// Assert
Assert.NotNull(typeKind);
Assert.Equal(EdmPrimitiveTypeKind.Date, typeKind);
}
public void TimestampConvention_AppliesWhenTheAttributeIsAppliedToASingleProperty()
{
// Arrange
PropertyInfo property = CreateMockPropertyInfo("TestProperty");
EntityTypeConfiguration entityType = new EntityTypeConfiguration();
PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType);
entityType.ExplicitProperties.Add(property, primitiveProperty);
TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention();
// Act
convention.Apply(primitiveProperty, entityType, ODataConventionModelBuilderFactory.Create());
// Assert
Assert.True(primitiveProperty.ConcurrencyToken);
}
public void RemoveKey_Removes_KeyProperty()
{
// Arrange
var builder = new ODataModelBuilder();
var motorcycle = builder.AddEntityType(typeof(Motorcycle));
PrimitivePropertyConfiguration modelProperty = motorcycle.AddProperty(typeof(Motorcycle).GetProperty("Model"));
motorcycle.HasKey(typeof(Motorcycle).GetProperty("Model"));
Assert.Equal(new[] { modelProperty }, motorcycle.Keys);
// Act
motorcycle.RemoveKey(modelProperty);
// Assert
Assert.Empty(motorcycle.Keys);
}
public void Property_IsNotNavigable_SetsNotSortableAndNotFilterable()
{
// Arrange
StructuralTypeConfiguration structuralType = Mock.Of <StructuralTypeConfiguration>();
Mock <PropertyInfo> propertyInfo = new Mock <PropertyInfo>();
propertyInfo.SetupGet(p => p.PropertyType).Returns(typeof(int));
PropertyConfiguration property = new PrimitivePropertyConfiguration(propertyInfo.Object, structuralType);
// Act
property.IsNotNavigable();
// Assert
Assert.True(property.NotFilterable);
Assert.True(property.NotSortable);
}
public void TimestampConvention_DoesntApplyWhenTheAttributeIsAppliedOnANonEntityType()
{
// Arrange
PropertyInfo property = CreateMockPropertyInfo("TestProperty");
ComplexTypeConfiguration complexType = new ComplexTypeConfiguration();
PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, complexType);
complexType.ExplicitProperties.Add(property, primitiveProperty);
TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention();
// Act
convention.Apply(primitiveProperty, complexType, ODataConventionModelBuilderFactory.Create());
// Assert
Assert.False(primitiveProperty.ConcurrencyToken);
}
public override void FillFrom(PrimitivePropertyConfiguration other, bool inCSpace)
{
base.FillFrom(other, inCSpace);
var lenConfigRhs = other as DecimalPropertyConfiguration;
if (lenConfigRhs != null)
{
if (Precision == null)
{
Precision = lenConfigRhs.Precision;
}
if (Scale == null)
{
Scale = lenConfigRhs.Scale;
}
}
}
private static void ApplyNavigation(NavigationPropertyConfiguration navProperty, EntityTypeConfiguration entityType,
ForeignKeyAttribute foreignKeyAttribute)
{
Contract.Assert(navProperty != null);
Contract.Assert(entityType != null);
Contract.Assert(foreignKeyAttribute != null);
if (navProperty.AddedExplicitly || navProperty.Multiplicity == EdmMultiplicity.Many)
{
return;
}
EntityTypeConfiguration principalEntity = entityType.ModelBuilder.StructuralTypes
.OfType <EntityTypeConfiguration>().FirstOrDefault(e => e.ClrType == navProperty.RelatedClrType);
if (principalEntity == null)
{
return;
}
// if a navigation property has multiple foreign keys, use comma to separate the list of foreign key names.
IEnumerable <string> dependentPropertyNames = foreignKeyAttribute.Name.Split(',').Select(p => p.Trim());
foreach (string dependentPropertyName in dependentPropertyNames)
{
if (String.IsNullOrWhiteSpace(dependentPropertyName))
{
continue;
}
PrimitivePropertyConfiguration dependent =
entityType.Properties.OfType <PrimitivePropertyConfiguration>()
.SingleOrDefault(p => p.Name.Equals(dependentPropertyName, StringComparison.Ordinal));
if (dependent != null)
{
Type dependentType = Nullable.GetUnderlyingType(dependent.PropertyInfo.PropertyType) ?? dependent.PropertyInfo.PropertyType;
PrimitivePropertyConfiguration principal = principalEntity.Keys.FirstOrDefault(
k => k.PropertyInfo.PropertyType == dependentType && navProperty.PrincipalProperties.All(p => p != k.PropertyInfo));
if (principal != null)
{
navProperty.HasConstraint(dependent.PropertyInfo, principal.PropertyInfo);
}
}
}
}
public void Apply_does_not_invoke_action_when_last_predicate_false()
{
var actionInvoked = false;
var convention = new PropertyConvention(
new Func <PropertyInfo, bool>[]
{
p => true,
p => false
},
c => actionInvoked = true);
var propertyInfo = new MockPropertyInfo();
var configuration = new PrimitivePropertyConfiguration();
convention.Apply(propertyInfo, () => configuration);
Assert.False(actionInvoked);
}
public static PrimitivePropertyConfiguration PrivateProperty <T, U>(
this EntityTypeConfiguration <T> mapper,
Expression <Func <T, U?> > exp,
NamingConventions?convention = null)
where T : class
where U : struct
{
mapper.Ignore(exp);
dynamic expression = exp;
string defaultColumnName;
ExpressionModifier.ToPrivate(ref expression, convention, out defaultColumnName);
PrimitivePropertyConfiguration configuration = mapper.Property(expression);
configuration.HasColumnName(defaultColumnName);
return(configuration);
}
public void TimestampConvention_DoesntApplyWhenTheAttributeIsAppliedToMultipleProperties()
{
// Arrange
PropertyInfo property = CreateMockPropertyInfo("TestProperty");
PropertyInfo otherProperty = CreateMockPropertyInfo("OtherTestProperty");
EntityTypeConfiguration entityType = new EntityTypeConfiguration();
PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType);
entityType.ExplicitProperties.Add(property, primitiveProperty);
entityType.ExplicitProperties.Add(otherProperty, new PrimitivePropertyConfiguration(otherProperty, entityType));
TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention();
// Act
convention.Apply(primitiveProperty, entityType, new ODataConventionModelBuilder());
// Assert
Assert.False(primitiveProperty.ConcurrencyToken);
}
public void Convert(Metadata data, PrimitivePropertyConfiguration configuration)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
Configuration = configuration;
ConvertToConfiguration(data);
if (adapter != null)
{
adapter.Convert(data, configuration);
}
}
/// <summary>
/// Marks the property with concurrency token on the EDM type.
/// </summary>
/// <param name="edmProperty">The EDM property.</param>
/// <param name="structuralTypeConfiguration">The EDM type being configured.</param>
/// <param name="attribute">The <see cref="Attribute"/> found.</param>
/// <param name="model">The ODataConventionModelBuilder used to build the model.</param>
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration,
Attribute attribute,
ODataConventionModelBuilder model)
{
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
EntityTypeConfiguration entityType = structuralTypeConfiguration as EntityTypeConfiguration;
PrimitivePropertyConfiguration primitiveProperty = edmProperty as PrimitivePropertyConfiguration;
if (entityType != null && primitiveProperty != null)
{
primitiveProperty.ConcurrencyToken = true;
}
}
public void CanAddPrimitiveProperty_ForTargetEntityType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
// Act
builder.EntityType <ForeignEntity>().HasRequired(c => c.Principal, (c, r) => c.ForeignKey1 == r.PrincipalKey1);
// Assert
EntityTypeConfiguration principalEntityType = Assert.Single(
builder.StructuralTypes.OfType <EntityTypeConfiguration>().Where(e => e.Name == "ForeignPrincipal"));
PropertyConfiguration propertyConfig = Assert.Single(principalEntityType.Properties);
PrimitivePropertyConfiguration primitiveConfig =
Assert.IsType <PrimitivePropertyConfiguration>(propertyConfig);
Assert.Equal("PrincipalKey1", primitiveConfig.Name);
Assert.Equal("System.Int32", primitiveConfig.RelatedClrType.FullName);
}
/// <summary>
/// Applies an index to <paramref name="property" />.
/// </summary>
/// <remarks>
/// Note: If the indexed property is of type string, you have to set the MaxLength.
/// </remarks>
/// <param name="property">The property instance.</param>
/// <param name="indexName">The name of the database index. Default is "IX_Default" if not defined.</param>
/// <param name="isUnique">
/// Set this property to true to define a unique index. Set this property to false to define a
/// non-unique index.
/// </param>
/// <param name="columnOrder">The column order of the index. Default is 0 if not defined.</param>
/// <returns></returns>
public static PrimitivePropertyConfiguration HasIndex(
this PrimitivePropertyConfiguration property,
string indexName = "",
bool isUnique = false,
int columnOrder = 0)
{
if (string.IsNullOrEmpty(indexName))
{
indexName = $"{IndexConstants.IndexPrefix}_{IndexConstants.DefaultIndexName}";
}
var indexAttribute = new IndexAttribute(indexName, columnOrder)
{
IsUnique = isUnique
};
var indexAnnotation = new IndexAnnotation(indexAttribute);
return(property.HasColumnAnnotation(IndexAnnotation.AnnotationName, indexAnnotation));
}
private static void CreateIndex(
PrimitivePropertyConfiguration property,
bool isUnique = false,
string name = null,
int position = 1)
{
var indexAttribute = new IndexAttribute();
if (!string.IsNullOrWhiteSpace(name))
{
indexAttribute = new IndexAttribute(
name,
position <= 0 ? 1 : position);
}
indexAttribute.IsUnique = isUnique;
property.HasColumnAnnotation(
IndexAnnotation.AnnotationName,
new IndexAnnotation(indexAttribute));
}
/// <summary>
/// Marks the property with StoreGeneratedPattern on the EDM type.
/// </summary>
/// <param name="edmProperty">The EDM property.</param>
/// <param name="structuralTypeConfiguration">The EDM type being configured.</param>
/// <param name="attribute">The <see cref="Attribute"/> found.</param>
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration, Attribute attribute)
{
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
EntityTypeConfiguration entityType = structuralTypeConfiguration as EntityTypeConfiguration;
PrimitivePropertyConfiguration primitiveProperty = edmProperty as PrimitivePropertyConfiguration;
DatabaseGeneratedAttribute databaseGeneratedAttribute = attribute as DatabaseGeneratedAttribute;
if (entityType != null && primitiveProperty != null && databaseGeneratedAttribute != null)
{
if (!edmProperty.AddedExplicitly)
{
primitiveProperty.StoreGeneratedPattern = databaseGeneratedAttribute.DatabaseGeneratedOption;
}
}
}
public void CanAddPrimitiveProperty_ForDependentEntityType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
// Act
builder.EntityType <ForeignEntity>().HasRequired(c => c.Principal, (c, r) => c.ForeignKey1 == r.PrincipalKey1);
// Assert
EntityTypeConfiguration dependentEntityType =
builder.StructuralTypes.OfType <EntityTypeConfiguration>().FirstOrDefault(e => e.Name == "ForeignEntity");
Assert.NotNull(dependentEntityType);
PrimitivePropertyConfiguration primitiveConfig =
Assert.Single(dependentEntityType.Properties.OfType <PrimitivePropertyConfiguration>());
Assert.Equal("ForeignKey1", primitiveConfig.Name);
Assert.Equal("System.Int32", primitiveConfig.RelatedClrType.FullName);
}
public void CreateDatePrimitiveProperty()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <File> file = builder.EntityType <File>();
PrimitivePropertyConfiguration date = file.Property(f => f.DateProperty);
// Act
IEdmModel model = builder.GetServiceModel();
// Assert
Assert.Equal(PropertyKind.Primitive, date.Kind);
IEdmEntityType fileType = Assert.Single(model.SchemaElements.OfType <IEdmEntityType>());
IEdmProperty dateProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "DateProperty"));
Assert.NotNull(dateProperty);
Assert.Equal("Edm.Date", dateProperty.Type.FullName());
}
public void Apply_invokes_action_with_value_when_not_null()
{
var actionInvoked = false;
object capturedValue = null;
var value = new object();
var convention = new PropertyConventionWithHaving <object>(
Enumerable.Empty <Func <PropertyInfo, bool> >(),
p => value,
(c, v) =>
{
actionInvoked = true;
capturedValue = v;
});
var propertyInfo = new MockPropertyInfo();
var configuration = new PrimitivePropertyConfiguration();
convention.Apply(propertyInfo, () => configuration);
Assert.True(actionInvoked);
Assert.Same(value, capturedValue);
}
private static void ApplyPrimitive(PrimitivePropertyConfiguration dependent, EntityTypeConfiguration entityType,
ForeignKeyAttribute foreignKeyAttribute)
{
Contract.Assert(dependent != null);
Contract.Assert(entityType != null);
Contract.Assert(foreignKeyAttribute != null);
string navName = foreignKeyAttribute.Name.Trim();
NavigationPropertyConfiguration navProperty = entityType.NavigationProperties
.FirstOrDefault(n => n.Name.Equals(navName, StringComparison.Ordinal));
if (navProperty == null)
{
return;
}
if (navProperty.Multiplicity == EdmMultiplicity.Many || navProperty.AddedExplicitly)
{
return;
}
EntityTypeConfiguration principalEntity = entityType.ModelBuilder.StructuralTypes
.OfType <EntityTypeConfiguration>().FirstOrDefault(e => e.ClrType == navProperty.RelatedClrType);
if (principalEntity == null)
{
return;
}
PrimitivePropertyConfiguration principal =
principalEntity.Keys.FirstOrDefault(
k => k.PropertyInfo.PropertyType == dependent.PropertyInfo.PropertyType &&
navProperty.PrincipalProperties.All(p => p != k.PropertyInfo));
if (principal != null)
{
navProperty.HasConstraint(dependent.PropertyInfo, principal.PropertyInfo);
}
}
public void Keys_Returns_DerivedKeys_IfBaseTypePresent()
{
// Arrange
PrimitivePropertyConfiguration[] keys = new PrimitivePropertyConfiguration[0];
Mock <EntityTypeConfiguration> baseBaseEntity = new Mock <EntityTypeConfiguration>();
baseBaseEntity.Setup(e => e.Keys).Returns(keys);
baseBaseEntity.Setup(e => e.BaseType).Returns <EntityTypeConfiguration>(null);
Mock <EntityTypeConfiguration> baseEntity = new Mock <EntityTypeConfiguration>();
baseEntity.Setup(e => e.BaseType).Returns(baseBaseEntity.Object);
Mock <EntityTypeConfiguration> entity = new Mock <EntityTypeConfiguration>();
baseEntity.Setup(e => e.BaseType).Returns(baseEntity.Object);
// Act & Assert
Assert.Equal(keys, entity.Object.Keys());
}
public static PrimitivePropertyConfiguration HasIdentityConfiguration(
this PrimitivePropertyConfiguration @this,
int seedValue = 1)
{
//@this.HasDatabaseGeneratedOption(
// DatabaseGeneratedOption.Identity)
// .HasColumnAnnotation("");
//var configuration = @this
// .HasDatabaseGeneratedOption(
// DatabaseGeneratedOption.Identity)
// .Reflect()
// .GetPropertyValue<object>(
// ReflectionVisibility.InstanceNonPublic, "Configuration");
//var annotations = configuration
// .Reflect()
// .GetPropertyValue<IDictionary<string, object>>(
// ReflectionVisibility.InstanceNonPublic, "Annotations");
return(@this);
}
private PrimitivePropertyConfiguration Cloning_a_primitive_property_configuration_clones_its_property_information_implementation(
PrimitivePropertyConfiguration configuration)
{
configuration.IsNullable = true;
configuration.ConcurrencyMode = ConcurrencyMode.Fixed;
configuration.DatabaseGeneratedOption = DatabaseGeneratedOption.Identity;
configuration.ColumnType = "ColumnType";
configuration.ColumnName = "ColumnName";
configuration.ColumnOrder = 1;
configuration.OverridableConfigurationParts = OverridableConfigurationParts.OverridableInCSpace;
var clone = configuration.Clone();
Assert.True(clone.IsNullable.Value);
Assert.Equal(ConcurrencyMode.Fixed, clone.ConcurrencyMode);
Assert.Equal(DatabaseGeneratedOption.Identity, clone.DatabaseGeneratedOption);
Assert.Equal("ColumnType", clone.ColumnType);
Assert.Equal("ColumnName", clone.ColumnName);
Assert.Equal(1, clone.ColumnOrder);
Assert.Equal(OverridableConfigurationParts.OverridableInCSpace, clone.OverridableConfigurationParts);
return(clone);
}
public void Configure_should_preserve_the_most_derived_configuration()
{
var configurationA = CreateConfiguration();
configurationA.ConcurrencyMode = ConcurrencyMode.Fixed;
var configurationB = new PrimitivePropertyConfiguration();
configurationB.IsNullable = false;
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
Assert.Null(property.GetConfiguration());
configurationA.Configure(property);
Assert.Equal(ConcurrencyMode.Fixed, ((PrimitivePropertyConfiguration)property.GetConfiguration()).ConcurrencyMode);
configurationB.Configure(property);
Assert.Equal(ConcurrencyMode.Fixed, ((PrimitivePropertyConfiguration)property.GetConfiguration()).ConcurrencyMode);
Assert.Equal(false, ((PrimitivePropertyConfiguration)property.GetConfiguration()).IsNullable);
Assert.Equal(GetConfigurationType(), property.GetConfiguration().GetType());
}
public void Apply_MultiForeignKeysOnForeignKeyProperty_Works()
{
// Arrange
Type dependentType = typeof(MultiDependentEntity2);
ODataModelBuilder builder = new ODataModelBuilder();
builder.Entity <PrincipalEntity>().HasKey(p => new { p.PrincipalIntId, p.PrincipalStringId });
EntityTypeConfiguration dependentEntity = builder.AddEntity(dependentType);
PropertyInfo expectPropertyInfo1 = dependentType.GetProperty("PrincipalId1");
PrimitivePropertyConfiguration propertyConfig1 = dependentEntity.AddProperty(expectPropertyInfo1);
PropertyInfo expectPropertyInfo2 = dependentType.GetProperty("PrincipalId2");
PrimitivePropertyConfiguration propertyConfig2 = dependentEntity.AddProperty(expectPropertyInfo2);
PropertyInfo propertyInfo = dependentType.GetProperty("Principal");
NavigationPropertyConfiguration navigation = dependentEntity.AddNavigationProperty(propertyInfo,
EdmMultiplicity.One);
navigation.AddedExplicitly = false;
// Act
ForeignKeyAttributeConvention convention = new ForeignKeyAttributeConvention();
convention.Apply(propertyConfig1, dependentEntity);
convention.Apply(propertyConfig2, dependentEntity);
// Assert
Assert.Equal(2, navigation.DependentProperties.Count());
Assert.Same(expectPropertyInfo1, navigation.DependentProperties.First());
Assert.Same(expectPropertyInfo2, navigation.DependentProperties.Last());
Assert.Equal(2, navigation.PrincipalProperties.Count());
Assert.Equal("PrincipalIntId", navigation.PrincipalProperties.First().Name);
Assert.Equal("PrincipalStringId", navigation.PrincipalProperties.Last().Name);
}
/// <summary>
/// Applies the configuration attributes for entities found in the specified assembly matching the given type filter
/// </summary>
/// <param name="modelBuilder">Model Builder</param>
/// <param name="assembly">Assembly to search for entities</param>
/// <param name="typeFilter">Filter for types in the given assembly</param>
public static void ApplyConfigurationAttributes(this DbModelBuilder modelBuilder, Assembly assembly, Func <Type, bool> typeFilter)
{
foreach (Type classType in assembly.GetTypes().Where(t => t.IsClass && typeFilter(t)))
{
var propertiesToConfigure = classType
.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.GetCustomAttribute <EFPropertyConfigurationAttribute>() != null)
.Select(p => new { prop = p, attr = p.GetCustomAttribute <EFPropertyConfigurationAttribute>(true) });
foreach (var propAttr in propertiesToConfigure)
{
var entityConfig = modelBuilder.GetType().GetMethod("Entity").MakeGenericMethod(classType).Invoke(modelBuilder, null);
ParameterExpression param = ParameterExpression.Parameter(classType, "c");
Expression property = Expression.Property(param, propAttr.prop.Name);
LambdaExpression lambdaExpression = Expression.Lambda(property, true, new ParameterExpression[] { param });
MethodInfo methodInfo = entityConfig.GetType().GetMethod("Property", new[] { lambdaExpression.GetType() });
PrimitivePropertyConfiguration propertyConfig = methodInfo.Invoke(entityConfig, new[] { lambdaExpression })
as PrimitivePropertyConfiguration;
propAttr.attr.Configure(propertyConfig);
}
}
}
public void TimestampConvention_DoesntApplyWhenTheAttributeIsAppliedToMultipleProperties_InATypeHierarchy()
{
// Arrange
PropertyInfo property = CreateMockPropertyInfo("TestProperty");
PropertyInfo otherProperty = CreateMockPropertyInfo("OtherTestProperty");
EntityTypeConfiguration baseEntityType = new EntityTypeConfiguration();
Mock <EntityTypeConfiguration> mockEntityType = new Mock <EntityTypeConfiguration>().SetupAllProperties();
mockEntityType.Setup(c => c.BaseType).Returns(baseEntityType);
mockEntityType.SetupGet(c => c.Kind).Returns(EdmTypeKind.Entity);
EntityTypeConfiguration entityType = mockEntityType.Object;
PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType);
entityType.ExplicitProperties.Add(property, primitiveProperty);
baseEntityType.ExplicitProperties.Add(otherProperty, new PrimitivePropertyConfiguration(otherProperty, baseEntityType));
TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention();
// Act
convention.Apply(primitiveProperty, entityType, new ODataConventionModelBuilder());
// Assert
Assert.False(primitiveProperty.ConcurrencyToken);
}
public void TimestampConvention_DoesntApplyWhenTheAttributeIsAppliedToMultipleProperties_InATypeHierarchy()
{
// Arrange
PropertyInfo property = CreateMockPropertyInfo("TestProperty");
PropertyInfo otherProperty = CreateMockPropertyInfo("OtherTestProperty");
ODataModelBuilder modelBuilder = ODataConventionModelBuilderFactory.Create();
EntityTypeConfiguration baseEntityType = new EntityTypeConfiguration(modelBuilder, typeof(object));
EntityTypeConfiguration entityType = new EntityTypeConfiguration(modelBuilder, typeof(Int32));
entityType.BaseType = baseEntityType;
PrimitivePropertyConfiguration primitiveProperty = new PrimitivePropertyConfiguration(property, entityType);
entityType.ExplicitProperties.Add(property, primitiveProperty);
baseEntityType.ExplicitProperties.Add(otherProperty, new PrimitivePropertyConfiguration(otherProperty, baseEntityType));
TimestampAttributeEdmPropertyConvention convention = new TimestampAttributeEdmPropertyConvention();
// Act
convention.Apply(primitiveProperty, entityType, ODataConventionModelBuilderFactory.Create());
// Assert
Assert.False(primitiveProperty.ConcurrencyToken);
}
public static void IsUnique(this PrimitivePropertyConfiguration property) => property
.HasColumnAnnotation(IndexAnnotation.AnnotationName, new IndexAnnotation(new IndexAttribute()
{
IsUnique = true
}));