public void AddEntityTypeMappingFragment( EdmEntitySet entitySet, EdmEntityType entityType, DbEntityTypeMappingFragment fragment) { Contract.Assert(fragment.Table == Table); _entityTypes.Add(entitySet, entityType); var defaultDiscriminatorColumn = fragment.GetDefaultDiscriminator(); DbColumnCondition defaultDiscriminatorCondition = null; if (defaultDiscriminatorColumn != null) { defaultDiscriminatorCondition = fragment.ColumnConditions.SingleOrDefault(cc => cc.Column == defaultDiscriminatorColumn); } foreach (var pm in fragment.PropertyMappings) { var columnMapping = FindOrCreateColumnMapping(pm.Column); columnMapping.AddMapping( entityType, pm.PropertyPath, fragment.ColumnConditions.Where(cc => cc.Column == pm.Column), defaultDiscriminatorColumn == pm.Column); } // Add any column conditions that aren't mapped to properties foreach ( var cc in fragment.ColumnConditions.Where(cc => !fragment.PropertyMappings.Any(pm => pm.Column == cc.Column))) { var columnMapping = FindOrCreateColumnMapping(cc.Column); columnMapping.AddMapping(entityType, null, new[] { cc }, defaultDiscriminatorColumn == cc.Column); } }
public static void SetKeyNamesType(this DbTableMetadata table, EdmEntityType entityType) { //Contract.Requires(table != null); //Contract.Requires(entityType != null); table.Annotations.SetAnnotation(KeyNamesTypeAnnotation, entityType); }
public void Add(EdmEntitySet entitySet, EdmEntityType entityType) { Contract.Requires(entitySet != null); Contract.Requires(entityType != null); var i = 0; List<EdmEntityType> entityTypes; if (!_entityTypes.TryGetValue(entitySet, out entityTypes)) { entityTypes = new List<EdmEntityType>(); _entityTypes.Add(entitySet, entityTypes); } for (; i < entityTypes.Count; i++) { if (entityTypes[i] == entityType) { return; } else if (entityType.IsAncestorOf(entityTypes[i])) { break; } } entityTypes.Insert(i, entityType); }
public void Apply_should_move_declared_keys_head_of_declared_properties_list() { var entityType = new EdmEntityType(); entityType.SetClrType(typeof(SimpleEntity)); entityType.AddPrimitiveProperty("StaticProperty"); entityType.AddPrimitiveProperty("PrivateProperty"); entityType.AddPrimitiveProperty("InheritedPropertyB"); entityType.AddPrimitiveProperty("InheritedPropertyA"); entityType.AddPrimitiveProperty("PropertyB"); entityType.AddPrimitiveProperty("PropertyA"); entityType.DeclaredKeyProperties.Add( entityType.AddPrimitiveProperty("Key")); ((IEdmConvention<EdmEntityType>)new DeclaredPropertyOrderingConvention()) .Apply(entityType, new EdmModel()); Assert.True( entityType.DeclaredProperties.Select(e => e.Name) .SequenceEqual( new[] { "Key", "PrivateProperty", "PropertyA", "PropertyB", "InheritedPropertyA", "InheritedPropertyB", "StaticProperty" })); }
public bool Contains(EdmEntitySet entitySet, EdmEntityType entityType) { Contract.Requires(entitySet != null); Contract.Requires(entityType != null); List<EdmEntityType> setTypes; return _entityTypes.TryGetValue(entitySet, out setTypes) && setTypes.Contains(entityType); }
public void Can_get_and_set_configuration_annotation() { var entityType = new EdmEntityType(); entityType.SetConfiguration(42); Assert.Equal(42, entityType.GetConfiguration()); }
public void Configure_should_throw_when_property_not_found() { var entityType = new EdmEntityType { Name = "E" }; var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>(); entityTypeConfiguration.Property(new PropertyPath(new MockPropertyInfo()), () => mockPropertyConfiguration.Object); Assert.Equal(Strings.PropertyNotFound(("P"), "E"), Assert.Throws<InvalidOperationException>(() => entityTypeConfiguration.Configure(entityType, new EdmModel())).Message); }
public void Configure_should_set_configuration() { var entityType = new EdmEntityType { Name = "E" }; var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); entityTypeConfiguration.Configure(entityType, new EdmModel()); Assert.Same(entityTypeConfiguration, entityType.GetConfiguration()); }
public void Apply_should_ignore_non_primitive_type() { var entityType = new EdmEntityType(); var property = entityType.AddPrimitiveProperty("Id"); ((IEdmConvention<EdmEntityType>)new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel()); Assert.False(entityType.DeclaredKeyProperties.Contains(property)); }
public void Apply_should_ignore_case() { var entityType = new EdmEntityType { Name = "Foo" }; var property = entityType.AddPrimitiveProperty("foOid"); property.PropertyType.EdmType = EdmPrimitiveType.Int32; ((IEdmConvention<EdmEntityType>)new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel()); Assert.True(entityType.DeclaredKeyProperties.Contains(property)); }
public void Apply_should_make_key_not_nullable() { var entityType = new EdmEntityType(); var property = entityType.AddPrimitiveProperty("Id"); property.PropertyType.EdmType = EdmPrimitiveType.Int32; ((IEdmConvention<EdmEntityType>)new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel()); Assert.False(property.PropertyType.IsNullable.Value); }
public void Apply_should_match_simple_id() { var entityType = new EdmEntityType(); var property = entityType.AddPrimitiveProperty("Id"); property.PropertyType.EdmType = EdmPrimitiveType.Int32; ((IEdmConvention<EdmEntityType>)new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel()); Assert.True(entityType.DeclaredKeyProperties.Contains(property)); }
public void AddMapping( EdmEntityType entityType, IList<EdmProperty> propertyPath, IEnumerable<DbColumnCondition> conditions, bool isDefaultDiscriminatorCondition) { _propertyMappings.Add( new PropertyMappingSpecification( entityType, propertyPath, conditions.ToList(), isDefaultDiscriminatorCondition)); }
public void GetPrimitiveProperties_should_return_only_primitive_properties() { var entityType = new EdmEntityType(); var property = entityType.AddPrimitiveProperty("Foo"); property.PropertyType.EdmType = EdmPrimitiveType.DateTime; entityType.AddComplexProperty("Bar", new EdmComplexType()); Assert.Equal(1, entityType.GetDeclaredPrimitiveProperties().Count()); Assert.True(entityType.GetDeclaredPrimitiveProperties().Contains(property)); }
public void Can_get_and_set_clr_type_annotation() { var entityType = new EdmEntityType(); Assert.Null(entityType.GetClrType()); entityType.SetClrType(typeof(object)); Assert.Equal(typeof(object), entityType.GetClrType()); }
public void Map_should_map_entity_navigation_properties() { var entityType = new EdmEntityType(); var mappingContext = new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), new EdmModel().Initialize()); new PropertyMapper(new TypeMapper(mappingContext)) .Map(new MockPropertyInfo(new MockType(), "Foo"), entityType, () => new EntityTypeConfiguration(typeof(object))); Assert.Equal(1, entityType.DeclaredNavigationProperties.Count); }
public TestModelBuilder Entity(string name, bool addSet = true) { _entityType = _model.AddEntityType(name); _entityType.SetClrType(new MockType(name)); if (addSet) { _model.AddEntitySet(name + "Set", _entityType); } return this; }
public void AddComplexProperty_should_create_and_add_complex_property() { var entityType = new EdmEntityType(); var complexType = new EdmComplexType(); var property = entityType.AddComplexProperty("Foo", complexType); Assert.NotNull(property); Assert.Equal("Foo", property.Name); Assert.Same(complexType, property.PropertyType.ComplexType); Assert.True(entityType.DeclaredProperties.Contains(property)); }
public void AddNavigationProperty_should_create_and_add_navigation_property() { var entityType = new EdmEntityType(); var associationType = new EdmAssociationType(); var navigationProperty = entityType.AddNavigationProperty("N", associationType); Assert.NotNull(navigationProperty); Assert.Equal("N", navigationProperty.Name); Assert.Same(associationType, navigationProperty.Association); Assert.True(entityType.NavigationProperties.Contains(navigationProperty)); }
public void Apply_should_match_id_ahead_of_type_and_id() { var entityType = new EdmEntityType { Name = "Foo" }; var typeIdProperty = entityType.AddPrimitiveProperty("FooId"); var idProperty = entityType.AddPrimitiveProperty("Id"); typeIdProperty.PropertyType.EdmType = EdmPrimitiveType.Int32; idProperty.PropertyType.EdmType = EdmPrimitiveType.Int32; ((IEdmConvention<EdmEntityType>)new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel()); Assert.Equal(1, entityType.DeclaredKeyProperties.Count); Assert.True(entityType.DeclaredKeyProperties.Contains(idProperty)); }
public void Map_should_not_detect_arrays_as_collection_associations() { var modelConfiguration = new ModelConfiguration(); var model = new EdmModel().Initialize(); var entityType = new EdmEntityType(); var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model); new NavigationPropertyMapper(new TypeMapper(mappingContext)) .Map(new MockPropertyInfo(typeof(NavigationPropertyMapperTests[]), "Nav"), entityType, () => new EntityTypeConfiguration(typeof(object))); Assert.Equal(0, model.Namespaces.Single().AssociationTypes.Count); }
public void Configure_should_configure_entity_set_name() { var model = new EdmModel().Initialize(); var entityType = new EdmEntityType { Name = "E" }; var entitySet = model.AddEntitySet("ESet", entityType); var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)) { EntitySetName = "MySet" }; entityTypeConfiguration.Configure(entityType, model); Assert.Equal("MySet", entitySet.Name); Assert.Same(entityTypeConfiguration, entitySet.GetConfiguration()); }
public PropertyMappingSpecification( EdmEntityType entityType, IList<EdmProperty> propertyPath, IList<DbColumnCondition> conditions, bool isDefaultDiscriminatorCondition) { //Contract.Requires(entityType != null); _entityType = entityType; _propertyPath = propertyPath; _conditions = conditions; _isDefaultDiscriminatorCondition = isDefaultDiscriminatorCondition; }
public void Generate_should_add_set_mapping_and_table_and_set_clr_type() { var databaseMapping = CreateEmptyModel(); var entityType = new EdmEntityType { Name = "E" }; var entitySet = databaseMapping.Model.AddEntitySet("ESet", entityType); entityType.SetClrType(typeof(object)); new EntityTypeMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(entityType, databaseMapping); Assert.NotNull(databaseMapping.GetEntitySetMapping(entitySet)); Assert.Same(entityType, databaseMapping.GetEntitySetMapping(entitySet).EntityTypeMappings.Single().EntityType); Assert.Same(typeof(object), databaseMapping.GetEntitySetMapping(entitySet).EntityTypeMappings.Single().GetClrType()); Assert.NotNull(databaseMapping.GetEntitySetMapping(entitySet).EntityTypeMappings.Single().TypeMappingFragments.Single().Table); }
public void Apply_should_match_simple_short_key() { var entityType = new EdmEntityType(); var property = new EdmProperty().AsPrimitive(); property.PropertyType.EdmType = EdmPrimitiveType.Int16; entityType.DeclaredKeyProperties.Add(property); ((IEdmConvention<EdmEntityType>)new StoreGeneratedIdentityKeyConvention()) .Apply(entityType, new EdmModel().Initialize()); Assert.Equal( DbStoreGeneratedPattern.Identity, entityType.DeclaredKeyProperties.Single().GetStoreGeneratedPattern()); }
public void Apply_should_set_correct_defaults_for_unconfigured_strings() { var entityType = new EdmEntityType(); var property = new EdmProperty().AsPrimitive(); property.PropertyType.EdmType = EdmPrimitiveType.String; entityType.DeclaredProperties.Add(property); ((IEdmConvention<EdmEntityType>)new SqlCePropertyMaxLengthConvention()) .Apply(entityType, CreateEdmModel()); var primitiveTypeFacets = property.PropertyType.PrimitiveTypeFacets; Assert.Equal(4000, primitiveTypeFacets.MaxLength); }
public void Configure_should_configure_properties() { var entityType = new EdmEntityType { Name = "E" }; var property = entityType.AddPrimitiveProperty("P"); property.PropertyType.EdmType = EdmPrimitiveType.Int32; var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object)); var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>(); var mockPropertyInfo = new MockPropertyInfo(); property.SetClrPropertyInfo(mockPropertyInfo); entityTypeConfiguration.Property(new PropertyPath(mockPropertyInfo), () => mockPropertyConfiguration.Object); entityTypeConfiguration.Configure(entityType, new EdmModel()); mockPropertyConfiguration.Verify(p => p.Configure(property)); }
public static bool IsAncestorOf(this EdmEntityType ancestor, EdmEntityType entityType) { //Contract.Requires(ancestor != null); //Contract.Requires(entityType != null); while (entityType != null) { if (entityType.BaseType == ancestor) { return true; } entityType = entityType.BaseType; } return false; }
public void Map_should_set_correct_name_and_type() { var entityType = new EdmEntityType(); var mappingContext = new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), new EdmModel().Initialize()); new PropertyMapper(new TypeMapper(mappingContext)) .Map(new MockPropertyInfo(typeof(int), "Foo"), entityType, () => new EntityTypeConfiguration(typeof(object))); Assert.Equal(1, entityType.DeclaredProperties.Count); var property = entityType.GetDeclaredPrimitiveProperty("Foo"); Assert.Equal(EdmPrimitiveType.Int32, property.PropertyType.PrimitiveType); }
public void Apply_should_set_correct_defaults_for_unconfigured_binary() { var entityType = new EdmEntityType(); var property = new EdmProperty().AsPrimitive(); property.PropertyType.EdmType = EdmPrimitiveType.Binary; entityType.DeclaredProperties.Add(property); ((IEdmConvention<EdmEntityType>)new PropertyMaxLengthConvention()) .Apply(entityType, new EdmModel()); var primitiveTypeFacets = property.PropertyType.PrimitiveTypeFacets; Assert.Null(primitiveTypeFacets.IsUnicode); Assert.Equal(false, primitiveTypeFacets.IsFixedLength); Assert.Null(primitiveTypeFacets.MaxLength); }