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.Annotations.SetClrType(typeof(string));
model.AddEntitySet("E1Set", entityType1);
var entityType2 = model.AddEntityType("E2");
entityType2.Annotations.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
= new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
Assert.Equal(0, databaseMapping.Database.Functions.Count());
}
public void GetEntitySets_should_return_all_sets()
{
var model = new EdmModel(DataSpace.CSpace);
model.AddEntitySet("S", new EntityType("E", "N", DataSpace.CSpace));
model.AddEntitySet("T", new EntityType("E", "N", DataSpace.CSpace));
Assert.Equal(2, model.GetEntitySets().Count());
}
public void GetEntitySets_should_return_all_sets()
{
var model = new EdmModel().Initialize();
model.AddEntitySet("S", new EntityType());
model.AddEntitySet("T", new EntityType());
Assert.Equal(2, model.GetEntitySets().Count());
}
public void Generate_can_map_foreign_key_association_type()
{
var model = new EdmModel(DataSpace.CSpace);
var principalEntityType = model.AddEntityType("P");
principalEntityType.Annotations.SetClrType(typeof(object));
var dependentEntityType = model.AddEntityType("D");
dependentEntityType.Annotations.SetClrType(typeof(string));
var dependentProperty1 = EdmProperty.Primitive("FK1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
dependentProperty1.Nullable = false;
dependentEntityType.AddMember(dependentProperty1);
var dependentProperty2 = EdmProperty.Primitive("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
= new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).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 Apply_should_uniquify_names()
{
var model = new EdmModel(DataSpace.CSpace);
model.AddEntitySet("Cats", new EntityType("E", "N", DataSpace.CSpace));
var entitySet = model.AddEntitySet("Cat", new EntityType("E", "N", DataSpace.CSpace));
((IEdmConvention <EntitySet>) new PluralizingEntitySetNameConvention())
.Apply(entitySet, model);
Assert.Equal("Cats1", entitySet.Name);
}
public void Generate_can_map_independent_association_type()
{
var model = new EdmModel(DataSpace.CSpace);
var principalEntityType = model.AddEntityType("P");
var type = typeof(object);
principalEntityType.Annotations.SetClrType(type);
var property = EdmProperty.Primitive("Id1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property);
var idProperty1 = property;
principalEntityType.AddKeyMember(idProperty1);
var property1 = EdmProperty.Primitive("Id2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
principalEntityType.AddMember(property1);
var idProperty2 = property1;
principalEntityType.AddKeyMember(idProperty2);
var dependentEntityType = model.AddEntityType("D");
var type1 = typeof(string);
dependentEntityType.Annotations.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 = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).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 Map_should_create_association_sets_for_associations()
{
var modelConfiguration = new ModelConfiguration();
var model = new EdmModel().Initialize();
var entityType = new EntityType
{
Name = "Source"
};
model.AddEntitySet("Source", entityType);
var mappingContext = new MappingContext(modelConfiguration, new ConventionsConfiguration(), model);
new NavigationPropertyMapper(new TypeMapper(mappingContext))
.Map(
new MockPropertyInfo(new MockType("Target"), "Nav"), entityType,
() => new EntityTypeConfiguration(typeof(object)));
Assert.Equal(1, model.Containers.Single().AssociationSets.Count);
var associationSet = model.Containers.Single().AssociationSets.Single();
Assert.NotNull(associationSet);
Assert.NotNull(associationSet.ElementType);
Assert.Equal("Source_Nav", associationSet.Name);
}
public void Apply_should_uniquify_names()
{
var database = new EdmModel().Initialize();
var tableA = new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace);
var tableB = new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace);
var entitySetA = database.AddEntitySet("ESA", tableA);
entitySetA.Table = "Customers";
var entitySetB = database.AddEntitySet("ESB", tableB);
entitySetB.Table = "Customer";
((IDbConvention <EntityType>) new PluralizingTableNameConvention()).Apply(tableB, database);
Assert.Equal("Customers1", entitySetB.Table);
}
public void Apply_should_sort_annotated_before_unannotated()
{
var table = new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace);
var columnA = new EdmProperty(
"C",
ProviderRegistry.Sql2008_ProviderManifest.GetStoreType(
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))));
columnA.SetOrder(2);
table.AddColumn(columnA);
table.AddColumn(
new EdmProperty(
"Id",
ProviderRegistry.Sql2008_ProviderManifest.GetStoreType(
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)))));
var database = new EdmModel().Initialize();
database.AddEntitySet("ES", table);
((IDbConvention <EntityType>) new ColumnOrderingConvention()).Apply(table, database);
Assert.Equal(2, table.Properties.Count);
Assert.Equal("C", table.Properties.First().Name);
}
public void Apply_should_order_by_annotation_if_given()
{
var table = new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace);
var columnA = new EdmProperty(
"C",
ProviderRegistry.Sql2008_ProviderManifest.GetStoreType(
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))));
columnA.SetOrder(2);
table.AddColumn(columnA);
var columnB = new EdmProperty(
"Id",
ProviderRegistry.Sql2008_ProviderManifest.GetStoreType(
TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))));
columnB.SetOrder(1);
table.AddColumn(columnB);
var database = new EdmModel(DataSpace.CSpace);
database.AddEntitySet("ES", table);
(new ColumnOrderingConvention()).Apply(table, new DbModel(null, database));
Assert.Equal(2, table.Properties.Count);
Assert.Equal("Id", table.Properties.First().Name);
}
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 Generate_maps_abstract_type_hierarchies_correctly()
{
var model = new EdmModel(DataSpace.CSpace);
var rootEntityType = model.AddEntityType("E");
rootEntityType.Annotations.SetClrType(typeof(object));
var property0
= EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property0);
rootEntityType.AddKeyMember(rootEntityType.Properties.First());
var property1
= EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property1);
model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
var property2
= EdmProperty.Primitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType2.AddMember(property2);
entityType2.Annotations.SetClrType(typeof(string));
entityType2.Abstract = true;
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
entityType3.Annotations.SetClrType(typeof(int));
var property3
= EdmProperty.Primitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType3.AddMember(property3);
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.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_a_simple_entity_type_and_set()
{
var model = new EdmModel(DataSpace.CSpace);
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 Generate_can_map_type_hierarchies_using_Tph()
{
var model = new EdmModel(DataSpace.CSpace);
var rootEntityType = model.AddEntityType("E");
var type = typeof(object);
rootEntityType.Annotations.SetClrType(type);
var property = EdmProperty.Primitive("P1", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property);
var property1 = EdmProperty.Primitive("P2", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
rootEntityType.AddMember(property1);
var entitySet = model.AddEntitySet("ESet", rootEntityType);
var entityType2 = model.AddEntityType("E2");
var property2 = EdmProperty.Primitive("P3", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType2.AddMember(property2);
var type1 = typeof(string);
entityType2.Annotations.SetClrType(type1);
entityType2.BaseType = rootEntityType;
var entityType3 = model.AddEntityType("E3");
var type2 = typeof(int);
entityType3.Annotations.SetClrType(type2);
var property3 = EdmProperty.Primitive("P4", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
entityType3.AddMember(property3);
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.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 Apply_should_uniquify_names_multiple()
{
var model = new EdmModel(DataSpace.CSpace);
model.AddEntitySet("Cats1", new EntityType("E", "N", DataSpace.CSpace));
var entitySet1 = model.AddEntitySet("Cats", new EntityType("E", "N", DataSpace.CSpace));
var entitySet2 = model.AddEntitySet("Cat", new EntityType("E", "N", DataSpace.CSpace));
(new PluralizingEntitySetNameConvention())
.Apply(entitySet1, new DbModel(model, null));
(new PluralizingEntitySetNameConvention())
.Apply(entitySet2, new DbModel(model, null));
Assert.Equal("Cats", entitySet1.Name);
Assert.Equal("Cats2", entitySet2.Name);
}
public void Validate_should_throw()
{
var model = new EdmModel().Initialize();
model.AddEntitySet("S", new EntityType());
Assert.Throws <ModelValidationException>(() => model.ValidateCsdl());
}
public void Validate_should_throw()
{
var model = new EdmModel(DataSpace.CSpace);
model.AddEntitySet("S", new EntityType("E", "N", DataSpace.CSpace));
Assert.Throws <ModelValidationException>(() => model.Validate());
}
public void Apply_should_ignore_current_entity_set()
{
var model = new EdmModel().Initialize();
var entitySet = model.AddEntitySet("Cats", new EntityType());
((IEdmConvention <EntitySet>) new PluralizingEntitySetNameConvention())
.Apply(entitySet, model);
Assert.Equal("Cats", entitySet.Name);
}
public void Apply_should_ignore_current_entity_set()
{
var model = new EdmModel(DataSpace.CSpace);
var entitySet = model.AddEntitySet("Cats", new EntityType("E", "N", DataSpace.CSpace));
(new PluralizingEntitySetNameConvention())
.Apply(entitySet, new DbModel(model, null));
Assert.Equal("Cats", entitySet.Name);
}
public void GetValidationErrors_should_return_validation_errors()
{
var model = new EdmModel().Initialize();
model.AddEntitySet("S", new EntityType());
var validationErrors = model.GetCsdlErrors();
Assert.Equal(1, validationErrors.Count());
}
public static System.Data.Entity.Core.Metadata.Edm.EntityType AddTable(
this EdmModel database,
string name)
{
string str = ((IEnumerable <INamedDataModelItem>)database.EntityTypes).UniquifyName(name);
System.Data.Entity.Core.Metadata.Edm.EntityType elementType = new System.Data.Entity.Core.Metadata.Edm.EntityType(str, "CodeFirstDatabaseSchema", DataSpace.SSpace);
database.AddItem(elementType);
database.AddEntitySet(elementType.Name, elementType, str);
return(elementType);
}
public void GetEntitySet_should_return_entity_set()
{
var model = new EdmModel(DataSpace.CSpace);
var entityType = model.AddEntityType("Foo");
model.AddEntitySet("FooSet", entityType);
var entitySet = model.GetEntitySet(entityType);
Assert.NotNull(entitySet);
Assert.Same(entityType, entitySet.ElementType);
}
public void ReplaceEntitySet_should_remove_set_with_type()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("Foo");
model.AddEntitySet("FooSet", entityType);
model.ReplaceEntitySet(entityType, null);
Assert.Equal(1, model.GetEntityTypes().Count());
Assert.Equal(0, model.Containers.First().EntitySets.Count());
}
public void Apply_should_set_pluralized_table_name_as_identitier()
{
var database = new EdmModel(DataSpace.CSpace);
var table = new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace);
var entitySet = database.AddEntitySet("ES", table);
entitySet.Table = "Customer";
((IDbConvention <EntityType>) new PluralizingTableNameConvention()).Apply(table, database);
Assert.Equal("Customers", entitySet.Table);
}
public void Apply_should_ignore_current_table()
{
var database = new EdmModel().Initialize();
var table = new EntityType("T", XmlConstants.TargetNamespace_3, DataSpace.SSpace);
var entitySet = database.AddEntitySet("ES", table);
entitySet.Table = "Customers";
((IDbConvention <EntityType>) new PluralizingTableNameConvention()).Apply(table, database);
Assert.Equal("Customers", entitySet.Table);
}
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 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));
}
private EdmModel CreateModelWithAssociations(params EdmProperty[] foreignKeys)
{
var model = new EdmModel(DataSpace.SSpace);
for (var i = 0; i < foreignKeys.Length; i++)
{
var sourceEntityType = new EntityType("E" + i, "N", DataSpace.SSpace);
var targetEntityType = new EntityType("E" + i, "N", DataSpace.SSpace);
model.AddEntitySet("S" + i, sourceEntityType);
model.AddEntitySet("T" + i, targetEntityType);
var fk = foreignKeys[i];
var associationType = new AssociationType((fk == null ? "IA" : fk.Name) + i, "MN", false, DataSpace.SSpace)
{
SourceEnd = new AssociationEndMember(
"A_Source" + i, sourceEntityType.GetReferenceType(), RelationshipMultiplicity.ZeroOrOne),
TargetEnd = new AssociationEndMember(
"A_Target" + i, targetEntityType.GetReferenceType(), RelationshipMultiplicity.Many)
};
model.AddAssociationType(associationType);
if (fk != null)
{
var constraint = new ReferentialConstraint(
associationType.SourceEnd,
associationType.TargetEnd,
new[] { new EdmProperty("SourceProperty") },
new[] { fk });
associationType.Constraint = constraint;
}
model.AddAssociationSet("Set" + (fk == null ? "IA" : fk.Name) + i, associationType);
}
return(model);
}
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 Map_should_map_entity_navigation_properties()
{
var model = new EdmModel(DataSpace.CSpace);
var entityType = new EntityType("E", "N", DataSpace.CSpace);
model.AddEntitySet("Source", entityType);
var mappingContext
= new MappingContext(new ModelConfiguration(), new ConventionsConfiguration(), model);
new PropertyMapper(new TypeMapper(mappingContext))
.Map(new MockPropertyInfo(new MockType(), "Foo"), entityType, () => new EntityTypeConfiguration(typeof(object)));
Assert.Equal(1, entityType.DeclaredNavigationProperties.Count);
}