public void GetClrTypes_should_return_ospace_types() { var model = new EdmModel().Initialize(); model.AddEntityType("A").SetClrType(typeof(object)); model.AddEntityType("B").SetClrType(typeof(string)); Assert.Equal(2, model.GetClrTypes().Count()); }
public void HasCascadeDeletePath_should_return_true_for_simple_cascade() { var model = new EdmModel().Initialize(); var entityTypeA = model.AddEntityType("A"); var entityTypeB = model.AddEntityType("B"); var associationType = new EdmAssociationType().Initialize(); associationType.SourceEnd.EntityType = entityTypeA; associationType.TargetEnd.EntityType = entityTypeB; associationType.SourceEnd.DeleteAction = EdmOperationAction.Cascade; model.AddAssociationType(associationType); Assert.True(model.HasCascadeDeletePath(entityTypeA, entityTypeB)); Assert.False(model.HasCascadeDeletePath(entityTypeB, entityTypeA)); }
public void Configure_should_configure_inverse() { var inverseMockPropertyInfo = new MockPropertyInfo(); var navigationPropertyConfiguration = new NavigationPropertyConfiguration(new MockPropertyInfo()) { InverseNavigationProperty = inverseMockPropertyInfo }; var associationType = new EdmAssociationType().Initialize(); var inverseAssociationType = new EdmAssociationType().Initialize(); var model = new EdmModel().Initialize(); model.AddAssociationType(inverseAssociationType); var inverseNavigationProperty = model.AddEntityType("T") .AddNavigationProperty("N", inverseAssociationType); inverseNavigationProperty.SetClrPropertyInfo(inverseMockPropertyInfo); navigationPropertyConfiguration.Configure( new EdmNavigationProperty { Association = associationType }, model, new EntityTypeConfiguration(typeof(object))); Assert.Same(associationType, inverseNavigationProperty.Association); Assert.Same(associationType.SourceEnd, inverseNavigationProperty.ResultEnd); Assert.Equal(0, model.GetAssociationTypes().Count()); }
public void Generate_should_correctly_map_string_primitive_property_facets() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); entityType.SetClrType(typeof(object)); model.AddEntitySet("ESet", entityType); var property = entityType.AddPrimitiveProperty("P"); property.PropertyType.EdmType = EdmPrimitiveType.String; property.PropertyType.IsNullable = false; property.PropertyType.PrimitiveTypeFacets.IsFixedLength = true; property.PropertyType.PrimitiveTypeFacets.IsMaxLength = true; property.PropertyType.PrimitiveTypeFacets.IsUnicode = true; property.PropertyType.PrimitiveTypeFacets.MaxLength = 42; property.PropertyType.PrimitiveTypeFacets.Precision = 23; property.PropertyType.PrimitiveTypeFacets.Scale = 77; property.SetStoreGeneratedPattern(DbStoreGeneratedPattern.Identity); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var column = databaseMapping.GetEntityTypeMapping(entityType).TypeMappingFragments.Single().PropertyMappings.Single().Column; Assert.False(column.IsNullable); Assert.Null(column.Facets.IsFixedLength); Assert.Equal(true, column.Facets.IsMaxLength); Assert.Null(column.Facets.IsUnicode); Assert.Equal(42, column.Facets.MaxLength); Assert.Null(column.Facets.Precision); Assert.Null(column.Facets.Scale); Assert.Equal(DbStoreGeneratedPattern.Identity, column.StoreGeneratedPattern); }
public void ApplyModel_should_run_targeted_model_conventions() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); var mockConvention = new Mock<IEdmConvention<EdmEntityType>>(); var conventionsConfiguration = new ConventionsConfiguration(new IConvention[] { mockConvention.Object }); conventionsConfiguration.ApplyModel(model); mockConvention.Verify(c => c.Apply(entityType, model), Times.AtMostOnce()); }
private static DbDatabaseMapping CreateSimpleModel(double version) { var model = new EdmModel().Initialize(version); var entityType = model.AddEntityType("E"); entityType.SetClrType(typeof(object)); model.AddEntitySet("ESet", entityType); var property = entityType.AddPrimitiveProperty("Id"); property.PropertyType.EdmType = EdmPrimitiveType.Int32; property.PropertyType.IsNullable = false; entityType.DeclaredKeyProperties.Add(property); return new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); }
public void Apply_generates_constraint_when_simple_fk() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); var associationType = model.AddAssociationType("A", entityType, EdmAssociationEndKind.Optional, entityType, EdmAssociationEndKind.Many); var navigationProperty = entityType.AddNavigationProperty("N", associationType); var fkProperty = entityType.AddPrimitiveProperty("Fk"); var foreignKeyAnnotation = new ForeignKeyAttribute("Fk"); navigationProperty.Annotations.SetClrAttributes(new[] { foreignKeyAnnotation }); ((IEdmConvention<EdmNavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention()) .Apply(navigationProperty, model); Assert.NotNull(associationType.Constraint); Assert.True(associationType.Constraint.DependentProperties.Contains(fkProperty)); }
public void Configure_should_configure_active_entities_and_complex_types() { var mockEntityType = new MockType(); var mockComplexType = new MockType(); var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); entityType.SetClrType(mockEntityType); var complexType = model.AddComplexType("C"); complexType.SetClrType(mockComplexType); var modelConfiguration = new ModelConfiguration(); var mockComplexTypeConfiguration = new Mock<ComplexTypeConfiguration>(mockComplexType.Object); var mockEntityTypeConfiguration = new Mock<EntityTypeConfiguration>(mockEntityType.Object); modelConfiguration.Add(mockComplexTypeConfiguration.Object); modelConfiguration.Add(mockEntityTypeConfiguration.Object); modelConfiguration.Configure(model); mockComplexTypeConfiguration.Verify(c => c.Configure(complexType)); mockEntityTypeConfiguration.Verify(c => c.Configure(entityType, model)); }
public void Generate_can_map_a_simple_entity_type_and_set() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); entityType.SetClrType(typeof(object)); entityType.AddPrimitiveProperty("P1").PropertyType.EdmType = EdmPrimitiveType.Int32; entityType.AddPrimitiveProperty("P2").PropertyType.EdmType = EdmPrimitiveType.String; var entitySet = model.AddEntitySet("ESet", entityType); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet); Assert.NotNull(entitySetMapping); Assert.Same(entitySet, entitySetMapping.EntitySet); var entityTypeMapping = entitySetMapping.EntityTypeMappings.Single(); Assert.Same(entityType, entityTypeMapping.EntityType); Assert.NotNull(entityTypeMapping.TypeMappingFragments.Single().Table); Assert.Equal("E", entityTypeMapping.TypeMappingFragments.Single().Table.Name); Assert.Equal(2, entityTypeMapping.TypeMappingFragments.Single().Table.Columns.Count); Assert.Equal(typeof(object), entityTypeMapping.GetClrType()); }
public void Generate_should_map_entity_keys_to_primary_keys() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); entityType.SetClrType(typeof(object)); var idProperty = entityType.AddPrimitiveProperty("Id"); idProperty.PropertyType.EdmType = EdmPrimitiveType.Int32; entityType.DeclaredKeyProperties.Add(idProperty); var entitySet = model.AddEntitySet("ESet", entityType); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet); var entityTypeMapping = entitySetMapping.EntityTypeMappings.Single(); Assert.Equal(1, entityTypeMapping.TypeMappingFragments.Single().Table.KeyColumns.Count()); Assert.Equal("Id", entityTypeMapping.TypeMappingFragments.Single().Table.KeyColumns.Single().Name); Assert.True(entityTypeMapping.TypeMappingFragments.Single().Table.KeyColumns.Single().IsPrimaryKeyColumn); }
public void GetDerivedTypes_must_return_list_of_direct_descendants() { var model = new EdmModel().Initialize(); var entity1 = model.AddEntityType("E1"); var entity2 = model.AddEntityType("E2"); var entity3 = model.AddEntityType("E3"); var entity4 = model.AddEntityType("E4"); entity2.BaseType = entity1; entity3.BaseType = entity1; entity4.BaseType = entity2; var derivedTypes = model.GetDerivedTypes(entity1).ToList(); Assert.Equal(2, derivedTypes.Count); Assert.Same(entity2, derivedTypes[0]); Assert.Same(entity3, derivedTypes[1]); }
public void AddAssociationSet_should_create_and_add_to_default_container() { var model = new EdmModel().Initialize(); var sourceEntityType = model.AddEntityType("Source"); var targetEntityType = model.AddEntityType("Target"); var associationType = model.AddAssociationType( "Foo", sourceEntityType, EdmAssociationEndKind.Required, targetEntityType, EdmAssociationEndKind.Many); var associationSet = model.AddAssociationSet("FooSet", associationType); Assert.NotNull(associationSet); Assert.Equal("FooSet", associationSet.Name); Assert.Same(associationType, associationSet.ElementType); Assert.True(model.Containers.Single().AssociationSets.Contains(associationSet)); }
public void AddAssociationType_should_create_and_add_to_default_namespace() { var model = new EdmModel().Initialize(); var sourceEntityType = model.AddEntityType("Source"); var targetEntityType = model.AddEntityType("Target"); var associationType = model.AddAssociationType( "Foo", sourceEntityType, EdmAssociationEndKind.Required, targetEntityType, EdmAssociationEndKind.Many); Assert.NotNull(associationType); Assert.Equal("Foo", associationType.Name); Assert.Same(sourceEntityType, associationType.SourceEnd.EntityType); Assert.Equal(EdmAssociationEndKind.Required, associationType.SourceEnd.EndKind); Assert.Same(targetEntityType, associationType.TargetEnd.EntityType); Assert.Equal(EdmAssociationEndKind.Many, associationType.TargetEnd.EndKind); Assert.True(model.Namespaces.Single().AssociationTypes.Contains(associationType)); }
public void RemoveEntityType_should_remove_type_and_set() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("Foo"); model.AddEntitySet("FooSet", entityType); model.RemoveEntityType(entityType); Assert.Equal(0, model.GetEntityTypes().Count()); Assert.Equal(0, model.Containers.First().EntitySets.Count()); }
public void AddEntitySet_should_create_and_add_to_default_container() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("Foo"); var entitySet = model.AddEntitySet("FooSet", entityType); Assert.NotNull(entitySet); Assert.Equal("FooSet", entitySet.Name); Assert.Same(entityType, entitySet.ElementType); Assert.True(model.Containers.Single().EntitySets.Contains(entitySet)); }
public void Generate_can_map_type_hierarchies_using_Tph() { var model = new EdmModel().Initialize(); var rootEntityType = model.AddEntityType("E"); rootEntityType.SetClrType(typeof(object)); rootEntityType.AddPrimitiveProperty("P1").PropertyType.EdmType = EdmPrimitiveType.Int32; rootEntityType.AddPrimitiveProperty("P2").PropertyType.EdmType = EdmPrimitiveType.String; var entitySet = model.AddEntitySet("ESet", rootEntityType); var entityType2 = model.AddEntityType("E2"); entityType2.AddPrimitiveProperty("P3").PropertyType.EdmType = EdmPrimitiveType.Decimal; entityType2.SetClrType(typeof(string)); entityType2.BaseType = rootEntityType; var entityType3 = model.AddEntityType("E3"); entityType3.SetClrType(typeof(int)); entityType3.AddPrimitiveProperty("P4").PropertyType.EdmType = EdmPrimitiveType.Int32; entityType3.BaseType = entityType2; var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet); Assert.NotNull(entitySetMapping); var entityTypeMappings = entitySetMapping.EntityTypeMappings; Assert.Equal(3, entityTypeMappings.Count); var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType); var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2); var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3); Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal(3, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal(4, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count); var table = entityType1Mapping.TypeMappingFragments.Single().Table; Assert.Same(table, entityType2Mapping.TypeMappingFragments.Single().Table); Assert.Same(table, entityType3Mapping.TypeMappingFragments.Single().Table); Assert.Equal(5, table.Columns.Count); Assert.Equal("P1", table.Columns[0].Name); Assert.Equal("P2", table.Columns[1].Name); Assert.Equal("P3", table.Columns[2].Name); Assert.Equal("P4", table.Columns[3].Name); Assert.Equal("Discriminator", table.Columns[4].Name); }
public void Generate_can_map_foreign_key_association_type() { var model = new EdmModel().Initialize(); var principalEntityType = model.AddEntityType("P"); principalEntityType.SetClrType(typeof(object)); var dependentEntityType = model.AddEntityType("D"); dependentEntityType.SetClrType(typeof(string)); var dependentProperty1 = dependentEntityType.AddPrimitiveProperty("FK1"); dependentProperty1.PropertyType.EdmType = EdmPrimitiveType.Int32; var dependentProperty2 = dependentEntityType.AddPrimitiveProperty("FK2"); dependentProperty2.PropertyType.EdmType = EdmPrimitiveType.String; model.AddEntitySet("PSet", principalEntityType); model.AddEntitySet("DSet", dependentEntityType); var associationType = model.AddAssociationType("P_D", principalEntityType, EdmAssociationEndKind.Required, dependentEntityType, EdmAssociationEndKind.Many); associationType.Constraint = new EdmAssociationConstraint { DependentEnd = associationType.TargetEnd, DependentProperties = new[] { dependentProperty1, dependentProperty2 }, }; associationType.SourceEnd.DeleteAction = EdmOperationAction.Cascade; var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var dependentTable = databaseMapping.GetEntityTypeMapping(dependentEntityType).TypeMappingFragments.Single().Table; var foreignKeyConstraint = dependentTable.ForeignKeyConstraints.Single(); Assert.Equal(2, dependentTable.Columns.Count()); Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count); Assert.Equal(DbOperationAction.Cascade, foreignKeyConstraint.DeleteAction); Assert.Equal(associationType.Name, foreignKeyConstraint.Name); var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First(); Assert.False(foreignKeyColumn.IsNullable); Assert.Equal("FK1", foreignKeyColumn.Name); }
public void AddEntityType_should_create_and_add_to_default_namespace() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("Foo"); Assert.NotNull(entityType); Assert.Equal("Foo", entityType.Name); Assert.True(model.Namespaces.Single().EntityTypes.Contains(entityType)); }
public void Apply_throws_with_empty_foreign_key_properties() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); var mockType = new MockType(); entityType.SetClrType(mockType); var associationType = model.AddAssociationType("A", entityType, EdmAssociationEndKind.Optional, entityType, EdmAssociationEndKind.Many); var navigationProperty = entityType.AddNavigationProperty("N", associationType); var foreignKeyAnnotation = new ForeignKeyAttribute(","); navigationProperty.Annotations.SetClrAttributes(new[] { foreignKeyAnnotation }); Assert.Equal(Strings.ForeignKeyAttributeConvention_EmptyKey("N", mockType.Object), Assert.Throws<InvalidOperationException>(() => ((IEdmConvention<EdmNavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention()) .Apply(navigationProperty, model)).Message); }
public void GetAssociationSet_should_return_association_set() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("Foo"); model.AddEntitySet("FooSet", entityType); var associationType = new EdmAssociationType().Initialize(); associationType.SourceEnd.EntityType = entityType; associationType.TargetEnd.EntityType = entityType; model.AddAssociationSet("FooSet", associationType); var associationSet = model.GetAssociationSet(associationType); Assert.NotNull(associationSet); Assert.Same(associationType, associationSet.ElementType); }
public void GetEntitySet_should_return_entity_set() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("Foo"); model.AddEntitySet("FooSet", entityType); var entitySet = model.GetEntitySet(entityType); Assert.NotNull(entitySet); Assert.Same(entityType, entitySet.ElementType); }
private static EdmModel CreateModelFixture( out EdmEntityType declaringEntityType, out EdmEntityType complexEntityType) { var model = new EdmModel().Initialize(); declaringEntityType = model.AddEntityType("E"); complexEntityType = model.AddEntityType("C"); complexEntityType.AddPrimitiveProperty("P"); var associationType = model.AddAssociationType( "A", declaringEntityType, EdmAssociationEndKind.Many, complexEntityType, EdmAssociationEndKind.Optional); declaringEntityType.AddNavigationProperty("E.C", associationType); return model; }
public void GetEntityType_should_return_correct_type() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("Foo"); var foundEntityType = model.GetEntityType("Foo"); Assert.NotNull(foundEntityType); Assert.Same(entityType, foundEntityType); }
public void GetStructuralType_should_return_entity_or_complex_type() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); var complexType = model.AddComplexType("C"); Assert.Same(entityType, model.GetStructuralType("E")); Assert.Same(complexType, model.GetStructuralType("C")); }
public void Generate_maps_abstract_type_hierarchies_correctly() { var model = new EdmModel().Initialize(); var rootEntityType = model.AddEntityType("E"); rootEntityType.SetClrType(typeof(object)); rootEntityType.AddPrimitiveProperty("P1").PropertyType.EdmType = EdmPrimitiveType.Int32; rootEntityType.DeclaredKeyProperties.Add(rootEntityType.Properties.First()); rootEntityType.AddPrimitiveProperty("P2").PropertyType.EdmType = EdmPrimitiveType.String; model.AddEntitySet("ESet", rootEntityType); var entityType2 = model.AddEntityType("E2"); entityType2.AddPrimitiveProperty("P3").PropertyType.EdmType = EdmPrimitiveType.Decimal; entityType2.SetClrType(typeof(string)); entityType2.IsAbstract = true; entityType2.BaseType = rootEntityType; var entityType3 = model.AddEntityType("E3"); entityType3.SetClrType(typeof(int)); entityType3.AddPrimitiveProperty("P4").PropertyType.EdmType = EdmPrimitiveType.Int32; entityType3.BaseType = entityType2; var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType); var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3); 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.Equal(4, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count); Assert.Equal("P1", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name); Assert.Equal("P2", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name); Assert.Equal("P3", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column.Name); Assert.Equal("P4", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[3].Column.Name); var table = entityType1Mapping.TypeMappingFragments.Single().Table; Assert.Equal(5, table.Columns.Count); }
public void GetAssociationsBetween_should_return_matching_associations() { var model = new EdmModel().Initialize(); var entityTypeA = model.AddEntityType("Foo"); var entityTypeB = model.AddEntityType("Bar"); Assert.Equal(0, model.GetAssociationTypesBetween(entityTypeA, entityTypeB).Count()); model.AddAssociationType( "Foo_Bar", entityTypeA, EdmAssociationEndKind.Optional, entityTypeB, EdmAssociationEndKind.Many); model.AddAssociationType( "Bar_Foo", entityTypeB, EdmAssociationEndKind.Optional, entityTypeA, EdmAssociationEndKind.Many); Assert.Equal(2, model.GetAssociationTypesBetween(entityTypeA, entityTypeB).Count()); Assert.Equal(2, model.GetAssociationTypesBetween(entityTypeB, entityTypeA).Count()); Assert.Equal(0, model.GetAssociationTypesBetween(entityTypeA, entityTypeA).Count()); }
public void TypeHierarchyIterator_should_return_entity_types_in_depth_first_order() { var model = new EdmModel().Initialize(); var entityTypeRoot = model.AddEntityType("Root"); var derivedType1 = model.AddEntityType("DType1"); var derivedType2 = model.AddEntityType("DType2"); derivedType1.BaseType = entityTypeRoot; derivedType2.BaseType = entityTypeRoot; var derivedType1_1 = model.AddEntityType("DType1_1"); var derivedType1_2 = model.AddEntityType("DType1_2"); derivedType1_1.BaseType = derivedType1; derivedType1_2.BaseType = derivedType1; var typesVisited = new List<EdmEntityType>(); foreach (var derivedType in entityTypeRoot.TypeHierarchyIterator(model)) { typesVisited.Add(derivedType); } var oracle = new List<EdmEntityType> { entityTypeRoot, derivedType1, derivedType1_1, derivedType1_2, derivedType2 }; Assert.Equal(true, oracle.SequenceEqual(typesVisited)); }