public void Apply_ignores_constraint_when_inverse_constraint_already_specified() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property(mockTypeA, "A").Property<int>("AId1").Property<int>("AId2"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var mockInversePropertyInfo = mockTypeB.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo); var inverseNavigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockInversePropertyInfo); navigationPropertyConfiguration.InverseNavigationProperty = mockInversePropertyInfo; inverseNavigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention.ForeignKeyAttributeConventionImpl() .Apply(mockPropertyInfo, modelConfiguration, new ForeignKeyAttribute("AId2")); Assert.Null(navigationPropertyConfiguration.Constraint); }
public void Apply_ignores_constraint_when_inverse_constraint_already_specified() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property(mockTypeA, "A").Property <int>("AId1").Property <int>("AId2"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var mockInversePropertyInfo = mockTypeB.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo); var inverseNavigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockInversePropertyInfo); navigationPropertyConfiguration.InverseNavigationProperty = mockInversePropertyInfo; inverseNavigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new ForeignKeyAttribute("AId2")); Assert.Null(navigationPropertyConfiguration.Constraint); }
public void RemoveBaseTypeProperties_RemovesAllBaseTypePropertiesFromDerivedTypes() { var mockType1 = new MockType("Foo").Property <int>("P1"); var mockType2 = new MockType("Bar").BaseType(mockType1).Property <int>("P1").Property <int>("P2"); var mockType3 = new MockType("FooBar").BaseType(mockType2).Property <int>("P1").Property <int>("P2"); var mockAssembly = new MockAssembly(mockType1, mockType2, mockType3); HttpConfiguration configuration = new HttpConfiguration(); configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(mockAssembly)); var builder = new ODataConventionModelBuilder(configuration); var entity1 = builder.AddEntity(mockType1); entity1.AddProperty(mockType1.GetProperty("P1")); var entity2 = builder.AddEntity(mockType2).DerivesFrom(entity1); entity2.AddProperty(mockType2.GetProperty("P2")); var entity3 = builder.AddEntity(mockType3); entity3.AddProperty(mockType3.GetProperty("P1")); entity3.AddProperty(mockType3.GetProperty("P2")); builder.RemoveBaseTypeProperties(entity3, entity2); Assert.Empty(entity3.Properties); }
public void Apply_adds_fk_column_when_nav_prop_is_valid() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property <int>("AId").Property(mockTypeA, "A"); var mockPropertyInfo = mockTypeB.GetProperty("AId"); var mockNavigationPropertyInfo = mockTypeB.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( mockPropertyInfo, new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration), new ForeignKeyAttribute("A")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockNavigationPropertyInfo); Assert.NotNull(navigationPropertyConfiguration.Constraint); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { mockTypeB.GetProperty("AId") }, foreignKeyConstraint.ToProperties); Assert.Null(navigationPropertyConfiguration.InverseNavigationProperty); }
public void Apply_adds_fk_column_when_nav_prop_is_valid() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property<int>("AId").Property(mockTypeA, "A"); var mockPropertyInfo = mockTypeB.GetProperty("AId"); var mockNavigationPropertyInfo = mockTypeB.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( mockPropertyInfo, new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration), new ForeignKeyAttribute("A")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockNavigationPropertyInfo); Assert.NotNull(navigationPropertyConfiguration.Constraint); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { mockTypeB.GetProperty("AId") }, foreignKeyConstraint.ToProperties); Assert.Null(navigationPropertyConfiguration.InverseNavigationProperty); }
public void Key_does_not_append_key_members_once_set_by_attributes() { var type = new MockType() .Property <int>("Key1") .Property <int>("Key2"); var config = new EntityTypeConfiguration(type); config.Key(type.GetProperty("Key1"), null, true); config.Key(type.GetProperty("Key2")); Assert.Equal(1, config.KeyProperties.Count()); Assert.Equal("Key1", config.KeyProperties.Single().Name); }
public void Ctor_ThrowsArgument_IfMultiplicityIsManyAndPropertyIsNotCollection() { MockType mockEntity = new MockType().Property <int>("ID"); #if NETCOREAPP3_1 ExceptionAssert.Throws <ArgumentException>( () => new NavigationPropertyConfiguration(mockEntity.GetProperty("ID"), EdmMultiplicity.Many, new EntityTypeConfiguration()), "The property 'ID' on the type 'T' is being configured as a Many-to-Many navigation property. Many to Many navigation properties must be collections. (Parameter 'property')"); #else ExceptionAssert.Throws <ArgumentException>( () => new NavigationPropertyConfiguration(mockEntity.GetProperty("ID"), EdmMultiplicity.Many, new EntityTypeConfiguration()), "The property 'ID' on the type 'T' is being configured as a Many-to-Many navigation property. Many to Many navigation properties must be collections.\r\nParameter name: property"); #endif }
public void Key_appends_key_members_when_not_set_by_attributes() { var type = new MockType() .Property <int>("Key1") .Property <int>("Key2"); var config = new EntityTypeConfiguration(type); config.Key(type.GetProperty("Key1")); config.Key(type.GetProperty("Key2")); Assert.Equal(2, config.KeyProperties.Count()); Assert.Equal("Key1", config.KeyProperties.First().Name); Assert.Equal("Key2", config.KeyProperties.Last().Name); }
public void Configure_should_uniquify_unconfigured_assocation_function_names() { var typeA = new MockType("A"); var typeB = new MockType("B").Property(typeA.AsCollection(), "As"); var mockPropertyInfo = typeB.GetProperty("As"); typeA.Property(typeB.AsCollection(), "Bs"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeB).Navigation(mockPropertyInfo); navigationPropertyConfiguration.ModificationFunctionsConfiguration = new ModificationFunctionsConfiguration(); var modificationFunctionConfiguration = new ModificationFunctionConfiguration(); modificationFunctionConfiguration.HasName("M2M_Delete"); navigationPropertyConfiguration.ModificationFunctionsConfiguration .Insert(modificationFunctionConfiguration); var model = new EdmModel(DataSpace.CSpace); var entityA = model.AddEntityType("A"); entityA.Annotations.SetClrType(typeA); entityA.SetConfiguration(modelConfiguration.Entity(typeA)); var entityB = model.AddEntityType("B"); entityB.Annotations.SetClrType(typeB); entityB.SetConfiguration(modelConfiguration.Entity(typeB)); model.AddEntitySet("AS", entityA); model.AddEntitySet("BS", entityB); var associationType = model.AddAssociationType( "M2M", entityA, RelationshipMultiplicity.Many, entityB, RelationshipMultiplicity.Many); associationType.SetConfiguration(navigationPropertyConfiguration); var navigationProperty = entityB.AddNavigationProperty("As", associationType); navigationProperty.SetClrPropertyInfo(mockPropertyInfo); model.AddAssociationSet("M2MSet", associationType); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest) .Generate(model); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); Assert.True(databaseMapping.Database.Functions.Any(f => f.Name == "M2M_Delete")); Assert.True(databaseMapping.Database.Functions.Any(f => f.Name == "M2M_Delete1")); }
public void Apply_AliasSetIfEnabled_ValidPropertyAlias(string propertyAlias, bool modelAliasing, string expectedProptertyName) { // Arrange ODataConventionModelBuilder modelBuilder = new ODataConventionModelBuilder() { ModelAliasingEnabled = modelAliasing }; MockType type = new MockType("Mocktype") .Property(typeof(string), "Property", new[] { new DataMemberAttribute { Name = propertyAlias } }); type.Setup(t => t.GetCustomAttributes(It.IsAny <Type>(), It.IsAny <bool>())).Returns(new[] { new DataContractAttribute() }); Mock <StructuralTypeConfiguration> structuralType = new Mock <StructuralTypeConfiguration>(); structuralType.Setup(t => t.ClrType).Returns(type); PropertyInfo property = type.GetProperty("Property"); Mock <StructuralPropertyConfiguration> structuralProperty = new Mock <StructuralPropertyConfiguration>(property, structuralType.Object); structuralProperty.Object.AddedExplicitly = false; // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object, modelBuilder); // Assert Assert.Equal(expectedProptertyName, structuralProperty.Object.Name); }
public void Apply_AliasNotSet_NoPropertyAlias(bool modelAliasing) { // Arrange ODataConventionModelBuilder modelBuilder = ODataConventionModelBuilderHelper.CreateWithModelAliasing(modelAliasing: modelAliasing); MockType type = new MockType("Mocktype") .Property(typeof(string), "Property", new[] { new DataMemberAttribute() }); type.Setup(t => t.GetCustomAttributes(It.IsAny <Type>(), It.IsAny <bool>())).Returns(new[] { new DataContractAttribute() }); Mock <StructuralTypeConfiguration> structuralType = new Mock <StructuralTypeConfiguration>(); structuralType.Setup(t => t.ClrType).Returns(type); PropertyInfo property = type.GetProperty("Property"); Mock <StructuralPropertyConfiguration> structuralProperty = new Mock <StructuralPropertyConfiguration>(property, structuralType.Object); structuralProperty.Object.AddedExplicitly = false; // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object, modelBuilder); // Assert Assert.Equal("Property", structuralProperty.Object.Name); }
public void Apply_SetsTimeSpanProperty_AsEdmTimeOfDay(string typeName, bool expect) { // Arrange MockType type = new MockType("Customer") .Property(typeof(TimeSpan), "CreatedTime", new[] {new ColumnAttribute {TypeName = typeName}}); Mock<StructuralTypeConfiguration> structuralType = new Mock<StructuralTypeConfiguration>(); structuralType.Setup(t => t.ClrType).Returns(type); PropertyInfo property = type.GetProperty("CreatedTime"); Mock<PrimitivePropertyConfiguration> primitiveProperty = new Mock<PrimitivePropertyConfiguration>(property, structuralType.Object); primitiveProperty.Setup(p => p.RelatedClrType).Returns(typeof(TimeSpan)); primitiveProperty.Object.AddedExplicitly = false; // Act new ColumnAttributeEdmPropertyConvention().Apply(primitiveProperty.Object, structuralType.Object, new ODataConventionModelBuilder()); // Assert if (expect) { Assert.NotNull(primitiveProperty.Object.TargetEdmTypeKind); Assert.Equal(EdmPrimitiveTypeKind.TimeOfDay, primitiveProperty.Object.TargetEdmTypeKind); } else { Assert.Null(primitiveProperty.Object.TargetEdmTypeKind); } }
public void DerivedType_DataMemberRequired_IsHonored_IfDerivedtypeIsDataContract() { // Arrange MockType baseType = new MockType("BaseMocktype"); baseType.Setup(t => t.GetCustomAttributes(It.IsAny <Type>(), It.IsAny <bool>())).Returns(new[] { new DataContractAttribute() }); MockType derivedType = new MockType("DerivedMockType") .Property(typeof(int), "Property", new[] { new DataMemberAttribute { IsRequired = true } }) .BaseType(baseType); PropertyInfo property = derivedType.GetProperty("Property"); Mock <IStructuralTypeConfiguration> structuralType = new Mock <IStructuralTypeConfiguration>(); Mock <StructuralPropertyConfiguration> structuralProperty = new Mock <StructuralPropertyConfiguration>(property, structuralType.Object); structuralType.Setup(t => t.ClrType).Returns(derivedType); // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object); // Assert Assert.False(structuralProperty.Object.OptionalProperty); }
public void ConcurrencyCheckAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { // Arrange MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(typeof(int), "Count", new ConcurrencyCheckAttribute()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var entityType = builder.AddEntityType(type); entityType.AddProperty(type.GetProperty("Count")).IsOptional(); builder.AddEntitySet("EntitySet", entityType); // Act IEdmModel model = builder.GetEdmModel(); // Assert IEdmEntityType entity = model.AssertHasEntityType(type); IEdmStructuralProperty property = entity.AssertHasPrimitiveProperty( model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); IEdmEntitySet entitySet = model.EntityContainer.FindEntitySet("EntitySet"); Assert.NotNull(entitySet); IEnumerable <IEdmStructuralProperty> currencyProperties = model.GetConcurrencyProperties(entitySet); IEdmStructuralProperty currencyProperty = Assert.Single(currencyProperties); Assert.Same(property, currencyProperty); }
public void Apply_SetsTimeSpanProperty_AsEdmTimeOfDay(string typeName, bool expect) { // Arrange MockType type = new MockType("Customer") .Property(typeof(TimeSpan), "CreatedTime", new[] { new ColumnAttribute { TypeName = typeName } }); Mock <StructuralTypeConfiguration> structuralType = new Mock <StructuralTypeConfiguration>(); structuralType.Setup(t => t.ClrType).Returns(type); PropertyInfo property = type.GetProperty("CreatedTime"); Mock <PrimitivePropertyConfiguration> primitiveProperty = new Mock <PrimitivePropertyConfiguration>(property, structuralType.Object); primitiveProperty.Setup(p => p.RelatedClrType).Returns(typeof(TimeSpan)); primitiveProperty.Object.AddedExplicitly = false; // Act new ColumnAttributeEdmPropertyConvention().Apply(primitiveProperty.Object, structuralType.Object, ODataConventionModelBuilderFactory.Create()); // Assert if (expect) { Assert.NotNull(primitiveProperty.Object.TargetEdmTypeKind); Assert.Equal(EdmPrimitiveTypeKind.TimeOfDay, primitiveProperty.Object.TargetEdmTypeKind); } else { Assert.Null(primitiveProperty.Object.TargetEdmTypeKind); } }
public void DatabaseGeneratedAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { // Arrange MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(typeof(int?), "Count", new DatabaseGeneratedAttribute(DatabaseGeneratedOption.Computed)); // Act ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntity(type).AddProperty(type.GetProperty("Count")).IsOptional(); IEdmModel model = builder.GetEdmModel(); // Assert IEdmEntityType entity = model.AssertHasEntityType(type); IEdmStructuralProperty property = entity.AssertHasPrimitiveProperty(model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); var idAnnotation = model.GetAnnotationValue <EdmStringConstant>( property, StoreGeneratedPatternAnnotation.AnnotationsNamespace, "StoreGeneratedPattern"); Assert.Null(idAnnotation); }
public void Apply_DoesnotSetRequiredProperty_IfTypeIsNotADataContract() { // Arrange MockType type = new MockType("Mocktype") .Property(typeof(string), "Property", new[] { new DataMemberAttribute { IsRequired = true } }); type.Setup(t => t.GetCustomAttributes(It.IsAny <Type>(), It.IsAny <bool>())).Returns(new object[0]); Mock <StructuralTypeConfiguration> structuralType = new Mock <StructuralTypeConfiguration>(); structuralType.Setup(t => t.ClrType).Returns(type); PropertyInfo property = type.GetProperty("Property"); Mock <StructuralPropertyConfiguration> structuralProperty = new Mock <StructuralPropertyConfiguration>(property, structuralType.Object); structuralProperty.Object.AddedExplicitly = false; // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object, ODataConventionModelBuilderFactory.Create()); // Assert Assert.True(structuralProperty.Object.OptionalProperty); }
public void Ctor_ThrowsArgument_IfMultiplicityIsManyAndPropertyIsNotCollection() { MockType mockEntity = new MockType().Property<int>("ID"); Assert.Throws<ArgumentException>( () => new NavigationPropertyConfiguration(mockEntity.GetProperty("ID"), EdmMultiplicity.Many, new EntityTypeConfiguration()), "The property 'ID' on the type 'T' is being configured as a Many-to-Many navigation property. Many to Many navigation properties must be collections.\r\nParameter name: property"); }
public void Apply_ignores_inverse_when_already_configured() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property(mockTypeA, "A1").Property(mockTypeA, "A2"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo); navigationPropertyConfiguration.InverseNavigationProperty = mockTypeB.GetProperty("A2"); new InversePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("A1")); Assert.NotSame(mockTypeB.GetProperty("A1"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void Apply_ignores_constraint_when_already_specified() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property<int>("AId1").Property<int>("AId2"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo); navigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention.ForeignKeyAttributeConventionImpl() .Apply(mockPropertyInfo, modelConfiguration, new ForeignKeyAttribute("AId2")); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { mockTypeB.GetProperty("AId1") }, foreignKeyConstraint.DependentProperties); }
public void IsKey_is_noop_when_set() { var type = new MockType() .Property <int>("Property1") .Property <int>("Property2"); var typeConfig = new EntityTypeConfiguration(type); typeConfig.Key(new[] { type.GetProperty("Property1") }); var innerConfig = new PrimitivePropertyConfiguration { TypeConfiguration = typeConfig }; var propertyInfo = type.GetProperty("Property2"); var config = new LightweightPropertyConfiguration(propertyInfo, () => innerConfig); var result = config.IsKey(); Assert.DoesNotContain(propertyInfo, typeConfig.KeyProperties); Assert.Same(config, result); }
public void Apply_ignores_constraint_when_already_specified() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property <int>("AId1").Property <int>("AId2"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo); navigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new ForeignKeyAttribute("AId2")); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { mockTypeB.GetProperty("AId1") }, foreignKeyConstraint.ToProperties); }
public void Mapping_a_single_abstract_type_should_not_throw() { var modelConfiguration = new ModelConfiguration(); var mockType = new MockType("T").TypeAttributes(TypeAttributes.Abstract).Property <int>("Id"); modelConfiguration.Entity(mockType).Key(mockType.GetProperty("Id")); var modelBuilder = new DbModelBuilder(); var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo); Assert.NotNull(databaseMapping); }
public void Apply_throws_when_cannot_find_navigation_property() { var mockTypeA = new MockType("A"); mockTypeA.Property(typeof(int), "BId"); var mockPropertyInfo = mockTypeA.GetProperty("BId"); Assert.Equal( Strings.ForeignKeyAttributeConvention_InvalidNavigationProperty("BId", mockTypeA.Object, "Missing"), Assert.Throws <InvalidOperationException>( () => new ForeignKeyPrimitivePropertyAttributeConvention() .Apply(mockPropertyInfo, new ModelConfiguration(), new ForeignKeyAttribute("Missing"))).Message); }
public void RequiredAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(typeof(int), "Count", new RequiredAttribute()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntityType(type).AddProperty(type.GetProperty("Count")).IsOptional(); IEdmModel model = builder.GetEdmModel(); IEdmEntityType entity = model.AssertHasEntityType(type); entity.AssertHasPrimitiveProperty(model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); }
public void Apply_ignores_inverse_on_nonnavigation() { var mockTypeA = new MockType("A").Property(typeof(int), "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var modelConfiguration = new ModelConfiguration(); var entityConfiguration = modelConfiguration.Entity(mockTypeA); new InversePropertyAttributeConvention() .Apply( mockPropertyInfo, new ConventionTypeConfiguration(mockTypeA, () => entityConfiguration, modelConfiguration), new InversePropertyAttribute("A1")); Assert.False(entityConfiguration.IsNavigationPropertyConfigured(mockPropertyInfo)); }
public void Apply_throws_on_self_inverse() { var mockTypeA = new MockType("A"); mockTypeA.Property(mockTypeA, "A"); var mockPropertyInfo = mockTypeA.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); Assert.Equal( Strings.InversePropertyAttributeConvention_SelfInverseDetected("A", mockTypeA.Object), Assert.Throws <InvalidOperationException>( () => new InversePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("A"))).Message); }
public void AsDate_ThrowsArgument(Type propertyType) { // Arrange MockType type = new MockType().Property(propertyType, "Birthday"); PropertyInfo property = type.GetProperty("Birthday"); _structuralType.Setup(t => t.ClrType).Returns(type); // Act PrimitivePropertyConfiguration propertyConfig = new PrimitivePropertyConfiguration(property, _structuralType.Object); // Assert Assert.ThrowsArgument(() => propertyConfig.AsDate(), "property", "The property 'Birthday' on type 'NS.Customer' must be a System.DateTime property"); }
public void AsTimeOfDay_ThrowsArgument(Type propertyType) { // Arrange MockType type = new MockType().Property(propertyType, "CreatedTime"); PropertyInfo property = type.GetProperty("CreatedTime"); _structuralType.Setup(t => t.ClrType).Returns(type); // Act PrimitivePropertyConfiguration propertyConfig = new PrimitivePropertyConfiguration(property, _structuralType.Object); // Assert ExceptionAssert.ThrowsArgument(() => propertyConfig.AsTimeOfDay(), "property", "The property 'CreatedTime' on type 'NS.Customer' must be a System.TimeSpan property"); }
public void Apply_throws_when_cannot_find_inverse_property() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var modelConfiguration = new ModelConfiguration(); Assert.Equal( Strings.InversePropertyAttributeConvention_PropertyNotFound("Foo", mockTypeB.Object, "B", mockTypeA.Object), Assert.Throws <InvalidOperationException>( () => new InversePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("Foo"))).Message); }
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 Build_should_map_types() { var modelConfiguration = new ModelConfiguration(); var mockType = new MockType("T").Property <int>("Id"); modelConfiguration.Entity(mockType).Key(mockType.GetProperty("Id")); modelConfiguration.ComplexType(new MockType("C")); var modelBuilder = new DbModelBuilder(modelConfiguration); var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping; Assert.NotNull(databaseMapping); Assert.Equal(1, databaseMapping.Model.GetEntityTypes().Count()); Assert.Equal(1, databaseMapping.Model.GetComplexTypes().Count()); }
public void HasKey_is_noop_when_set() { var type = new MockType() .Property <int>("Property1") .Property <int>("Property2"); var innerConfig = new EntityTypeConfiguration(type); innerConfig.Key(new[] { type.GetProperty("Property1") }); var config = new LightweightEntityConfiguration(type, () => innerConfig); var result = config.HasKey("Property2"); Assert.Equal(1, innerConfig.KeyProperties.Count()); Assert.False(innerConfig.KeyProperties.Any(p => p.Name == "Property2")); Assert.Same(config, result); }
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); }
public void RequiredAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(typeof(int), "Count", new RequiredAttribute()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntity(type).AddProperty(type.GetProperty("Count")).IsOptional(); IEdmModel model = builder.GetEdmModel(); IEdmEntityType entity = model.AssertHasEntityType(type); entity.AssertHasPrimitiveProperty(model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); }
public void Build_should_apply_model_configuration() { var modelConfiguration = new ModelConfiguration(); var mockType = new MockType("T").Property <int>("Id"); modelConfiguration.Entity(mockType) .Property(new PropertyPath(mockType.GetProperty("Id"))) .ConcurrencyMode = ConcurrencyMode.Fixed; var databaseMapping = new DbModelBuilder(modelConfiguration).Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping; Assert.NotNull(databaseMapping); Assert.Equal( ConcurrencyMode.Fixed, databaseMapping.Model.Namespaces.Single().EntityTypes.Single().DeclaredProperties.Single().ConcurrencyMode); }
public void Apply_finds_inverse_when_many_to_many() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property(mockTypeA.AsCollection(), "As"); var mockPropertyInfo = mockTypeB.GetProperty("As"); mockTypeA.Property(mockTypeB.AsCollection(), "Bs"); var modelConfiguration = new ModelConfiguration(); new InversePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("Bs")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo); Assert.Same(mockTypeA.GetProperty("Bs"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void Apply_DoesnotSetRequiredProperty_IfTypeIsNotADataContract() { // Arrange MockType type = new MockType("Mocktype") .Property(typeof(string), "Property", new[] { new DataMemberAttribute { IsRequired = true } }); type.Setup(t => t.GetCustomAttributes(It.IsAny<Type>(), It.IsAny<bool>())).Returns(new object[0]); PropertyInfo property = type.GetProperty("Property"); Mock<StructuralTypeConfiguration> structuralType = new Mock<StructuralTypeConfiguration>(); Mock<StructuralPropertyConfiguration> structuralProperty = new Mock<StructuralPropertyConfiguration>(property, structuralType.Object); structuralType.Setup(t => t.ClrType).Returns(type); // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object); // Assert Assert.True(structuralProperty.Object.OptionalProperty); }
public void ConcurrencyCheckAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(typeof(int), "Count", new ConcurrencyCheckAttribute()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntityType(type).AddProperty(type.GetProperty("Count")).IsOptional(); IEdmModel model = builder.GetEdmModel(); IEdmEntityType entity = model.AssertHasEntityType(type); IEdmStructuralProperty property = entity.AssertHasPrimitiveProperty( model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); Assert.Equal(EdmConcurrencyMode.Fixed, property.ConcurrencyMode); }
public void Apply_finds_inverse_when_optional_to_optional() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property(mockTypeA, "A"); var mockPropertyInfo = mockTypeB.GetProperty("A"); mockTypeA.Property(mockTypeB, "B"); var modelConfiguration = new ModelConfiguration(); new InversePropertyAttributeConvention() .Apply( mockPropertyInfo, new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration), new InversePropertyAttribute("B")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo); Assert.Same(mockTypeA.GetProperty("B"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void Apply_SetsRequiredProperty() { // Arrange MockType type = new MockType("Mocktype") .Property(typeof(string), "Property", new[] { new DataMemberAttribute { IsRequired = true } }); type.Setup(t => t.GetCustomAttributes(It.IsAny<Type>(), It.IsAny<bool>())).Returns(new[] { new DataContractAttribute() }); Mock<StructuralTypeConfiguration> structuralType = new Mock<StructuralTypeConfiguration>(); structuralType.Setup(t => t.ClrType).Returns(type); PropertyInfo property = type.GetProperty("Property"); Mock<StructuralPropertyConfiguration> structuralProperty = new Mock<StructuralPropertyConfiguration>(property, structuralType.Object); structuralProperty.Object.AddedExplicitly = false; // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object, new ODataConventionModelBuilder()); // Assert Assert.False(structuralProperty.Object.OptionalProperty); }
public void DatabaseGeneratedAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { // Arrange MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(typeof(int?), "Count", new DatabaseGeneratedAttribute(DatabaseGeneratedOption.Computed)); // Act ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntity(type).AddProperty(type.GetProperty("Count")).IsOptional(); IEdmModel model = builder.GetEdmModel(); // Assert IEdmEntityType entity = model.AssertHasEntityType(type); IEdmStructuralProperty property = entity.AssertHasPrimitiveProperty(model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); var idAnnotation = model.GetAnnotationValue<EdmStringConstant>( property, StoreGeneratedPatternAnnotation.AnnotationsNamespace, "StoreGeneratedPattern"); Assert.Null(idAnnotation); }
public void CanMapObjectArrayAsAComplexProperty() { MockType type = new MockType("entity") .Property<int>("ID") .Property<object[]>("Collection"); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); var entityType = builder.AddEntity(type); entityType.AddCollectionProperty(type.GetProperty("Collection")); builder.AddEntitySet("entityset", entityType); IEdmModel model = builder.GetEdmModel(); Assert.Equal(3, model.SchemaElements.Count()); var entityEdmType = model.AssertHasEntitySet("entityset", type); model.AssertHasComplexType(typeof(object)); entityEdmType.AssertHasCollectionProperty(model, "Collection", typeof(object), isNullable: true); }
public void Apply_throws_when_cannot_find_inverse_property() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B"); mockTypeA.Property(mockTypeB, "B"); var mockPropertyInfo = mockTypeA.GetProperty("B"); var modelConfiguration = new ModelConfiguration(); Assert.Equal( Strings.InversePropertyAttributeConvention_PropertyNotFound("Foo", mockTypeB.Object, "B", mockTypeA.Object), Assert.Throws<InvalidOperationException>( () => new InversePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("Foo"))).Message); }
public void Apply_throws_on_self_inverse() { var mockTypeA = new MockType("A"); mockTypeA.Property(mockTypeA, "A"); var mockPropertyInfo = mockTypeA.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); Assert.Equal( Strings.InversePropertyAttributeConvention_SelfInverseDetected("A", mockTypeA.Object), Assert.Throws<InvalidOperationException>( () => new InversePropertyAttributeConvention() .Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("A"))).Message); }
public void HasKey_composite_is_noop_when_set() { var type = new MockType() .Property<int>("Property1") .Property<int>("Property2") .Property<int>("Property3"); var innerConfig = new EntityTypeConfiguration(type); innerConfig.Key(new[] { type.GetProperty("Property1") }); var config = new LightweightEntityConfiguration(type, () => innerConfig); var result = config.HasKey(new[] { "Property2", "Property3" }); Assert.Equal(1, innerConfig.KeyProperties.Count()); Assert.False(innerConfig.KeyProperties.Any(p => p.Name == "Property2")); Assert.False(innerConfig.KeyProperties.Any(p => p.Name == "Property3")); Assert.Same(config, result); }
public void Apply_AliasSetIfEnabled_ValidPropertyAlias(string propertyAlias, bool modelAliasing, string expectedProptertyName) { // Arrange MockType type = new MockType("Mocktype") .Property(typeof(string), "Property", new[] { new DataMemberAttribute { Name = propertyAlias } }); type.Setup(t => t.GetCustomAttributes(It.IsAny<Type>(), It.IsAny<bool>())).Returns(new[] { new DataContractAttribute() }); PropertyInfo property = type.GetProperty("Property"); Mock<StructuralTypeConfiguration> structuralType = new Mock<StructuralTypeConfiguration>(); ODataModelBuilder modelBuilder = new ODataModelBuilder { ModelAliasingEnabled = modelAliasing }; structuralType.SetupGet(s => s.ModelBuilder).Returns(modelBuilder); Mock<StructuralPropertyConfiguration> structuralProperty = new Mock<StructuralPropertyConfiguration>(property, structuralType.Object); structuralProperty.Object.AddedExplicitly = false; structuralType.Setup(t => t.ClrType).Returns(type); // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object); // Assert Assert.Equal(expectedProptertyName, structuralProperty.Object.Name); }
public void DataMemberAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfiguration() { MockType type = new MockType("Entity") .Property(typeof(int), "ID", new DataMemberAttribute()) .Property(typeof(int), "Count", new DataMemberAttribute { IsRequired = true }); type.Setup(t => t.GetCustomAttributes(It.IsAny<Type>(), It.IsAny<bool>())).Returns(new[] { new DataContractAttribute() }); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntity(type).AddProperty(type.GetProperty("Count")).IsOptional(); IEdmModel model = builder.GetEdmModel(); IEdmEntityType entity = model.AssertHasEntityType(type); entity.AssertHasPrimitiveProperty(model, "Count", EdmPrimitiveTypeKind.Int32, isNullable: true); }
public void IgnoredPropertyOnBaseType_DoesnotShowupOnDerivedType() { // Arrange var baseType = new MockType("BaseType") .Property<int>("BaseTypeProperty"); var derivedType = new MockType("DerivedType") .BaseType(baseType) .Property<int>("DerivedTypeProperty"); var mockAssembly = new MockAssembly(baseType, derivedType); HttpConfiguration configuration = new HttpConfiguration(); configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(mockAssembly)); var builder = new ODataConventionModelBuilder(configuration); // Act var baseEntity = builder.AddEntity(baseType); baseEntity.RemoveProperty(baseType.GetProperty("BaseTypeProperty")); IEdmModel model = builder.GetEdmModel(); // Assert IEdmEntityType baseEntityType = model.AssertHasEntityType(derivedType); Assert.DoesNotContain("BaseTypeProperty", baseEntityType.Properties().Select(p => p.Name)); IEdmEntityType derivedEntityType = model.AssertHasEntityType(derivedType); Assert.DoesNotContain("BaseTypeProperty", derivedEntityType.Properties().Select(p => p.Name)); }
public void ModelBuilder_Doesnot_Override_NavigationPropertyConfiguration() { MockType type1 = new MockType("Entity1") .Property<int>("ID"); MockType type2 = new MockType("Entity2") .Property<int>("ID") .Property(type1, "Relation"); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntity(type2).AddNavigationProperty(type2.GetProperty("Relation"), EdmMultiplicity.One); IEdmModel model = builder.GetEdmModel(); IEdmEntityType entity = model.AssertHasEntityType(type2); entity.AssertHasNavigationProperty(model, "Relation", type1, isNullable: false, multiplicity: EdmMultiplicity.One); }
public void RequiredAttributeEdmPropertyConvention_DoesnotOverwriteExistingConfigurationForNavigationProperties() { MockType anotherType = new MockType("RelatedEntity") .Property<int>("ID"); MockType type = new MockType("Entity") .Property(typeof(int), "ID") .Property(anotherType, "RelatedEntity", new RequiredAttribute()); ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddEntityType(type).AddNavigationProperty(type.GetProperty("RelatedEntity"), EdmMultiplicity.ZeroOrOne); IEdmModel model = builder.GetEdmModel(); IEdmEntityType entity = model.AssertHasEntityType(type); entity.AssertHasNavigationProperty(model, "RelatedEntity", anotherType, isNullable: true, multiplicity: EdmMultiplicity.ZeroOrOne); }
public void Apply_throws_when_cannot_find_navigation_property() { var mockTypeA = new MockType("A"); mockTypeA.Property(typeof(int), "BId"); var mockPropertyInfo = mockTypeA.GetProperty("BId"); Assert.Equal( Strings.ForeignKeyAttributeConvention_InvalidNavigationProperty("BId", mockTypeA.Object, "Missing"), Assert.Throws<InvalidOperationException>( () => new ForeignKeyPrimitivePropertyAttributeConvention.ForeignKeyAttributeConventionImpl() .Apply(mockPropertyInfo, new ModelConfiguration(), new ForeignKeyAttribute("Missing"))).Message); }
public void RemoveBaseTypeProperties_RemovesAllBaseTypePropertiesFromDerivedTypes() { var mockType1 = new MockType("Foo").Property<int>("P1"); var mockType2 = new MockType("Bar").BaseType(mockType1).Property<int>("P1").Property<int>("P2"); var mockType3 = new MockType("FooBar").BaseType(mockType2).Property<int>("P1").Property<int>("P2"); var mockAssembly = new MockAssembly(mockType1, mockType2, mockType3); HttpConfiguration configuration = new HttpConfiguration(); configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(mockAssembly)); var builder = new ODataConventionModelBuilder(configuration); var entity1 = builder.AddEntity(mockType1); entity1.AddProperty(mockType1.GetProperty("P1")); var entity2 = builder.AddEntity(mockType2).DerivesFrom(entity1); entity2.AddProperty(mockType2.GetProperty("P2")); var entity3 = builder.AddEntity(mockType3); entity3.AddProperty(mockType3.GetProperty("P1")); entity3.AddProperty(mockType3.GetProperty("P2")); builder.RemoveBaseTypeProperties(entity3, entity2); Assert.Empty(entity3.Properties); }
public void ODataConventionModelBuilder_IgnoresIndexerProperties() { MockType type = new MockType("ComplexType") .Property<int>("Item"); MockPropertyInfo pi = type.GetProperty("Item"); pi.Setup(p => p.GetIndexParameters()).Returns(new[] { new Mock<ParameterInfo>().Object }); // make it indexer ODataConventionModelBuilder builder = new ODataConventionModelBuilder(); builder.AddComplexType(type); IEdmModel model = builder.GetEdmModel(); IEdmComplexType complexType = model.AssertHasComplexType(type); Assert.Empty(complexType.Properties()); }
public void ODataConventionModelBuilder_Sets_IsAddedExplicitly_Appropriately() { // Arrange MockType relatedEntity = new MockType("RelatedEntity") .Property<int>("ID"); MockType relatedComplexType = new MockType("RelatedComplexType"); MockType type = new MockType() .Property<int>("ID") .Property<int>("ExplicitlyAddedPrimitive") .Property<int>("InferredPrimitive") .Property<int[]>("ExplicitlyAddedPrimitiveCollection") .Property<int[]>("InferredAddedPrimitiveCollection") .Property(relatedComplexType, "ExplicitlyAddedComplex") .Property(relatedComplexType, "InferredComplex") .Property(relatedComplexType.AsCollection(), "ExplicitlyAddedComplexCollection") .Property(relatedComplexType.AsCollection(), "InferredComplexCollection") .Property(relatedEntity, "ExplicitlyAddedNavigation") .Property(relatedEntity, "InferredNavigation") .Property(relatedEntity.AsCollection(), "ExplicitlyAddedNavigationCollection") .Property(relatedEntity.AsCollection(), "InferredNavigationCollection"); var builder = new ODataConventionModelBuilder(); var entity = builder.AddEntity(type); entity.AddProperty(type.GetProperty("ExplicitlyAddedPrimitive")); entity.AddCollectionProperty(type.GetProperty("ExplicitlyAddedPrimitiveCollection")); entity.AddComplexProperty(type.GetProperty("ExplicitlyAddedComplex")); entity.AddCollectionProperty(type.GetProperty("ExplicitlyAddedComplexCollection")); entity.AddNavigationProperty(type.GetProperty("ExplicitlyAddedNavigation"), EdmMultiplicity.ZeroOrOne); entity.AddNavigationProperty(type.GetProperty("ExplicitlyAddedNavigationCollection"), EdmMultiplicity.Many); builder.OnModelCreating = (b) => { var explicitlyAddedProperties = entity.Properties.Where(p => p.Name.Contains("ExplicitlyAdded")); var inferredProperties = entity.Properties.Where(p => p.Name.Contains("Inferred")); Assert.Equal(13, entity.Properties.Count()); Assert.Equal(6, explicitlyAddedProperties.Count()); Assert.Equal(6, inferredProperties.Count()); foreach (var explicitlyAddedProperty in explicitlyAddedProperties) { Assert.True(explicitlyAddedProperty.AddedExplicitly); } foreach (var inferredProperty in inferredProperties) { Assert.False(inferredProperty.AddedExplicitly); } }; Assert.DoesNotThrow(() => builder.GetEdmModel()); }
public void DerivedType_DataMemberRequired_IsHonored_IfDerivedtypeIsDataContract() { // Arrange MockType baseType = new MockType("BaseMocktype"); baseType.Setup(t => t.GetCustomAttributes(It.IsAny<Type>(), It.IsAny<bool>())).Returns(new[] { new DataContractAttribute() }); MockType derivedType = new MockType("DerivedMockType") .Property(typeof(int), "Property", new[] { new DataMemberAttribute { IsRequired = true } }) .BaseType(baseType); PropertyInfo property = derivedType.GetProperty("Property"); Mock<StructuralTypeConfiguration> structuralType = new Mock<StructuralTypeConfiguration>(); Mock<StructuralPropertyConfiguration> structuralProperty = new Mock<StructuralPropertyConfiguration>(property, structuralType.Object); structuralType.Setup(t => t.ClrType).Returns(derivedType); // Act new DataMemberAttributeEdmPropertyConvention().Apply(structuralProperty.Object, structuralType.Object); // Assert Assert.False(structuralProperty.Object.OptionalProperty); }