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_ignores_constraint_when_inverse_constraint_already_specified() { var mockPropertyInfo = typeof(AType4).GetInstanceProperty("B"); var mockInversePropertyInfo = typeof(BType4).GetInstanceProperty("A"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(AType4)).Navigation(mockPropertyInfo); var inverseNavigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType4)).Navigation(mockInversePropertyInfo); navigationPropertyConfiguration.InverseNavigationProperty = mockInversePropertyInfo; inverseNavigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { typeof(BType4).GetInstanceProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( typeof(BType4).GetInstanceProperty("AId1"), new ConventionTypeConfiguration(typeof(BType4), () => modelConfiguration.Entity(typeof(BType4)), modelConfiguration), new ForeignKeyAttribute("A")); 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); }
private bool HasConfiguredConstraint() { if (_configuration != null && _configuration.Constraint != null && _configuration.Constraint.IsFullySpecified) { return(true); } if (_configuration != null && _configuration.InverseNavigationProperty != null) { var targetType = _configuration.NavigationProperty.PropertyType.GetTargetType(); if (_modelConfiguration.Entities.Contains(targetType)) { var entityConfiguration = _modelConfiguration.Entity(targetType); if (entityConfiguration.IsNavigationPropertyConfigured(_configuration.InverseNavigationProperty)) { return(entityConfiguration.Navigation(_configuration.InverseNavigationProperty) .Constraint != null); } } } return(false); }
public void Apply_finds_inverse_when_many_to_many() { var propertyInfo = typeof(BType2).GetInstanceProperty("As"); var modelConfiguration = new ModelConfiguration(); new InversePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration(typeof(BType2), () => modelConfiguration.Entity(typeof(BType2)), modelConfiguration), new InversePropertyAttribute("Bs")); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType2)).Navigation(propertyInfo); Assert.Same(typeof(AType2).GetInstanceProperty("Bs"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void Apply_ignores_inverse_when_already_configured() { var propertyInfo = typeof(AType4).GetInstanceProperty("B"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(AType4)).Navigation(propertyInfo); navigationPropertyConfiguration.InverseNavigationProperty = typeof(BType4).GetInstanceProperty("A2"); new InversePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration(typeof(AType4), () => modelConfiguration.Entity(typeof(AType4)), modelConfiguration), new InversePropertyAttribute("A1")); Assert.NotSame(typeof(BType4).GetInstanceProperty("A1"), navigationPropertyConfiguration.InverseNavigationProperty); }
public static void ConfigureEdmMetadata(ModelConfiguration modelConfiguration) { DebugCheck.NotNull(modelConfiguration); #pragma warning disable 612,618 modelConfiguration.Entity(typeof(EdmMetadata)).ToTable(TableName); #pragma warning restore 612,618 }
public void Build_should_validate_and_throw_with_invalid_model() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(typeof(Random), true); Assert.Throws <ModelValidationException>( () => new DbModelBuilder(modelConfiguration).Build(ProviderRegistry.Sql2008_ProviderInfo)); }
public void Add_entity_configuration_should_add_to_model_configuration() { var modelConfiguration = new ModelConfiguration(); var entityConfiguration = new EntityTypeConfiguration <object>(); new ConfigurationRegistrar(modelConfiguration).Add(entityConfiguration); Assert.Same(entityConfiguration.Configuration, modelConfiguration.Entity(typeof(object))); }
public void Add_entity_configuration_should_add_to_model_configuration() { var modelConfiguration = new ModelConfiguration(); var entityConfiguration = new EntityTypeConfiguration<object>(); new ConfigurationRegistrar(modelConfiguration).Add(entityConfiguration); Assert.Same(entityConfiguration.Configuration, modelConfiguration.Entity(typeof(object))); }
public void Apply_ignores_constraint_when_already_specified() { var propertyInfo = typeof(BType3).GetInstanceProperty("A"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType3)).Navigation(propertyInfo); navigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { typeof(BType3).GetInstanceProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( typeof(BType3).GetInstanceProperty("AId2"), new ConventionTypeConfiguration(typeof(BType3), () => modelConfiguration.Entity(typeof(BType3)), modelConfiguration), new ForeignKeyAttribute("A")); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { typeof(BType3).GetInstanceProperty("AId1") }, foreignKeyConstraint.ToProperties); }
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, new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration), new InversePropertyAttribute("Bs")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo); Assert.Same(mockTypeA.GetProperty("Bs"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void Mapping_a_single_abstract_type_should_not_throw() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(typeof(AType1)).Key(typeof(AType1).GetDeclaredProperty("Id")); var modelBuilder = new DbModelBuilder(); var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo); Assert.NotNull(databaseMapping); }
public void IsIgnoredProperty_should_return_true_if_property_is_ignored() { var modelConfiguration = new ModelConfiguration(); var mockType = new MockType(); var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S"); Assert.False(modelConfiguration.IsIgnoredProperty(mockType, mockPropertyInfo)); modelConfiguration.Entity(mockType).Ignore(mockPropertyInfo); Assert.True(modelConfiguration.IsIgnoredProperty(mockType, mockPropertyInfo)); }
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_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, new ConventionTypeConfiguration(mockTypeA, () => modelConfiguration.Entity(mockTypeA), modelConfiguration), new InversePropertyAttribute("A1")); Assert.NotSame(mockTypeB.GetProperty("A1"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void GetConfiguredProperties_should_return_all_configured_properties() { var modelConfiguration = new ModelConfiguration(); var mockType = new MockType(); var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S"); Assert.False(modelConfiguration.GetConfiguredProperties(mockType).Any()); modelConfiguration.Entity(mockType).Property(new PropertyPath(mockPropertyInfo)); Assert.Same(mockPropertyInfo.Object, modelConfiguration.GetConfiguredProperties(mockType).Single()); }
public void Apply_ignores_inverse_on_nonnavigation() { var propertyInfo = typeof(AType5).GetInstanceProperty("B"); var modelConfiguration = new ModelConfiguration(); var entityConfiguration = modelConfiguration.Entity(typeof(AType5)); new InversePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration(typeof(AType5), () => entityConfiguration, modelConfiguration), new InversePropertyAttribute("A1")); Assert.False(entityConfiguration.IsNavigationPropertyConfigured(propertyInfo)); }
public void MapEntityType_with_configured_Entity_should_throw_with_StoreInline() { var type = typeof(TypeMapper_EntityWithStoreInline); var model = new EdmModel(DataSpace.CSpace); var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(typeof(TypeMapper_EntityWithStoreInline)); var typeMapper = new TypeMapper(new MappingContext(modelConfiguration, new ConventionsConfiguration(), model)); Assert.Equal( Strings.ComplexTypeConfigurationMismatch(type.Name), Assert.Throws <InvalidOperationException>(() => typeMapper.MapEntityType(type)).Message); }
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_adds_fk_column_when_nav_prop_is_valid() { var propertyInfo = typeof(BType2).GetInstanceProperty("AId"); var navigationPropertyInfo = typeof(BType2).GetInstanceProperty("A"); var modelConfiguration = new ModelConfiguration(); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration(typeof(BType2), () => modelConfiguration.Entity(typeof(BType2)), modelConfiguration), new ForeignKeyAttribute("A")); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType2)).Navigation(navigationPropertyInfo); Assert.NotNull(navigationPropertyConfiguration.Constraint); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { typeof(BType2).GetInstanceProperty("AId") }, foreignKeyConstraint.ToProperties); Assert.Null(navigationPropertyConfiguration.InverseNavigationProperty); }
public void Apply_throws_when_cannot_find_navigation_property() { var modelConfiguration = new ModelConfiguration(); Assert.Equal( Strings.ForeignKeyAttributeConvention_InvalidNavigationProperty("BId", typeof(AType1), "Missing"), Assert.Throws <InvalidOperationException>( () => new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( typeof(AType1).GetInstanceProperty("BId"), new ConventionTypeConfiguration( typeof(AType1), () => modelConfiguration.Entity(typeof(AType1)), modelConfiguration), new ForeignKeyAttribute("Missing"))).Message); }
public void MapEntityType_recognizes_TableName() { var type = typeof(TypeMapper_EntityWithTableName); var model = new EdmModel(DataSpace.CSpace); var modelConfiguration = new ModelConfiguration(); var typeMapper = new TypeMapper(new MappingContext(modelConfiguration, new ConventionsConfiguration(), model)); typeMapper.MapEntityType(type); Assert.False(modelConfiguration.IsComplexType(type)); Assert.Equal(1, model.EntityTypes.Count()); Assert.Equal(0, model.ComplexTypes.Count()); Assert.Equal("Foo", modelConfiguration.Entity(typeof(TypeMapper_EntityWithTableName)).GetTableName().Name); }
public void Apply_ignores_constraint_when_already_specified() { var mockTypeA = new MockType("A"); var mockTypeB = new MockType("B").Property <int>("AId1").Property <int>("AId2"); mockTypeB.Property(mockTypeA, "A"); var mockPropertyInfo = mockTypeB.GetProperty("A"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo); navigationPropertyConfiguration.Constraint = new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") }); new ForeignKeyPrimitivePropertyAttributeConvention() .Apply( mockTypeB.GetProperty("AId2"), new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration), new ForeignKeyAttribute("A")); var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint; Assert.Equal(new[] { mockTypeB.GetProperty("AId1") }, foreignKeyConstraint.ToProperties); }
public void Apply_throws_when_cannot_find_inverse_property() { var propertyInfo = typeof(AType7).GetInstanceProperty("B"); var modelConfiguration = new ModelConfiguration(); Assert.Equal( Strings.InversePropertyAttributeConvention_PropertyNotFound("Foo", typeof(BType7), "B", typeof(AType7)), Assert.Throws <InvalidOperationException>( () => new InversePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration( typeof(AType7), () => modelConfiguration.Entity(typeof(AType7)), modelConfiguration), new InversePropertyAttribute("Foo"))).Message); }
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 Apply_throws_on_self_inverse() { var propertyInfo = typeof(AType6).GetInstanceProperty("A"); var modelConfiguration = new ModelConfiguration(); Assert.Equal( Strings.InversePropertyAttributeConvention_SelfInverseDetected("A", typeof(AType6)), Assert.Throws <InvalidOperationException>( () => new InversePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration( typeof(AType6), () => modelConfiguration.Entity(typeof(AType6)), modelConfiguration), new InversePropertyAttribute("A"))).Message); }
public void Build_should_map_types() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(typeof(AType2)).Key(typeof(AType2).GetInstanceProperty("Id")); modelConfiguration.ComplexType(typeof(CType2)); var modelBuilder = new DbModelBuilder(modelConfiguration); var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping; Assert.NotNull(databaseMapping); Assert.Equal(1, databaseMapping.Model.EntityTypes.Count()); Assert.Equal(1, databaseMapping.Model.ComplexTypes.Count()); }
public void Build_should_apply_model_configuration() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(typeof(AType1)) .Property(new PropertyPath(typeof(AType1).GetInstanceProperty("Id"))) .ConcurrencyMode = ConcurrencyMode.Fixed; var databaseMapping = new DbModelBuilder(modelConfiguration).Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping; Assert.NotNull(databaseMapping); Assert.Equal( ConcurrencyMode.Fixed, databaseMapping.Model.EntityTypes.Single().DeclaredProperties.Single().ConcurrencyMode); }
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_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, modelConfiguration, new InversePropertyAttribute("B")); var navigationPropertyConfiguration = modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo); Assert.Same(mockTypeA.GetProperty("B"), navigationPropertyConfiguration.InverseNavigationProperty); }
public void HasConstraint_is_noop_when_set_on_inverse() { var modelConfiguration = new ModelConfiguration(); var inverseNavigationProperty = typeof(LightweighEntity).GetDeclaredProperty("PrivateNavigationProperty"); modelConfiguration.Entity(typeof(LightweighEntity)) .Navigation(inverseNavigationProperty) .Constraint = IndependentConstraintConfiguration.Instance; var configuration = new NavigationPropertyConfiguration( typeof(LightweighEntity).GetDeclaredProperty("ValidNavigationProperty")); configuration.InverseNavigationProperty = inverseNavigationProperty; var lightweightConfiguration = new ConventionNavigationPropertyConfiguration(configuration, modelConfiguration); lightweightConfiguration.HasConstraint <ForeignKeyConstraintConfiguration>(); Assert.Null(configuration.Constraint); }
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, new ConventionTypeConfiguration( mockTypeA, () => modelConfiguration.Entity(mockTypeA), modelConfiguration), new InversePropertyAttribute("A"))).Message); }
public void HasConstraint_is_noop_when_set_on_inverse() { var modelConfiguration = new ModelConfiguration(); var inverseNavigationProperty = typeof(LightweighEntity).GetDeclaredProperty("PrivateNavigationProperty"); modelConfiguration.Entity(typeof(LightweighEntity)) .Navigation(inverseNavigationProperty) .Constraint = IndependentConstraintConfiguration.Instance; var configuration = new NavigationPropertyConfiguration( typeof(LightweighEntity).GetDeclaredProperty("ValidNavigationProperty")); configuration.InverseNavigationProperty = inverseNavigationProperty; var lightweightConfiguration = new ConventionNavigationPropertyConfiguration(configuration, modelConfiguration); lightweightConfiguration.HasConstraint < ForeignKeyConstraintConfiguration>(); Assert.Null(configuration.Constraint); }
public void Configure_entity_splitting_should_throw_if_ignored_property_is_mapped() { EdmModel model = new TestModelBuilder() .Entity("E") .Key("P1"); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entityType = model.GetEntityType("E"); var modelConfiguration = new ModelConfiguration(); var entityConfiguration = modelConfiguration.Entity(entityType.GetClrType()); var p1PropertyInfo = entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo(); var entityMappingConfiguration1 = new EntityMappingConfiguration { Properties = new List<PropertyPath> { new PropertyPath(p1PropertyInfo), new PropertyPath(new MockPropertyInfo(typeof(int), "P2")) }, TableName = new DatabaseName("E") }; entityConfiguration.AddMappingConfiguration(entityMappingConfiguration1); Assert.Equal( Strings.EntityMappingConfiguration_CannotMapIgnoredProperty("E", "P2"), Assert.Throws<InvalidOperationException>( () => modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest)).Message); }
public void ConfiguredTypes_returns_all_known_types() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(new MockType()); modelConfiguration.ComplexType(new MockType()); modelConfiguration.Ignore(new MockType()); Assert.Equal(3, modelConfiguration.ConfiguredTypes.Count()); }
public void Can_add_and_get_entity_configuration() { var modelConfiguration = new ModelConfiguration(); var entityTypeConfiguration = new Mock<EntityTypeConfiguration>(typeof(object)).Object; modelConfiguration.Add(entityTypeConfiguration); Assert.Same(entityTypeConfiguration, modelConfiguration.Entity(typeof(object))); }
public void ComplexTypes_returns_only_configured_non_ignored_complex_types() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(new MockType()); var mockComplexType = new MockType(); modelConfiguration.ComplexType(mockComplexType); var mockIgnoredComplexType = new MockType(); modelConfiguration.ComplexType(mockIgnoredComplexType); modelConfiguration.Ignore(mockIgnoredComplexType); Assert.Same(mockComplexType.Object, modelConfiguration.ComplexTypes.Single()); }
public void Configure_mapping_can_process_entity_splitting() { EdmModel model = new TestModelBuilder() .Entity("E") .Key("P1") .Property("P2") .Property("P3") .Property("P4") .Property("P5"); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entityType = model.GetEntityType("E"); var modelConfiguration = new ModelConfiguration(); var entityMappingConfiguration1 = new EntityMappingConfiguration { Properties = new List<PropertyPath> { new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo()), new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P2").GetClrPropertyInfo()), new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P3").GetClrPropertyInfo()) }, TableName = new DatabaseName("E1") }; var entityMappingConfiguration2 = new EntityMappingConfiguration { Properties = new List<PropertyPath> { new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo()), new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P4").GetClrPropertyInfo()), new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P5").GetClrPropertyInfo()) }, TableName = new DatabaseName("E2") }; var entityConfiguration = modelConfiguration.Entity(entityType.GetClrType()); entityConfiguration.AddMappingConfiguration(entityMappingConfiguration1); entityConfiguration.AddMappingConfiguration(entityMappingConfiguration2); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType); var table1 = entityTypeMapping.TypeMappingFragments[0].Table; var table2 = entityTypeMapping.TypeMappingFragments[1].Table; Assert.NotSame(table1, table2); Assert.Equal("E1", table1.GetTableName().Name); Assert.Equal("E2", table2.GetTableName().Name); Assert.Equal(3, table1.Columns.Count); Assert.Equal(3, table2.Columns.Count); Assert.Equal(2, entityTypeMapping.TypeMappingFragments.Count); var entityTypeMappingFragment1 = entityTypeMapping.TypeMappingFragments[0]; var entityTypeMappingFragment2 = entityTypeMapping.TypeMappingFragments[1]; Assert.Equal(3, entityTypeMappingFragment1.PropertyMappings.Count); Assert.Equal("P1", entityTypeMappingFragment1.PropertyMappings[0].Column.Name); Assert.Equal("P2", entityTypeMappingFragment1.PropertyMappings[1].Column.Name); Assert.Equal("P3", entityTypeMappingFragment1.PropertyMappings[2].Column.Name); Assert.Equal(3, entityTypeMappingFragment2.PropertyMappings.Count); Assert.Equal("P1", entityTypeMappingFragment2.PropertyMappings[0].Column.Name); Assert.Equal("P4", entityTypeMappingFragment2.PropertyMappings[1].Column.Name); Assert.Equal("P5", entityTypeMappingFragment2.PropertyMappings[2].Column.Name); }
public void Entity_should_return_new_configuration_if_no_configuration_found() { var modelConfiguration = new ModelConfiguration(); Assert.NotNull(modelConfiguration.Entity(typeof(object))); }
public void Configure_mapping_can_process_one_level_TPH_on_both_sides_of_tree() { //Setup var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities(); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entityType1 = model.GetEntityType("E1"); var entityType2 = model.GetEntityType("E2"); var entityType3 = model.GetEntityType("E3"); // Action var modelConfiguration = new ModelConfiguration(); var entity1Configuration = modelConfiguration.Entity(entityType1.GetClrType()); var entity1MappingConfiguration = new EntityMappingConfiguration { TableName = new DatabaseName("E1") }; entity1MappingConfiguration .AddValueCondition( new ValueConditionConfiguration(entity1MappingConfiguration, "P3") { Value = null }); entity1MappingConfiguration .AddValueCondition( new ValueConditionConfiguration(entity1MappingConfiguration, "P4") { Value = null }); entity1Configuration.AddMappingConfiguration(entity1MappingConfiguration); var entity1SubTypeMappingConfiguration = new EntityMappingConfiguration { TableName = new DatabaseName("E1") }; entity1SubTypeMappingConfiguration .AddValueCondition( new ValueConditionConfiguration(entity1SubTypeMappingConfiguration, "P3") { Value = null }); entity1SubTypeMappingConfiguration .AddNullabilityCondition( new NotNullConditionConfiguration( entity1SubTypeMappingConfiguration, new PropertyPath(entityType3.GetDeclaredPrimitiveProperty("P4").GetClrPropertyInfo()))); entity1Configuration.AddSubTypeMappingConfiguration(entityType3.GetClrType(), entity1SubTypeMappingConfiguration); var entity2Configuration = modelConfiguration.Entity(entityType2.GetClrType()); var entity2MappingConfiguration = new EntityMappingConfiguration { TableName = new DatabaseName("E1") }; entity2MappingConfiguration .AddNullabilityCondition( new NotNullConditionConfiguration( entity2MappingConfiguration, new PropertyPath(entityType2.GetDeclaredPrimitiveProperty("P3").GetClrPropertyInfo()))); entity2MappingConfiguration .AddValueCondition( new ValueConditionConfiguration(entity2MappingConfiguration, "P4") { Value = null }); entity2Configuration.AddMappingConfiguration(entity2MappingConfiguration); modelConfiguration.NormalizeConfigurations(); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); //Validate var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1)); Assert.NotNull(entitySetMapping); Assert.Equal(4, entitySetMapping.EntityTypeMappings.Count); var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1); var entityType1MappingConditions = databaseMapping.GetEntityTypeMappings(entityType1).Single(x => !x.IsHierarchyMapping); var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2); var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3); var table1 = entityType1Mapping.TypeMappingFragments.Single().Table; var table2 = entityType2Mapping.TypeMappingFragments.Single().Table; var table3 = entityType3Mapping.TypeMappingFragments.Single().Table; Assert.True(entityType1Mapping.IsHierarchyMapping); Assert.Equal(4, table1.Columns.Count); Assert.Equal("P1", table1.Columns[0].Name); Assert.Equal("P2", table1.Columns[1].Name); Assert.Equal("P3", table1.Columns[2].Name); Assert.Equal("P4", table1.Columns[3].Name); Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal("P1", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P2", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Same(table1.Columns[2], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[0].Column); Assert.True((bool)entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[0].IsNull); Assert.Same(table1.Columns[3], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[1].Column); Assert.True((bool)entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[1].IsNull); Assert.False(entityType2Mapping.IsHierarchyMapping); Assert.Same(table1, table2); Assert.Same(table1.Columns[0], table2.Columns[0]); Assert.Same(table1.Columns[1], table2.Columns[1]); Assert.Equal(2, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal("P1", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P3", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Same(table1.Columns[3], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[0].Column); Assert.True((bool)entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[0].IsNull); Assert.Same(table1.Columns[2], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[1].Column); Assert.False((bool)entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[1].IsNull); Assert.False(entityType3Mapping.IsHierarchyMapping); Assert.Same(table1, table3); Assert.Same(table1.Columns[0], table3.Columns[0]); Assert.Same(table1.Columns[1], table3.Columns[1]); Assert.Equal(2, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal("P1", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P4", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Same(table1.Columns[2], entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[0].Column); Assert.True((bool)entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[0].IsNull); Assert.Same(table1.Columns[3], entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[1].Column); Assert.False((bool)entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[1].IsNull); }
public void Configure_mapping_can_process_simple_TPH_mapping() { //Setup var model = TestModelBuilderHelpers.CreateSimpleInheritanceTwoEntities(); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entityType1 = model.GetEntityType("E1"); var entityType2 = model.GetEntityType("E2"); // Action var modelConfiguration = new ModelConfiguration(); var entity1Configuration = modelConfiguration.Entity(entityType1.GetClrType()); var entity1MappingConfiguration = new EntityMappingConfiguration { TableName = new DatabaseName("E1") }; entity1MappingConfiguration .AddValueCondition( new ValueConditionConfiguration(entity1MappingConfiguration, "disc") { Value = "foo" }); entity1Configuration.AddMappingConfiguration(entity1MappingConfiguration); var entity1SubTypeMappingConfiguration = new EntityMappingConfiguration { TableName = new DatabaseName("E1") }; entity1SubTypeMappingConfiguration .AddValueCondition( new ValueConditionConfiguration(entity1SubTypeMappingConfiguration, "disc") { Value = "bar" }); entity1Configuration.AddSubTypeMappingConfiguration(entityType2.GetClrType(), entity1SubTypeMappingConfiguration); modelConfiguration.NormalizeConfigurations(); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); //Validate var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1)); Assert.NotNull(entitySetMapping); Assert.Equal(3, entitySetMapping.EntityTypeMappings.Count); var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1); var entityType1MappingConditions = databaseMapping.GetEntityTypeMappings(entityType1).Single(tm => !tm.IsHierarchyMapping); var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2); var table1 = entityType1Mapping.TypeMappingFragments.Single().Table; var table2 = entityType2Mapping.TypeMappingFragments.Single().Table; Assert.True(entityType1Mapping.IsHierarchyMapping); Assert.Equal(4, table1.Columns.Count); Assert.Equal("P1", table1.Columns[0].Name); Assert.Equal("P2", table1.Columns[1].Name); Assert.Equal("P3", table1.Columns[2].Name); Assert.Equal("disc", table1.Columns[3].Name); Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal("P1", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P2", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Same(table1.Columns[3], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column); Assert.Equal("foo", entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Value); Assert.Equal("nvarchar", entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column.TypeName); Assert.Equal( DatabaseMappingGenerator.DiscriminatorLength, entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column.Facets.MaxLength); Assert.False(entityType2Mapping.IsHierarchyMapping); Assert.Same(table1, table2); Assert.Equal(2, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Same(table1.Columns[0], table2.Columns[0]); Assert.Same(table1.Columns[1], table2.Columns[1]); Assert.Equal("P1", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P3", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Same(table2.Columns[3], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions.Single().Column); Assert.Equal("bar", entityType2Mapping.TypeMappingFragments.Single().ColumnConditions.Single().Value); }
public void Entity_should_throw_when_configuration_is_not_for_entity() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Add(new Mock<ComplexTypeConfiguration>(typeof(object)).Object); Assert.Equal( Strings.EntityTypeConfigurationMismatch(typeof(object)), Assert.Throws<InvalidOperationException>(() => modelConfiguration.Entity(typeof(object))).Message); }
public void Configure_mapping_can_process_one_level_TPC_on_both_sides_of_tree() { //Setup var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities(); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entityType1 = model.GetEntityType("E1"); var entityType2 = model.GetEntityType("E2"); var entityType3 = model.GetEntityType("E3"); // Action var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(entityType2.GetClrType()) .AddMappingConfiguration( new EntityMappingConfiguration { MapInheritedProperties = true, TableName = new DatabaseName("E2") }); modelConfiguration.Entity(entityType3.GetClrType()) .AddMappingConfiguration( new EntityMappingConfiguration { MapInheritedProperties = true, TableName = new DatabaseName("E3") }); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); //Validate var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1)); Assert.NotNull(entitySetMapping); Assert.Equal(3, entitySetMapping.EntityTypeMappings.Count); var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1); var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2); var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3); var table1 = entityType1Mapping.TypeMappingFragments.Single().Table; var table2 = entityType2Mapping.TypeMappingFragments.Single().Table; var table3 = entityType3Mapping.TypeMappingFragments.Single().Table; Assert.False(entityType1Mapping.IsHierarchyMapping); Assert.Equal(2, table1.Columns.Count); Assert.Equal("P1", table1.Columns[0].Name); Assert.Equal("P2", table1.Columns[1].Name); Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Same(entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table1.Columns[0]); Assert.Same(entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table1.Columns[1]); Assert.False(entityType2Mapping.IsHierarchyMapping); Assert.Equal("E2", table2.Name); Assert.Equal(3, table2.Columns.Count); Assert.Equal("P1", table2.Columns[0].Name); Assert.Equal("P2", table2.Columns[1].Name); Assert.Equal("P3", table2.Columns[2].Name); Assert.NotSame(table1, table2); Assert.NotSame(table1.Columns[0], table2.Columns[0]); Assert.NotSame(table1.Columns[1], table2.Columns[1]); Assert.Equal(3, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table2.Columns[0]); Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table2.Columns[1]); Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column, table2.Columns[2]); Assert.False(entityType3Mapping.IsHierarchyMapping); Assert.Equal("E3", table3.Name); Assert.Equal(3, table3.Columns.Count); Assert.Equal("P1", table3.Columns[0].Name); Assert.Equal("P2", table3.Columns[1].Name); Assert.Equal("P4", table3.Columns[2].Name); Assert.NotSame(table1, table3); Assert.NotSame(table3, table2); Assert.NotSame(table1.Columns[0], table3.Columns[0]); Assert.NotSame(table1.Columns[1], table3.Columns[1]); Assert.Equal(3, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table3.Columns[0]); Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table3.Columns[1]); Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column, table3.Columns[2]); }
public void Configure_mapping_can_configure_one_level_TPT_on_both_sides_of_tree() { //Setup var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities(); var entityType1 = model.GetEntityType("E1"); var entityType2 = model.GetEntityType("E2"); var entityType3 = model.GetEntityType("E3"); entityType1.GetDeclaredPrimitiveProperty("P1").SetStoreGeneratedPattern(DbStoreGeneratedPattern.Identity); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(entityType2.GetClrType()).ToTable("E2"); modelConfiguration.Entity(entityType3.GetClrType()).ToTable("E3"); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); var entityTypeMapping1 = databaseMapping.GetEntityTypeMapping(entityType1); var entityTypeMapping2 = databaseMapping.GetEntityTypeMapping(entityType2); var entityTypeMapping3 = databaseMapping.GetEntityTypeMapping(entityType3); var table1 = entityTypeMapping1.TypeMappingFragments.Single().Table; var table2 = entityTypeMapping2.TypeMappingFragments.Single().Table; var table3 = entityTypeMapping3.TypeMappingFragments.Single().Table; Assert.NotSame(table1, table2); Assert.NotSame(table1, table3); Assert.NotSame(table3, table2); Assert.True(entityTypeMapping1.IsHierarchyMapping); Assert.Equal(2, table1.Columns.Count); Assert.Equal("P1", table1.Columns[0].Name); Assert.Equal(DbStoreGeneratedPattern.Identity, table1.Columns[0].StoreGeneratedPattern); Assert.Equal("P2", table1.Columns[1].Name); Assert.Equal(2, entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal("P1", entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P2", entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.False(entityTypeMapping2.IsHierarchyMapping); Assert.Equal(2, entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal("P1", entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal(DbStoreGeneratedPattern.None, table2.Columns[0].StoreGeneratedPattern); Assert.Equal("P3", entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Equal(2, table2.Columns.Count); Assert.Equal("P1", table2.Columns[0].Name); Assert.Equal("P3", table2.Columns[1].Name); Assert.NotSame(table1.Columns[0], table2.Columns[0]); Assert.False(entityTypeMapping3.IsHierarchyMapping); Assert.Equal(2, entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal(DbStoreGeneratedPattern.None, table3.Columns[0].StoreGeneratedPattern); Assert.Equal("P1", entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P4", entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Equal(2, table3.Columns.Count); Assert.Equal("P1", table3.Columns[0].Name); Assert.Equal("P4", table3.Columns[1].Name); Assert.NotSame(table1.Columns[0], table3.Columns[0]); Assert.NotSame(table2.Columns[0], table3.Columns[0]); }