private SimpleCollectionColumnMap BuildSimpleEntitySetColumnMap(Mock <MetadataWorkspace> metadataWorkspaceMock, CodeFirstOSpaceTypeFactory codeFirstOSpaceTypeFactory = null)
{
var cSpaceEntityType = new EntityType(typeof(SimpleEntity).Name, "N", DataSpace.CSpace);
var intTypeUsage = TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), new FacetValues {
Nullable = false
});
cSpaceEntityType.AddMember(new EdmProperty("Id", intTypeUsage));
cSpaceEntityType.AddMember(new EdmProperty("Count", intTypeUsage));
var entityTypeUsage = TypeUsage.Create(cSpaceEntityType);
var idScalarMap = new ScalarColumnMap(intTypeUsage, "Id", 0, 0);
var entityMap = new EntityColumnMap(
entityTypeUsage, "E", new[] { idScalarMap,
new ScalarColumnMap(intTypeUsage, "Count", 0, 1) },
new SimpleEntityIdentity(null, new SimpleColumnMap[] { idScalarMap }));
var collectionMap = new SimpleCollectionColumnMap(
entityTypeUsage, "MockCollectionType", entityMap, null, null);
codeFirstOSpaceTypeFactory = codeFirstOSpaceTypeFactory ?? new CodeFirstOSpaceTypeFactory();
var oSpaceEntityType = codeFirstOSpaceTypeFactory.TryCreateType(typeof(SimpleEntity), cSpaceEntityType);
codeFirstOSpaceTypeFactory.CspaceToOspace.Add(cSpaceEntityType, oSpaceEntityType);
metadataWorkspaceMock.Setup(m => m.GetItem <EdmType>("N.SimpleEntity", DataSpace.OSpace))
.Returns(oSpaceEntityType);
return(collectionMap);
}
public void Generate_should_map_scalar_properties_to_columns()
{
var databaseMapping = CreateEmptyModel();
var entityType = new EntityType
{
Name = "E"
};
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 = databaseMapping.Model.AddEntitySet("ESet", entityType);
var type = typeof(object);
entityType.Annotations.SetClrType(type);
new EntityTypeMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(entityType, databaseMapping);
var entityTypeMappingFragment
= databaseMapping.GetEntitySetMapping(entitySet).EntityTypeMappings.Single().MappingFragments.Single();
Assert.Equal(2, entityTypeMappingFragment.ColumnMappings.Count());
Assert.Equal(2, entityTypeMappingFragment.Table.Properties.Count());
}
public void Configure_should_configure_and_order_keys_when_keys_and_order_specified()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.CreatePrimitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
var property1 = EdmProperty.CreatePrimitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
var mockPropertyInfo2 = new MockPropertyInfo(typeof(int), "P2");
entityTypeConfiguration.Key(mockPropertyInfo2);
entityTypeConfiguration.Property(new PropertyPath(mockPropertyInfo2)).ColumnOrder = 1;
(entityType.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == "P2")).SetClrPropertyInfo(mockPropertyInfo2);
var mockPropertyInfo1 = new MockPropertyInfo(typeof(int), "P1");
entityTypeConfiguration.Key(mockPropertyInfo1);
entityTypeConfiguration.Property(new PropertyPath(mockPropertyInfo1)).ColumnOrder = 0;
(entityType.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == "P1")).SetClrPropertyInfo(mockPropertyInfo1);
entityTypeConfiguration.Configure(entityType, new EdmModel(DataSpace.CSpace));
Assert.Equal(2, entityType.KeyProperties.Count);
Assert.Equal("P1", entityType.KeyProperties.First().Name);
}
public TestModelBuilder Property(string propertyName)
{
var property1 = EdmProperty.Primitive(propertyName, PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
_entityType.AddMember(property1);
var property = property1;
property.SetClrPropertyInfo(new MockPropertyInfo(typeof(string), propertyName));
return(this);
}
public void Apply_should_match_id_ahead_of_type_and_id()
{
var entityType = new EntityType("Foo", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("FooId", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var idProperty = property1;
(new IdKeyDiscoveryConvention()).Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.Equal(1, entityType.KeyProperties.Count);
Assert.True(entityType.KeyProperties.Contains(idProperty));
}
public void Configure_should_propagate_end_kind_to_keys_when_required()
{
var mockPropertyInfo = new MockPropertyInfo(typeof(int), "P");
var constraintConfiguration = new ForeignKeyConstraintConfiguration(new[] { mockPropertyInfo.Object });
var entityType = new EntityType("SE", "N", DataSpace.CSpace);
entityType.GetMetadataProperties().SetClrType(typeof(object));
var property1 = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
property.Nullable = true;
property.SetClrPropertyInfo(mockPropertyInfo);
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", entityType);
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("TE", "N", DataSpace.CSpace));
associationType.TargetEnd.RelationshipMultiplicity = RelationshipMultiplicity.One;
constraintConfiguration.Configure(
associationType, associationType.SourceEnd, new EntityTypeConfiguration(typeof(object)));
Assert.Equal(1, associationType.Constraint.ToProperties.Count);
Assert.Equal(false, property.Nullable);
}
public static NavigationProperty AddNavigationProperty(
this EntityType entityType, string name, AssociationType associationType)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotEmpty(name);
DebugCheck.NotNull(associationType);
var targetEntityType
= associationType.TargetEnd.GetEntityType();
var typeUsage
= associationType.TargetEnd.RelationshipMultiplicity.IsMany()
? (EdmType)targetEntityType.GetCollectionType()
: targetEntityType;
var navigationProperty
= new NavigationProperty(name, TypeUsage.Create(typeUsage))
{
RelationshipType = associationType,
FromEndMember = associationType.SourceEnd,
ToEndMember = associationType.TargetEnd
};
entityType.AddMember(navigationProperty);
return(navigationProperty);
}
internal override void Configure(
AssociationSetMapping associationSetMapping,
EdmModel database,
PropertyInfo navigationProperty)
{
List <ScalarPropertyMapping> propertyMappings = associationSetMapping.SourceEndMapping.PropertyMappings.ToList <ScalarPropertyMapping>();
if (this._tableName != null)
{
EntityType targetTable = database.EntityTypes.Select(t => new
{
t = t,
n = t.GetTableName()
}).Where(_param1 =>
{
if (_param1.n != null)
{
return(_param1.n.Equals(this._tableName));
}
return(false);
}).Select(_param0 => _param0.t).SingleOrDefault <EntityType>() ?? database.GetEntitySets().Where <EntitySet>((Func <EntitySet, bool>)(es => string.Equals(es.Table, this._tableName.Name, StringComparison.Ordinal))).Select <EntitySet, EntityType>((Func <EntitySet, EntityType>)(es => es.ElementType)).SingleOrDefault <EntityType>();
if (targetTable == null)
{
throw Error.TableNotFound((object)this._tableName);
}
EntityType sourceTable = associationSetMapping.Table;
if (sourceTable != targetTable)
{
ForeignKeyBuilder foreignKeyBuilder = sourceTable.ForeignKeyBuilders.Single <ForeignKeyBuilder>((Func <ForeignKeyBuilder, bool>)(fk => fk.DependentColumns.SequenceEqual <EdmProperty>(propertyMappings.Select <ScalarPropertyMapping, EdmProperty>((Func <ScalarPropertyMapping, EdmProperty>)(pm => pm.Column)))));
sourceTable.RemoveForeignKey(foreignKeyBuilder);
targetTable.AddForeignKey(foreignKeyBuilder);
foreignKeyBuilder.DependentColumns.Each <EdmProperty>((Action <EdmProperty>)(c =>
{
bool primaryKeyColumn = c.IsPrimaryKeyColumn;
sourceTable.RemoveMember((EdmMember)c);
targetTable.AddMember((EdmMember)c);
if (!primaryKeyColumn)
{
return;
}
targetTable.AddKeyMember((EdmMember)c);
}));
associationSetMapping.StoreEntitySet = database.GetEntitySet(targetTable);
}
}
if (this._keyColumnNames.Count > 0 && this._keyColumnNames.Count != propertyMappings.Count <ScalarPropertyMapping>())
{
throw Error.IncorrectColumnCount((object)string.Join(", ", (IEnumerable <string>) this._keyColumnNames));
}
this._keyColumnNames.Each <string>((Action <string, int>)((n, i) => propertyMappings[i].Column.Name = n));
foreach (KeyValuePair <Tuple <string, string>, object> annotation in (IEnumerable <KeyValuePair <Tuple <string, string>, object> >) this._annotations)
{
int index = this._keyColumnNames.IndexOf(annotation.Key.Item1);
if (index == -1)
{
throw new InvalidOperationException(Strings.BadKeyNameForAnnotation((object)annotation.Key.Item1, (object)annotation.Key.Item2));
}
propertyMappings[index].Column.AddAnnotation("http://schemas.microsoft.com/ado/2013/11/edm/customannotation:" + annotation.Key.Item2, annotation.Value);
}
}
public void Generate_should_flatten_complex_properties_to_columns()
{
var databaseMapping = CreateEmptyModel();
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var complexType = new ComplexType("C");
var property = EdmProperty.CreatePrimitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
complexType.AddMember(property);
entityType.AddComplexProperty("C1", complexType);
var property1 = EdmProperty.CreatePrimitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var entitySet = databaseMapping.Model.AddEntitySet("ESet", entityType);
var type = typeof(object);
entityType.GetMetadataProperties().SetClrType(type);
new TableMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(entityType, databaseMapping);
var entityTypeMappingFragment
= databaseMapping.GetEntitySetMapping(entitySet).EntityTypeMappings.Single().MappingFragments.Single();
Assert.Equal(2, entityTypeMappingFragment.ColumnMappings.Count());
Assert.Equal(2, entityTypeMappingFragment.Table.Properties.Count());
}
public void Apply_should_update_foreign_keys()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var principalProperty = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalProperty.MaxLength = 23;
entityType.AddMember(principalProperty);
entityType.AddKeyMember(principalProperty);
var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace);
associationType.SourceEnd = new AssociationEndMember("S", entityType);
associationType.TargetEnd = new AssociationEndMember("T", new EntityType("E", "N", DataSpace.CSpace));
var dependentProperty = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
associationType.Constraint
= new ReferentialConstraint(
associationType.SourceEnd,
associationType.TargetEnd,
new[] { principalProperty },
new[] { dependentProperty });
((IEdmConvention <AssociationType>) new PropertyMaxLengthConvention())
.Apply(associationType, new EdmModel(DataSpace.CSpace));
Assert.Equal(23, dependentProperty.MaxLength);
}
public void Apply_should_throw_if_two_type_Id_properties_are_matched_that_differ_only_by_case()
{
var entityType = new EntityType("Foo", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("FOOId", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
var FOOIdProperty = property;
var property1 = EdmProperty.Primitive("FooId", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var FooIdProperty = property1;
Assert.Equal(
Strings.MultiplePropertiesMatchedAsKeys("FOOId", "Foo"),
Assert.Throws <InvalidOperationException>(
() => (new IdKeyDiscoveryConvention()).Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null))).Message);
}
public static EdmProperty AddComplexProperty(
this EntityType entityType,
string name,
ComplexType complexType)
{
EdmProperty complex = EdmProperty.CreateComplex(name, complexType);
entityType.AddMember((EdmMember)complex);
return(complex);
}
public static void AddColumn(this EntityType table, EdmProperty column)
{
DebugCheck.NotNull(table);
DebugCheck.NotNull(column);
column.SetPreferredName(column.Name);
column.Name = table.Properties.UniquifyName(column.Name);
table.AddMember(column);
}
public void Apply_should_set_given_value_for_unconfigured_strings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
(new SqlCePropertyMaxLengthConvention(2000)).Apply(entityType, CreateDbModel());
Assert.Equal(2000, property.MaxLength);
}
[Fact] // Dev11 347225
public void Apply_should_throw_if_two_Id_properties_are_matched_that_differ_only_by_case()
{
var entityType = new EntityType
{
Name = "Foo"
};
var property = EdmProperty.Primitive("ID", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
var IDProperty = property;
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var IdProperty = property1;
Assert.Equal(
Strings.MultiplePropertiesMatchedAsKeys("ID", "Foo"),
Assert.Throws <InvalidOperationException>(
() => ((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel())).Message);
}
public void Apply_should_match_id_ahead_of_type_and_id()
{
var entityType = new EntityType
{
Name = "Foo"
};
var property = EdmProperty.Primitive("FooId", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
var typeIdProperty = property;
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var idProperty = property1;
((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel());
Assert.Equal(1, entityType.DeclaredKeyProperties.Count);
Assert.True(entityType.DeclaredKeyProperties.Contains(idProperty));
}
public void Apply_should_set_correct_defaults_for_unicode_fixed_length_strings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
property.IsFixedLength = true;
entityType.AddMember(property);
(new SqlCePropertyMaxLengthConvention())
.Apply(entityType, CreateDbModel());
Assert.Equal(4000, property.MaxLength);
}
public void Apply_should_ignore_non_primitive_type()
{
var entityType = new EntityType();
var property1 = EdmProperty.Complex("Id", new ComplexType("C"));
entityType.AddMember(property1);
var property = property1;
((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel());
Assert.False(entityType.DeclaredKeyProperties.Contains(property));
}
public void Apply_should_match_simple_id()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property1 = EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
(new IdKeyDiscoveryConvention()).Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.True(entityType.KeyProperties.Contains(property));
}
public void Apply_should_set_correct_defaults_for_unconfigured_strings()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
((IEdmConvention <EntityType>) new SqlCePropertyMaxLengthConvention())
.Apply(entityType, CreateEdmModel());
Assert.Equal(4000, property.MaxLength);
}
public void Apply_should_match_type_prefixed_id()
{
var entityType = new EntityType("Foo", "N", DataSpace.CSpace);
var property1 = EdmProperty.Primitive("FooId", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.True(entityType.KeyProperties.Contains(property));
}
public void Apply_should_ignore_non_primitive_type()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property1 = EdmProperty.Complex("Id", new ComplexType("C"));
entityType.AddMember(property1);
var property = property1;
(new IdKeyDiscoveryConvention()).Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.False(entityType.KeyProperties.Contains(property));
}
public void Apply_should_ignore_case()
{
var entityType = new EntityType("Foo", "N", DataSpace.CSpace);
var property1 = EdmProperty.Primitive("foOid", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
(new IdKeyDiscoveryConvention()).Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.True(entityType.KeyProperties.Contains(property));
}
public void Apply_should_make_key_not_nullable()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
(new IdKeyDiscoveryConvention()).Apply(entityType, new DbModel(new EdmModel(DataSpace.CSpace), null));
Assert.False(property.Nullable);
}
public void Apply_should_match_simple_id()
{
var entityType = new EntityType();
var property1 = EdmProperty.Primitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
((IEdmConvention <EntityType>) new IdKeyDiscoveryConvention()).Apply(entityType, new EdmModel());
Assert.True(entityType.DeclaredKeyProperties.Contains(property));
}
public void Apply_should_set_correct_defaults_for_string_keys()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
entityType.AddKeyMember(property);
((IEdmConvention <EntityType>) new PropertyMaxLengthConvention())
.Apply(entityType, new EdmModel(DataSpace.CSpace));
Assert.Equal(128, property.MaxLength);
}
public void GetPrimitiveProperty_should_return_correct_property()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property1 = EdmProperty.CreatePrimitive("Foo", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
var foundProperty = entityType.GetDeclaredPrimitiveProperties().SingleOrDefault(p => p.Name == "Foo");
Assert.NotNull(foundProperty);
Assert.Same(property, foundProperty);
}
public static EdmProperty AddComplexProperty(
this EntityType entityType, string name, ComplexType complexType)
{
DebugCheck.NotNull(entityType);
DebugCheck.NotEmpty(name);
DebugCheck.NotNull(complexType);
var property = EdmProperty.CreateComplex(name, complexType);
entityType.AddMember(property);
return(property);
}
public void GetPrimitiveProperties_should_return_only_primitive_properties()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property1 = EdmProperty.CreatePrimitive("Foo", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property1);
var property = property1;
entityType.AddComplexProperty("Bar", new ComplexType("C"));
Assert.Equal(1, entityType.GetDeclaredPrimitiveProperties().Count());
Assert.True(entityType.GetDeclaredPrimitiveProperties().Contains(property));
}
public void Apply_should_set_correct_defaults_for_binary_key()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var property = EdmProperty.CreatePrimitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType.AddMember(property);
entityType.AddKeyMember(property);
(new SqlCePropertyMaxLengthConvention())
.Apply(entityType, CreateDbModel());
Assert.Null(property.IsUnicode);
Assert.Equal(4000, property.MaxLength);
}
