public void HasCascadeDeletePath_should_return_true_for_transitive_cascade() { var model = new EdmModel(DataSpace.CSpace); var entityTypeA = model.AddEntityType("A"); var entityTypeB = model.AddEntityType("B"); var entityTypeC = model.AddEntityType("B"); var associationTypeA = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace) { SourceEnd = new AssociationEndMember("S", entityTypeA), TargetEnd = new AssociationEndMember("T", entityTypeB) }; associationTypeA.SourceEnd.DeleteBehavior = OperationAction.Cascade; model.AddAssociationType(associationTypeA); var associationTypeB = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace) { SourceEnd = new AssociationEndMember("S", entityTypeB), TargetEnd = new AssociationEndMember("T", entityTypeC) }; associationTypeB.SourceEnd.DeleteBehavior = OperationAction.Cascade; model.AddAssociationType(associationTypeB); Assert.True(model.HasCascadeDeletePath(entityTypeA, entityTypeB)); Assert.True(model.HasCascadeDeletePath(entityTypeB, entityTypeC)); Assert.True(model.HasCascadeDeletePath(entityTypeA, entityTypeC)); Assert.False(model.HasCascadeDeletePath(entityTypeB, entityTypeA)); Assert.False(model.HasCascadeDeletePath(entityTypeC, entityTypeB)); Assert.False(model.HasCascadeDeletePath(entityTypeC, entityTypeA)); }
public void Generate_can_map_a_simple_entity_type_and_set() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); var type = typeof(object); entityType.GetMetadataProperties().SetClrType(type); var property = EdmProperty.CreatePrimitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property); var property1 = EdmProperty.CreatePrimitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property1); var entitySet = model.AddEntitySet("ESet", entityType); var databaseMapping = CreateDatabaseMappingGenerator().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.MappingFragments.Single().Table); Assert.Equal("E", entityTypeMapping.MappingFragments.Single().Table.Name); Assert.Equal(2, entityTypeMapping.MappingFragments.Single().Table.Properties.Count); Assert.Equal(typeof(object), entityTypeMapping.GetClrType()); }
public void Configure_should_configure_modification_functions() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); entityType.GetMetadataProperties().SetClrType(typeof(object)); model.AddEntitySet("ESet", entityType); var modificationFunctionsConfigurationMock = new Mock<ModificationStoredProceduresConfiguration>(); var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); entityTypeConfiguration.MapToStoredProcedures(modificationFunctionsConfigurationMock.Object, true); entityType.SetConfiguration(entityTypeConfiguration); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model); entityTypeConfiguration.Configure(entityType, databaseMapping, ProviderRegistry.Sql2008_ProviderManifest); modificationFunctionsConfigurationMock .Verify( m => m.Configure( It.IsAny<EntityTypeModificationFunctionMapping>(), It.IsAny<DbProviderManifest>()), Times.Once()); }
public void Configure_should_configure_inverse() { var inverseMockPropertyInfo = new MockPropertyInfo(); var navigationPropertyConfiguration = new NavigationPropertyConfiguration(new MockPropertyInfo()) { InverseNavigationProperty = inverseMockPropertyInfo }; var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); associationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace)); var inverseAssociationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); inverseAssociationType.SourceEnd = new AssociationEndMember("S", new EntityType("E", "N", DataSpace.CSpace)); inverseAssociationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace)); var model = new EdmModel(DataSpace.CSpace); model.AddAssociationType(inverseAssociationType); var inverseNavigationProperty = model.AddEntityType("T") .AddNavigationProperty("N", inverseAssociationType); inverseNavigationProperty.SetClrPropertyInfo(inverseMockPropertyInfo); navigationPropertyConfiguration.Configure( new NavigationProperty("N", TypeUsage.Create(associationType.TargetEnd.GetEntityType())) { RelationshipType = associationType }, model, new EntityTypeConfiguration(typeof(object))); Assert.Same(associationType, inverseNavigationProperty.Association); Assert.Same(associationType.SourceEnd, inverseNavigationProperty.ResultEnd); Assert.Same(associationType.TargetEnd, inverseNavigationProperty.FromEndMember); Assert.Equal(0, model.AssociationTypes.Count()); }
public void Generate_can_map_a_simple_entity_type_and_set() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); var type = typeof(object); entityType.Annotations.SetClrType(type); var property = EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property); var property1 = EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property1); 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.MappingFragments.Single().Table); Assert.Equal("E", entityTypeMapping.MappingFragments.Single().Table.Name); Assert.Equal(2, entityTypeMapping.MappingFragments.Single().Table.Properties.Count); Assert.Equal(typeof(object), entityTypeMapping.GetClrType()); }
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 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 HasCascadeDeletePath_should_return_true_for_self_ref_cascade() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("A"); var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace) { SourceEnd = new AssociationEndMember("S", entityType) }; associationType.TargetEnd = new AssociationEndMember("T", associationType.SourceEnd.GetEntityType()); associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade; model.AddAssociationType(associationType); Assert.True(model.HasCascadeDeletePath(entityType, entityType)); }
private static DbDatabaseMapping CreateSimpleModel(double version) { var model = new EdmModel(DataSpace.CSpace, version); var entityType = model.AddEntityType("E"); var type = typeof(object); entityType.GetMetadataProperties().SetClrType(type); model.AddEntitySet("ESet", entityType); var property1 = EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property1); var property = property1; property.Nullable = false; entityType.AddKeyMember(property); return new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model); }
public void Apply_generates_constraint_when_simple_fk() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); var associationType = model.AddAssociationType( "A", entityType, RelationshipMultiplicity.ZeroOrOne, entityType, RelationshipMultiplicity.Many); var navigationProperty = entityType.AddNavigationProperty("N", associationType); var property = EdmProperty.Primitive("Fk", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property); var fkProperty = property; var foreignKeyAnnotation = new ForeignKeyAttribute("Fk"); navigationProperty.Annotations.SetClrAttributes(new[] { foreignKeyAnnotation }); ((IEdmConvention<NavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention()) .Apply(navigationProperty, model); Assert.NotNull(associationType.Constraint); Assert.True(associationType.Constraint.ToProperties.Contains(fkProperty)); }
public void Generate_should_correctly_map_string_primitive_property_facets() { var model = new EdmModel().Initialize(); var entityType = model.AddEntityType("E"); var type = typeof(object); entityType.Annotations.SetClrType(type); model.AddEntitySet("ESet", entityType); var property = EdmProperty .Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property); property.Nullable = false; property.IsFixedLength = true; property.IsMaxLength = true; property.IsUnicode = true; property.MaxLength = 42; property.Precision = 23; property.Scale = 77; property.SetStoreGeneratedPattern(StoreGeneratedPattern.Identity); var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model); var column = databaseMapping.GetEntityTypeMapping(entityType).MappingFragments.Single().ColumnMappings.Single().ColumnProperty; Assert.False(column.Nullable); Assert.Null(column.IsFixedLength); Assert.Equal(false, column.IsMaxLength); Assert.Null(column.IsUnicode); Assert.Equal(42, column.MaxLength); Assert.Null(column.Precision); Assert.Null(column.Scale); Assert.Equal(StoreGeneratedPattern.Identity, column.StoreGeneratedPattern); }
public void Generate_should_correctly_map_string_primitive_property_facets() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); var type = typeof(object); entityType.GetMetadataProperties().SetClrType(type); model.AddEntitySet("ESet", entityType); var property = EdmProperty .CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property); property.Nullable = false; property.IsFixedLength = true; property.IsMaxLength = true; property.IsUnicode = true; property.MaxLength = 42; property.Precision = 23; property.Scale = 77; property.SetStoreGeneratedPattern(StoreGeneratedPattern.Identity); var databaseMapping = CreateDatabaseMappingGenerator().Generate(model); var column = databaseMapping.GetEntityTypeMapping(entityType).MappingFragments.Single().ColumnMappings.Single().ColumnProperty; Assert.False(column.Nullable); Assert.True(column.IsFixedLengthConstant); Assert.False(column.IsMaxLength); Assert.True(column.IsUnicodeConstant); Assert.Equal(42, column.MaxLength); Assert.Null(column.Precision); Assert.Null(column.Scale); Assert.Equal(StoreGeneratedPattern.Identity, column.StoreGeneratedPattern); }
public void Generate_should_not_generate_modification_function_mappings_when_entity_abstract() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); entityType.Abstract = true; entityType.GetMetadataProperties().SetClrType(typeof(string)); var derivedType = model.AddEntityType("D"); derivedType.BaseType = entityType; derivedType.GetMetadataProperties().SetClrType(typeof(object)); model.AddEntitySet("ESet", entityType); var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); entityTypeConfiguration.MapToStoredProcedures(); entityType.SetConfiguration(entityTypeConfiguration); var databaseMapping = CreateDatabaseMappingGenerator().Generate(model); Assert.Equal(0, databaseMapping.Database.Functions.Count()); }
public void Generate_maps_abstract_type_hierarchies_correctly() { var model = new EdmModel(DataSpace.CSpace); var rootEntityType = model.AddEntityType("E"); rootEntityType.GetMetadataProperties().SetClrType(typeof(object)); var property0 = EdmProperty.CreatePrimitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); rootEntityType.AddMember(property0); rootEntityType.AddKeyMember(rootEntityType.Properties.First()); var property1 = EdmProperty.CreatePrimitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); rootEntityType.AddMember(property1); model.AddEntitySet("ESet", rootEntityType); var entityType2 = model.AddEntityType("E2"); var property2 = EdmProperty.CreatePrimitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType2.AddMember(property2); entityType2.GetMetadataProperties().SetClrType(typeof(string)); entityType2.Abstract = true; entityType2.BaseType = rootEntityType; var entityType3 = model.AddEntityType("E3"); entityType3.GetMetadataProperties().SetClrType(typeof(int)); var property3 = EdmProperty.CreatePrimitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType3.AddMember(property3); entityType3.BaseType = entityType2; var databaseMapping = CreateDatabaseMappingGenerator().Generate(model); var entityType1Mapping = databaseMapping.GetEntityTypeMapping(rootEntityType); var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3); 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.Equal(4, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count()); Assert.Equal("P1", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(0).ColumnProperty.Name); Assert.Equal("P2", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(1).ColumnProperty.Name); Assert.Equal("P3", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(2).ColumnProperty.Name); Assert.Equal("P4", entityType3Mapping.MappingFragments.Single().ColumnMappings.ElementAt(3).ColumnProperty.Name); var table = entityType1Mapping.MappingFragments.Single().Table; Assert.Equal(5, table.Properties.Count); }
public void Generate_can_map_type_hierarchies_using_Tph() { var model = new EdmModel(DataSpace.CSpace); var rootEntityType = model.AddEntityType("E"); var type = typeof(object); rootEntityType.GetMetadataProperties().SetClrType(type); var property = EdmProperty.CreatePrimitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); rootEntityType.AddMember(property); var property1 = EdmProperty.CreatePrimitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); rootEntityType.AddMember(property1); var entitySet = model.AddEntitySet("ESet", rootEntityType); var entityType2 = model.AddEntityType("E2"); var property2 = EdmProperty.CreatePrimitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType2.AddMember(property2); var type1 = typeof(string); entityType2.GetMetadataProperties().SetClrType(type1); entityType2.BaseType = rootEntityType; var entityType3 = model.AddEntityType("E3"); var type2 = typeof(int); entityType3.GetMetadataProperties().SetClrType(type2); var property3 = EdmProperty.CreatePrimitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType3.AddMember(property3); entityType3.BaseType = entityType2; var databaseMapping = CreateDatabaseMappingGenerator().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.MappingFragments.Single().ColumnMappings.Count()); Assert.Equal(3, entityType2Mapping.MappingFragments.Single().ColumnMappings.Count()); Assert.Equal(4, entityType3Mapping.MappingFragments.Single().ColumnMappings.Count()); var table = entityType1Mapping.MappingFragments.Single().Table; Assert.Same(table, entityType2Mapping.MappingFragments.Single().Table); Assert.Same(table, entityType3Mapping.MappingFragments.Single().Table); Assert.Equal(5, table.Properties.Count); Assert.Equal("P1", table.Properties[0].Name); Assert.Equal("P2", table.Properties[1].Name); Assert.Equal("P3", table.Properties[2].Name); Assert.Equal("P4", table.Properties[3].Name); Assert.Equal("Discriminator", table.Properties[4].Name); }
public void Generate_can_map_foreign_key_association_type() { var model = new EdmModel(DataSpace.CSpace); var principalEntityType = model.AddEntityType("P"); principalEntityType.GetMetadataProperties().SetClrType(typeof(object)); var dependentEntityType = model.AddEntityType("D"); dependentEntityType.GetMetadataProperties().SetClrType(typeof(string)); var dependentProperty1 = EdmProperty.CreatePrimitive("FK1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)); dependentProperty1.Nullable = false; dependentEntityType.AddMember(dependentProperty1); var dependentProperty2 = EdmProperty.CreatePrimitive("FK2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); dependentEntityType.AddMember(dependentProperty2); model.AddEntitySet("PSet", principalEntityType); model.AddEntitySet("DSet", dependentEntityType); var associationType = model.AddAssociationType( "P_D", principalEntityType, RelationshipMultiplicity.One, dependentEntityType, RelationshipMultiplicity.Many); associationType.Constraint = new ReferentialConstraint( associationType.SourceEnd, associationType.TargetEnd, principalEntityType.KeyProperties, new[] { dependentProperty1, dependentProperty2 }); associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade; var databaseMapping = CreateDatabaseMappingGenerator().Generate(model); var dependentTable = databaseMapping.GetEntityTypeMapping(dependentEntityType).MappingFragments.Single().Table; var foreignKeyConstraint = dependentTable.ForeignKeyBuilders.Single(); Assert.Equal(2, dependentTable.Properties.Count()); Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count()); Assert.Equal(OperationAction.Cascade, foreignKeyConstraint.DeleteAction); Assert.Equal(associationType.Name, foreignKeyConstraint.Name); var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First(); Assert.False(foreignKeyColumn.Nullable); Assert.Equal("FK1", foreignKeyColumn.Name); }
public void AddEntityType_should_create_and_add_when_custom_namespace() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("Foo", "Bar"); Assert.NotNull(entityType); Assert.Equal("Foo", entityType.Name); Assert.Equal("Bar", entityType.NamespaceName); Assert.True(model.EntityTypes.Contains(entityType)); }
public void GetStructuralOrEnumType_should_return_correct_type_for_EntityType() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("Foo"); Assert.Same(entityType, model.GetStructuralOrEnumType("Foo")); }
public void Apply_throws_with_empty_foreign_key_properties() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); var mockType = new MockType(); entityType.Annotations.SetClrType(mockType); var associationType = model.AddAssociationType( "A", entityType, RelationshipMultiplicity.ZeroOrOne, entityType, RelationshipMultiplicity.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<NavigationProperty>)new ForeignKeyNavigationPropertyAttributeConvention()) .Apply(navigationProperty, model)).Message); }
private static EdmModel CreateModelFixture( out EntityType declaringEntityType, out EntityType complexEntityType) { var model = new EdmModel(DataSpace.CSpace); declaringEntityType = model.AddEntityType("E"); complexEntityType = model.AddEntityType("C"); var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); complexEntityType.AddMember(property); var associationType = model.AddAssociationType( "A", declaringEntityType, RelationshipMultiplicity.Many, complexEntityType, RelationshipMultiplicity.ZeroOrOne); declaringEntityType.AddNavigationProperty("E.C", associationType); return model; }
public void GetClrTypes_should_return_ospace_types() { var model = new EdmModel(DataSpace.CSpace); var type1 = typeof(object); var tempQualifier1 = model.AddEntityType("A"); tempQualifier1.Annotations.SetClrType(type1); var type = typeof(string); model.AddEntityType("B").Annotations.SetClrType(type); Assert.Equal(2, model.GetClrTypes().Count()); }
public void GetEntityType_should_return_correct_type() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("Foo"); var foundEntityType = model.GetEntityType("Foo"); Assert.NotNull(foundEntityType); Assert.Same(entityType, foundEntityType); }
public void AddAssociationSet_should_create_and_add_to_default_container() { var model = new EdmModel(DataSpace.CSpace); var sourceEntityType = model.AddEntityType("Source"); var targetEntityType = model.AddEntityType("Target"); model.AddEntitySet("S", sourceEntityType); model.AddEntitySet("T", targetEntityType); var associationType = model.AddAssociationType( "Foo", sourceEntityType, RelationshipMultiplicity.One, targetEntityType, RelationshipMultiplicity.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_with_custom_namespace() { var model = new EdmModel(DataSpace.CSpace); var sourceEntityType = model.AddEntityType("Source"); var targetEntityType = model.AddEntityType("Target"); var associationType = model.AddAssociationType( "Foo", sourceEntityType, RelationshipMultiplicity.One, targetEntityType, RelationshipMultiplicity.Many, "Bar"); Assert.NotNull(associationType); Assert.Equal("Foo", associationType.Name); Assert.Equal("Bar", associationType.NamespaceName); Assert.Same(sourceEntityType, associationType.SourceEnd.GetEntityType()); Assert.Equal(RelationshipMultiplicity.One, associationType.SourceEnd.RelationshipMultiplicity); Assert.Same(targetEntityType, associationType.TargetEnd.GetEntityType()); Assert.Equal(RelationshipMultiplicity.Many, associationType.TargetEnd.RelationshipMultiplicity); Assert.True(model.AssociationTypes.Contains(associationType)); }
public void RemoveEntityType_should_remove_type_and_set() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("Foo"); model.AddEntitySet("FooSet", entityType); model.RemoveEntityType(entityType); Assert.Equal(0, model.EntityTypes.Count()); Assert.Equal(0, model.Containers.First().EntitySets.Count()); }
public void Generate_should_not_generate_modification_function_mappings_when_ends_not_mapped_to_functions() { var model = new EdmModel(DataSpace.CSpace); var entityType1 = model.AddEntityType("E1"); entityType1.GetMetadataProperties().SetClrType(typeof(string)); model.AddEntitySet("E1Set", entityType1); var entityType2 = model.AddEntityType("E2"); entityType2.GetMetadataProperties().SetClrType(typeof(string)); model.AddEntitySet("E2Set", entityType2); var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); entityType1.SetConfiguration(entityTypeConfiguration); entityType2.SetConfiguration(entityTypeConfiguration); model.AddAssociationSet( "M2MSet", model.AddAssociationType( "M2M", entityType1, RelationshipMultiplicity.Many, entityType2, RelationshipMultiplicity.Many)); var databaseMapping = CreateDatabaseMappingGenerator().Generate(model); Assert.Equal(0, databaseMapping.Database.Functions.Count()); }
public void Generate_should_map_entity_keys_to_primary_keys() { var model = new EdmModel(DataSpace.CSpace); var entityType = model.AddEntityType("E"); var type = typeof(object); entityType.GetMetadataProperties().SetClrType(type); var property = EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); entityType.AddMember(property); var idProperty = property; entityType.AddKeyMember(idProperty); var entitySet = model.AddEntitySet("ESet", entityType); var databaseMapping = CreateDatabaseMappingGenerator().Generate(model); var entitySetMapping = databaseMapping.GetEntitySetMapping(entitySet); var entityTypeMapping = entitySetMapping.EntityTypeMappings.Single(); Assert.Equal(1, entityTypeMapping.MappingFragments.Single().Table.KeyProperties.Count()); Assert.Equal("Id", entityTypeMapping.MappingFragments.Single().Table.KeyProperties.Single().Name); Assert.True(entityTypeMapping.MappingFragments.Single().Table.KeyProperties.Single().IsPrimaryKeyColumn); }
public void Generate_can_map_independent_association_type() { var model = new EdmModel(DataSpace.CSpace); var principalEntityType = model.AddEntityType("P"); var type = typeof(object); principalEntityType.GetMetadataProperties().SetClrType(type); var property = EdmProperty.CreatePrimitive("Id1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); principalEntityType.AddMember(property); var idProperty1 = property; principalEntityType.AddKeyMember(idProperty1); var property1 = EdmProperty.CreatePrimitive("Id2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); principalEntityType.AddMember(property1); var idProperty2 = property1; principalEntityType.AddKeyMember(idProperty2); var dependentEntityType = model.AddEntityType("D"); var type1 = typeof(string); dependentEntityType.GetMetadataProperties().SetClrType(type1); model.AddEntitySet("PSet", principalEntityType); model.AddEntitySet("DSet", dependentEntityType); var associationType = model.AddAssociationType( "P_D", principalEntityType, RelationshipMultiplicity.One, dependentEntityType, RelationshipMultiplicity.Many); model.AddAssociationSet("P_DSet", associationType); associationType.SourceEnd.DeleteBehavior = OperationAction.Cascade; var databaseMapping = CreateDatabaseMappingGenerator().Generate(model); var foreignKeyConstraint = databaseMapping.GetEntityTypeMapping(dependentEntityType).MappingFragments.Single().Table.ForeignKeyBuilders.Single(); Assert.Equal(2, foreignKeyConstraint.DependentColumns.Count()); Assert.Equal(associationType.Name, foreignKeyConstraint.Name); Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().AssociationSetMappings.Count()); Assert.Equal(OperationAction.Cascade, foreignKeyConstraint.DeleteAction); var foreignKeyColumn = foreignKeyConstraint.DependentColumns.First(); Assert.False(foreignKeyColumn.Nullable); Assert.Equal("P_Id1", foreignKeyColumn.Name); }
public void GetDerivedTypes_must_return_list_of_direct_descendants() { var model = new EdmModel(DataSpace.CSpace); 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 AddEntitySet_should_create_and_add_to_default_container() { var model = new EdmModel(DataSpace.CSpace); 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)); }