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); }
/// <summary> /// Registers an entity type as part of the model and returns an object that can be used to /// configure the entity. This method can be called multiple times for the same entity to /// perform multiple lines of configuration. /// </summary> /// <typeparam name="TEntityType"> The type to be registered or configured. </typeparam> /// <returns> The configuration object for the specified entity type. </returns> public virtual EntityTypeConfiguration <TEntityType> Entity <TEntityType>() where TEntityType : class { return (new EntityTypeConfiguration <TEntityType>( _modelConfiguration.Entity(typeof(TEntityType), explicitEntity: true))); }
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_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 Configure_should_uniquify_unconfigured_association_function_names() { var mockPropertyInfo = typeof(BType1).GetDeclaredProperty("As"); var modelConfiguration = new ModelConfiguration(); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType1)).Navigation(mockPropertyInfo); navigationPropertyConfiguration.ModificationStoredProceduresConfiguration = new ModificationStoredProceduresConfiguration(); var modificationFunctionConfiguration = new ModificationStoredProcedureConfiguration(); modificationFunctionConfiguration.HasName("AB_Delete"); navigationPropertyConfiguration.ModificationStoredProceduresConfiguration .Insert(modificationFunctionConfiguration); var model = new EdmModel(DataSpace.CSpace); var entityA = model.AddEntityType("A"); entityA.GetMetadataProperties().SetClrType(typeof(AType1)); entityA.SetConfiguration(modelConfiguration.Entity(typeof(AType1))); var entityB = model.AddEntityType("B"); entityB.GetMetadataProperties().SetClrType(typeof(BType1)); entityB.SetConfiguration(modelConfiguration.Entity(typeof(BType1))); 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_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest) .Generate(model); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); Assert.True(databaseMapping.Database.Functions.Any(f => f.StoreFunctionNameAttribute == "AB_Delete")); Assert.True(databaseMapping.Database.Functions.Any(f => f.StoreFunctionNameAttribute == "AB_Delete1")); }
public void Apply_finds_inverse_when_optional_to_optional() { var propertyInfo = typeof(BType3).GetInstanceProperty("A"); var modelConfiguration = new ModelConfiguration(); new InversePropertyAttributeConvention() .Apply( propertyInfo, new ConventionTypeConfiguration(typeof(BType3), () => modelConfiguration.Entity(typeof(BType3)), modelConfiguration), new InversePropertyAttribute("B")); var navigationPropertyConfiguration = modelConfiguration.Entity(typeof(BType3)).Navigation(propertyInfo); Assert.Same(typeof(AType3).GetDeclaredProperty("B"), navigationPropertyConfiguration.InverseNavigationProperty); }
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 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 static void ConfigureEdmMetadata(ModelConfiguration modelConfiguration) { //Contract.Requires(modelConfiguration != null); #pragma warning disable 612,618 modelConfiguration.Entity(typeof(EdmMetadata)).ToTable(TableName); #pragma warning restore 612,618 }
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_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 Configure_should_uniquify_unconfigured_function_names() { var modelConfiguration = new ModelConfiguration(); var typeA = new MockType("A"); var typeB = new MockType("B"); modelConfiguration.Entity(typeA).MapToStoredProcedures(); var modificationFunctionsConfiguration = new ModificationStoredProceduresConfiguration(); var modificationFunctionConfiguration = new ModificationStoredProcedureConfiguration(); modificationFunctionConfiguration.HasName("A_Insert"); modificationFunctionsConfiguration.Insert(modificationFunctionConfiguration); modelConfiguration.Entity(typeB).MapToStoredProcedures(modificationFunctionsConfiguration, true); var model = new EdmModel(DataSpace.CSpace); var entityA = model.AddEntityType("A"); entityA.GetMetadataProperties().SetClrType(typeA); entityA.SetConfiguration(modelConfiguration.Entity(typeA)); var entityB = model.AddEntityType("B"); entityB.GetMetadataProperties().SetClrType(typeB); entityB.SetConfiguration(modelConfiguration.Entity(typeB)); model.AddEntitySet("AS", entityA); model.AddEntitySet("BS", entityB); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest) .Generate(model); modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); Assert.True(databaseMapping.Database.Functions.Any(f => f.StoreFunctionNameAttribute == "A_Insert")); Assert.True(databaseMapping.Database.Functions.Any(f => f.StoreFunctionNameAttribute == "A_Insert1")); }
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_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 AddConfigurationTypesToModel_adds_entitytypeconfigurations_into_model() { var entityTypeConfiguration = new EntityTypeConfiguration(typeof(Random)); var filter = new Mock<ConfigurationTypeFilter>(); filter.Setup(f => f.IsEntityTypeConfiguration(It.IsAny<Type>())).Returns(true); var activator = new Mock<ConfigurationTypeActivator>(); activator.Setup(a => a.Activate<EntityTypeConfiguration>(It.IsAny<Type>())) .Returns(entityTypeConfiguration); var finder = new ConfigurationTypesFinder(activator.Object, filter.Object); var modelConfiguration = new ModelConfiguration(); finder.AddConfigurationTypesToModel(new[] { typeof(Object) }, modelConfiguration); Assert.Same(entityTypeConfiguration, modelConfiguration.Entity(typeof(Random))); }
public void AddConfigurationTypesToModel_adds_entitytypeconfigurations_into_model() { var entityTypeConfiguration = new EntityTypeConfiguration(typeof(Random)); var filter = new Mock <ConfigurationTypeFilter>(); filter.Setup(f => f.IsEntityTypeConfiguration(It.IsAny <Type>())).Returns(true); var activator = new Mock <ConfigurationTypeActivator>(); activator.Setup(a => a.Activate <EntityTypeConfiguration>(It.IsAny <Type>())) .Returns(entityTypeConfiguration); var finder = new ConfigurationTypesFinder(activator.Object, filter.Object); var modelConfiguration = new ModelConfiguration(); finder.AddConfigurationTypesToModel(new[] { typeof(Object) }, modelConfiguration); Assert.Same(entityTypeConfiguration, modelConfiguration.Entity(typeof(Random))); }
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 Entity_should_return_new_configuration_if_no_configuration_found() { var modelConfiguration = new ModelConfiguration(); Assert.NotNull(modelConfiguration.Entity(typeof(object))); }
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 Configure_should_not_throw_when_only_derived_type_mapped_to_function_but_base_is_abstract() { var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(typeof(BType2)); modelConfiguration.Entity(typeof(CType2)).MapToStoredProcedures(); var model = new EdmModel(DataSpace.CSpace); var baseEntity = model.AddEntityType("Base"); baseEntity.GetMetadataProperties().SetClrType(typeof(BType2)); baseEntity.Abstract = true; var derivedEntity = model.AddEntityType("Derived"); derivedEntity.GetMetadataProperties().SetClrType(typeof(CType2)); derivedEntity.BaseType = baseEntity; modelConfiguration.Configure(model); Assert.NotNull(modelConfiguration.Entity(typeof(BType2)).ModificationStoredProceduresConfiguration); Assert.NotNull(modelConfiguration.Entity(typeof(CType2)).ModificationStoredProceduresConfiguration); }
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 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 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 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 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_simple_TPH_mapping() { //Setup var model = TestModelBuilderHelpers.CreateSimpleInheritanceTwoEntities(); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, 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.MappingFragments.Single().Table; var table2 = entityType2Mapping.MappingFragments.Single().Table; Assert.True(entityType1Mapping.IsHierarchyMapping); Assert.Equal(4, table1.Properties.Count); Assert.Equal("P1", table1.Properties[0].Name); Assert.Equal("P2", table1.Properties[1].Name); Assert.Equal("P3", table1.Properties[2].Name); Assert.Equal("disc", table1.Properties[3].Name); Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count()); Assert.Equal("P1", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name); Assert.Equal("P2", entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name); Assert.Same( table1.Properties[3], entityType1MappingConditions.MappingFragments.Single().ColumnConditions.Single().Column); Assert.Equal("foo", entityType1MappingConditions.MappingFragments.Single().ColumnConditions.Single().Value); Assert.Equal( "nvarchar", entityType1MappingConditions.MappingFragments.Single().ColumnConditions.Single().Column.TypeName); Assert.Equal( DatabaseMappingGenerator.DiscriminatorMaxLength, entityType1MappingConditions.MappingFragments.Single().ColumnConditions.Single().Column.MaxLength); Assert.False(entityType2Mapping.IsHierarchyMapping); Assert.Same(table1, table2); Assert.Equal(2, entityType2Mapping.MappingFragments.Single().ColumnMappings.Count()); Assert.Same(table1.Properties[0], table2.Properties[0]); Assert.Same(table1.Properties[1], table2.Properties[1]); Assert.Equal("P1", entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name); Assert.Equal("P3", entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name); Assert.Same(table2.Properties[3], entityType2Mapping.MappingFragments.Single().ColumnConditions.Single().Column); Assert.Equal("bar", entityType2Mapping.MappingFragments.Single().ColumnConditions.Single().Value); }
public void TPC_with_IA_on_non_leaf_type_not_allowed() { new Exception("The association 'Related_to_Base' between entity types 'Related' and 'Base' is invalid. In a TPC hierarchy independent associations are only allowed on the most derived types.") .ValidateMessage("EntityMappingConfiguration_TPCWithIAsOnNonLeafType", "Related_to_Base", "Related", "Base"); var modelBuilder = new TestModelBuilder() .Entity("Base") .Key("P1") .Property("P2") .Subclass("Derived"); modelBuilder.Entity("Related"); modelBuilder.Association( "Related_To_Base", "Related", RelationshipMultiplicity.One, "BaseEntities", "Base", RelationshipMultiplicity.Many, "RelatedEntities"); EdmModel model = modelBuilder; var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest) .Generate(model); var modelConfiguration = new ModelConfiguration(); modelConfiguration.Entity(model.GetEntityType("Derived").GetClrType()) .AddMappingConfiguration( new EntityMappingConfiguration { MapInheritedProperties = true, TableName = new DatabaseName("DerivedEntities") }); Assert.Throws<InvalidOperationException>( () => modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest)) .ValidateMessage("EntityMappingConfiguration_TPCWithIAsOnNonLeafType", "Related_To_Base", "Related", "Base"); }
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_ProviderInfo, 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.MappingFragments.Single().Table; var table2 = entityType2Mapping.MappingFragments.Single().Table; var table3 = entityType3Mapping.MappingFragments.Single().Table; Assert.False(entityType1Mapping.IsHierarchyMapping); Assert.Equal(2, table1.Properties.Count); Assert.Equal("P1", table1.Properties[0].Name); Assert.Equal("P2", table1.Properties[1].Name); Assert.Equal(2, entityType1Mapping.MappingFragments.Single().ColumnMappings.Count()); Assert.Same(entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty, table1.Properties[0]); Assert.Same(entityType1Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty, table1.Properties[1]); Assert.False(entityType2Mapping.IsHierarchyMapping); Assert.Equal("E2", table2.Name); Assert.Equal(3, table2.Properties.Count); Assert.Equal("P1", table2.Properties[0].Name); Assert.Equal("P2", table2.Properties[1].Name); Assert.Equal("P3", table2.Properties[2].Name); Assert.NotSame(table1, table2); Assert.NotSame(table1.Properties[0], table2.Properties[0]); Assert.NotSame(table1.Properties[1], table2.Properties[1]); Assert.Equal(3, entityType2Mapping.MappingFragments.Single().ColumnMappings.Count()); Assert.Same(entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty, table2.Properties[0]); Assert.Same(entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty, table2.Properties[1]); Assert.Same(entityType2Mapping.MappingFragments.Single().ColumnMappings.ElementAt(2).ColumnProperty, table2.Properties[2]); Assert.False(entityType3Mapping.IsHierarchyMapping); Assert.Equal("E3", table3.Name); Assert.Equal(3, table3.Properties.Count); Assert.Equal("P1", table3.Properties[0].Name); Assert.Equal("P2", table3.Properties[1].Name); Assert.Equal("P4", table3.Properties[2].Name); Assert.NotSame(table1, table3); Assert.NotSame(table3, table2); Assert.NotSame(table1.Properties[0], table3.Properties[0]); Assert.NotSame(table1.Properties[1], table3.Properties[1]); Assert.Equal(3, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count()); Assert.Same(entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty, table3.Properties[0]); Assert.Same(entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty, table3.Properties[1]); Assert.Same(entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(2).ColumnProperty, table3.Properties[2]); }
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).Name), Assert.Throws<InvalidOperationException>(() => modelConfiguration.Entity(typeof(object))).Message); }
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.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == "P1")).SetStoreGeneratedPattern( StoreGeneratedPattern.Identity); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, 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.MappingFragments.Single().Table; var table2 = entityTypeMapping2.MappingFragments.Single().Table; var table3 = entityTypeMapping3.MappingFragments.Single().Table; Assert.NotSame(table1, table2); Assert.NotSame(table1, table3); Assert.NotSame(table3, table2); Assert.True(entityTypeMapping1.IsHierarchyMapping); Assert.Equal(2, table1.Properties.Count); Assert.Equal("P1", table1.Properties[0].Name); Assert.Equal(StoreGeneratedPattern.Identity, table1.Properties[0].StoreGeneratedPattern); Assert.Equal("P2", table1.Properties[1].Name); Assert.Equal(2, entityTypeMapping1.MappingFragments.Single().ColumnMappings.Count()); Assert.Equal("P1", entityTypeMapping1.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name); Assert.Equal("P2", entityTypeMapping1.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name); Assert.False(entityTypeMapping2.IsHierarchyMapping); Assert.Equal(2, entityTypeMapping2.MappingFragments.Single().ColumnMappings.Count()); Assert.Equal("P1", entityTypeMapping2.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name); Assert.Equal(StoreGeneratedPattern.None, table2.Properties[0].StoreGeneratedPattern); Assert.Equal("P3", entityTypeMapping2.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name); Assert.Equal(2, table2.Properties.Count); Assert.Equal("P1", table2.Properties[0].Name); Assert.Equal("P3", table2.Properties[1].Name); Assert.NotSame(table1.Properties[0], table2.Properties[0]); Assert.False(entityTypeMapping3.IsHierarchyMapping); Assert.Equal(2, entityTypeMapping3.MappingFragments.Single().ColumnMappings.Count()); Assert.Equal(StoreGeneratedPattern.None, table3.Properties[0].StoreGeneratedPattern); Assert.Equal("P1", entityTypeMapping3.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name); Assert.Equal("P4", entityTypeMapping3.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name); Assert.Equal(2, table3.Properties.Count); Assert.Equal("P1", table3.Properties[0].Name); Assert.Equal("P4", table3.Properties[1].Name); Assert.NotSame(table1.Properties[0], table3.Properties[0]); Assert.NotSame(table2.Properties[0], table3.Properties[0]); }