public static void BuildAssociationSetMappings_creates_valid_association_set_mappings()
{
var mappingContext = CreateSimpleMappingContext(isForeignKey: false);
var storeContainer = mappingContext.StoreContainers().Single();
var modelContainer = mappingContext[storeContainer];
var entityContainerMapping =
new EntityContainerMapping(modelContainer, storeContainer, null, false, false);
var associationSetMappings =
DbDatabaseMappingBuilder.BuildAssociationSetMappings(entityContainerMapping, mappingContext);
Assert.Equal(1, associationSetMappings.Count());
var setMapping = associationSetMappings.First();
Assert.Equal("modelAS", setMapping.Set.Name);
Assert.Equal("storeET2", setMapping.Table.Name);
Assert.Equal(1, setMapping.TypeMappings.Count());
Assert.Equal(1, setMapping.TypeMappings.ElementAt(0).Types.Count);
Assert.Equal("modelAT", setMapping.TypeMappings.ElementAt(0).Types[0].Name);
Assert.Equal("modelEM1", setMapping.SourceEndMapping.AssociationEnd.Name);
Assert.Equal("modelEM2", setMapping.TargetEndMapping.AssociationEnd.Name);
Assert.Equal(1, setMapping.SourceEndMapping.PropertyMappings.Count);
Assert.Equal(1, setMapping.TargetEndMapping.PropertyMappings.Count);
Assert.Equal("modelSourceId", setMapping.SourceEndMapping.PropertyMappings[0].Property.Name);
Assert.Equal("modelTargetId", setMapping.TargetEndMapping.PropertyMappings[0].Property.Name);
Assert.Equal(1, setMapping.Conditions.Count());
Assert.Equal("storeTargetId", setMapping.Conditions.First().Column.Name);
Assert.Equal(false, setMapping.Conditions.First().IsNull);
}
public void BuildEntitySetMapping_creates_valid_entity_set_mapping()
{
var storeEntityType =
EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null);
var modelEntityType =
EntityType.Create("foo_C", "bar_C", DataSpace.CSpace, null, null, null);
var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null);
var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null);
var modelEntitySet = EntitySet.Create("ES_C", "Ns_C", null, null, storeEntityType, null);
var modelContainer = EntityContainer.Create("C_C", DataSpace.SSpace, new[] { modelEntitySet }, null, null);
var storageContainerMapping =
new EntityContainerMapping(modelContainer, storeContainer, null, false, false);
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true);
mappingContext.AddMapping(storeEntitySet, modelEntitySet);
mappingContext.AddMapping(storeEntityType, modelEntityType);
var entitySetMapping =
DbDatabaseMappingBuilder.BuildEntitySetMappings(storageContainerMapping, mappingContext).Single();
Assert.Same(modelEntitySet, entitySetMapping.EntitySet);
Assert.Equal(1, entitySetMapping.EntityTypeMappings.Count());
}
public void Build_builds_valid_DbDatabaseMapping_for_entity_types()
{
var storeEntityType =
EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null);
var modelEntityType =
EntityType.Create("foo_C", "bar_C", DataSpace.CSpace, null, null, null);
var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null);
var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null);
var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null);
var modelEntitySet = EntitySet.Create("ES_C", "Ns_C", null, null, storeEntityType, null);
var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new[] { modelEntitySet }, null, null);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(storeContainer, modelContainer);
mappingContext.AddMapping(storeEntitySet, modelEntitySet);
mappingContext.AddMapping(storeEntityType, modelEntityType);
var dbMapping = DbDatabaseMappingBuilder.Build(mappingContext).DatabaseMapping;
Assert.Same(storeModel, dbMapping.Database);
var entityContainerMapping = dbMapping.EntityContainerMappings.Single();
Assert.Same(storeContainer, entityContainerMapping.StorageEntityContainer);
Assert.Same(modelContainer, entityContainerMapping.EdmEntityContainer);
Assert.Equal(1, entityContainerMapping.EntitySetMappings.Count());
Assert.NotNull(dbMapping.Model);
Assert.Same(modelContainer, dbMapping.Model.Containers.Single());
Assert.Same(modelEntityType, dbMapping.Model.EntityTypes.Single());
}
public static void BuildAssociationSetMappings_does_not_create_mappings_if_association_type_is_foreign_key()
{
var mappingContext = CreateSimpleMappingContext(isForeignKey: true);
var storeContainer = mappingContext.StoreContainers().Single();
var modelContainer = mappingContext[storeContainer];
var entityContainerMapping =
new EntityContainerMapping(modelContainer, storeContainer, null, false, false);
var associationSetMappings =
DbDatabaseMappingBuilder.BuildAssociationSetMappings(entityContainerMapping, mappingContext);
Assert.Equal(0, associationSetMappings.Count());
}
public void BuildEntityMapping_creates_valid_entity_mappings()
{
var storeEntityType =
EntityType.Create(
"foo_S",
"bar_S",
DataSpace.SSpace,
new[] { "Id" },
new[] { CreateStoreProperty("Id", "int") },
null);
var modelEntityType =
EntityType.Create(
"foo_C",
"bar_C",
DataSpace.CSpace,
new[] { "C_Id" },
new[] { EdmProperty.CreatePrimitive("C_Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)) },
null);
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true);
mappingContext.AddMapping(storeEntityType, modelEntityType);
mappingContext.AddMapping(storeEntityType.Properties.Single(), modelEntityType.Properties.Single());
var modelEntitySet = EntitySet.Create("ES", "Ns", null, null, modelEntityType, null);
var modelEntityContainer = EntityContainer.Create("C", DataSpace.SSpace, new[] { modelEntitySet }, null, null);
var storeEntitySet = EntitySet.Create("ES", "Ns.Store", null, null, storeEntityType, null);
var storageEntitySetMapping =
new EntitySetMapping(
modelEntitySet,
new EntityContainerMapping(modelEntityContainer, null, null, false, false));
var typeMapping =
DbDatabaseMappingBuilder
.BuildEntityTypeMapping(storageEntitySetMapping, mappingContext, storeEntitySet);
Assert.Same(modelEntityType, typeMapping.EntityType);
Assert.Equal(1, typeMapping.MappingFragments.Count);
var mappingFragment = typeMapping.MappingFragments.Single();
Assert.Equal(storeEntityType, mappingFragment.Table);
Assert.Equal(1, mappingFragment.ColumnMappings.Count());
}
public void BuildPropertyMapping_does_not_build_property_mappings_for_foreign_key_properties_if_foreign_keys_disabled()
{
var storeEntityType =
EntityType.Create(
"foo",
"bar",
DataSpace.SSpace,
new[] { "Id" },
new[]
{
CreateStoreProperty("Id", "int"),
CreateStoreProperty("ForeignKey", "int"),
},
null);
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), false);
mappingContext.StoreForeignKeyProperties.Add(storeEntityType.Properties.Single(p => p.Name == "ForeignKey"));
foreach (var storeProperty in storeEntityType.Properties)
{
mappingContext.AddMapping(
storeProperty,
EdmProperty.CreatePrimitive(
storeProperty.Name + "Model",
(PrimitiveType)storeProperty.TypeUsage.EdmType));
}
var propertyMappings =
DbDatabaseMappingBuilder
.BuildPropertyMapping(storeEntityType, mappingContext);
Assert.Equal(
new[] { "Id" },
propertyMappings.Select(m => m.ColumnProperty.Name));
Assert.Equal(
new[] { "IdModel" },
propertyMappings.SelectMany(m => m.PropertyPath, (m, p) => p.Name));
}
public void BuildPropertyMapping_creates_valid_property_mappings()
{
var storeEntityType =
EntityType.Create(
"foo",
"bar",
DataSpace.SSpace,
new[] { "Id" },
new[]
{
CreateStoreProperty("Id", "int"),
CreateStoreProperty("FirstName", "nvarchar"),
CreateStoreProperty("LastName", "char")
},
null);
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true);
foreach (var storeProperty in storeEntityType.Properties)
{
mappingContext.AddMapping(
storeProperty,
EdmProperty.CreatePrimitive(
storeProperty.Name + "Model",
(PrimitiveType)storeProperty.TypeUsage.EdmType));
}
var propertyMappings =
DbDatabaseMappingBuilder
.BuildPropertyMapping(storeEntityType, mappingContext);
Assert.Equal(
new[] { "Id", "FirstName", "LastName" },
propertyMappings.Select(m => m.ColumnProperty.Name));
Assert.Equal(
new[] { "IdModel", "FirstNameModel", "LastNameModel" },
propertyMappings.SelectMany(m => m.PropertyPath, (m, p) => p.Name));
}
public void Build_adds_association_types_to_model()
{
var storeEntityType =
EntityType.Create("foo_S", "bar_S", DataSpace.SSpace, null, null, null);
var storeEntitySet = EntitySet.Create("ES_S", "Ns_S", null, null, storeEntityType, null);
var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new[] { storeEntitySet }, null, null);
var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null);
var conceptualAssociationType =
AssociationType.Create("AT_C", "ns", false, DataSpace.CSpace, null, null, null, null);
var associationSet = AssociationSet.Create("AS_C", conceptualAssociationType, null, null, null);
var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new[] { associationSet }, null, null);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(storeContainer, modelContainer);
mappingContext.AddMapping(new CollapsibleEntityAssociationSets(storeEntitySet), associationSet);
var model = DbDatabaseMappingBuilder.Build(mappingContext);
Assert.Same(conceptualAssociationType, model.ConceptualModel.AssociationTypes.SingleOrDefault());
}
public void Build_does_not_try_map_not_mapped_functions()
{
var rowTypeProperty = CreateStoreProperty("p1", "int");
var storeFunction = EdmFunction.Create(
"f_s",
"storeModel",
DataSpace.SSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = false,
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(),
ParameterMode.ReturnValue)
}
},
null);
var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], null, null);
var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null);
var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null);
storeModel.AddItem(storeFunction);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(storeContainer, modelContainer);
var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel;
Assert.NotNull(entityModel);
Assert.Empty(entityModel.Containers.Single().FunctionImports);
}
public void Build_builds_valid_DbDatabaseMapping_for_functions()
{
var rowTypeProperty = CreateStoreProperty("p1", "int");
var complexTypeProperty =
EdmProperty.Create(
"p2",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)));
var functionImportReturnComplexType =
ComplexType.Create(
"CT",
"entityModel",
DataSpace.CSpace,
new[] { complexTypeProperty }, null);
var storeFunction = EdmFunction.Create(
"f_s",
"storeModel",
DataSpace.SSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = false,
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(),
ParameterMode.ReturnValue)
}
},
null);
var functionImport =
EdmFunction.Create(
"f_c",
"entityModel",
DataSpace.CSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = true,
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
functionImportReturnComplexType.GetCollectionType(),
ParameterMode.ReturnValue)
}
},
null);
var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], new[] { functionImport }, null);
var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null);
var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null);
storeModel.AddItem(storeFunction);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(rowTypeProperty, complexTypeProperty);
mappingContext.AddMapping(storeFunction, functionImport);
mappingContext.AddMapping(storeContainer, modelContainer);
var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel;
Assert.NotNull(entityModel);
Assert.Equal(new[] { "f_c" }, entityModel.Containers.Single().FunctionImports.Select(f => f.Name));
Assert.Equal(new[] { "CT" }, entityModel.ComplexTypes.Select(t => t.Name));
}
public void BuildComposableFunctionMapping_creates_valid_function_mapping()
{
var rowTypeProperty = CreateStoreProperty("p1", "int");
var complexTypeProperty =
EdmProperty.Create(
"p2",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)));
var functionImportReturnComplexType =
ComplexType.Create(
"c",
"entityModel",
DataSpace.CSpace,
new[] { complexTypeProperty }, null);
var storeFunction = EdmFunction.Create(
"f_s",
"storeModel",
DataSpace.SSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = false,
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(),
ParameterMode.ReturnValue)
}
},
null);
var functionImport =
EdmFunction.Create(
"f_c",
"entityModel",
DataSpace.CSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = false,
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
functionImportReturnComplexType.GetCollectionType(),
ParameterMode.ReturnValue)
}
},
null);
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true);
mappingContext.AddMapping(rowTypeProperty, complexTypeProperty);
mappingContext.AddMapping(storeFunction, functionImport);
var functionImportMapping =
DbDatabaseMappingBuilder.BuildComposableFunctionMapping(storeFunction, mappingContext);
Assert.NotNull(functionImportMapping);
Assert.Same(storeFunction, functionImportMapping.TargetFunction);
Assert.Same(functionImport, functionImportMapping.FunctionImport);
var structuralTypeMappings = functionImportMapping.StructuralTypeMappings;
Assert.NotNull(structuralTypeMappings);
Assert.Same(functionImportReturnComplexType, structuralTypeMappings.Single().Item1);
Assert.Empty(structuralTypeMappings.Single().Item2);
Assert.Same(complexTypeProperty, structuralTypeMappings.Single().Item3.Single().Property);
Assert.Same(rowTypeProperty, ((ScalarPropertyMapping)structuralTypeMappings.Single().Item3.Single()).Column);
}
public void BuildAssociationSetMappings_builds_conceptual_association_set_mapping_for_collapsed_store_entity_sets()
{
#region Setting up many to many relationship in the SSpace Teacher * -- 1 TeacherStudents 1 -- * Teachers
var joinStoreEntityType =
EntityType.Create(
"TeacherStudents", "ns.Store", DataSpace.SSpace,
new[] { "JoinTeacherId", "JoinStudentId" },
new[]
{
CreateStoreProperty("JoinTeacherId", "int"),
CreateStoreProperty("JoinStudentId", "int")
}, null);
var joinStoreEntitySet =
EntitySet.Create("TeacherStudentsSet", "dbo", "TeacherStudentTable", null, joinStoreEntityType, null);
var storeTeacherEntityType =
EntityType.Create(
"Teacher", "ns.Store", DataSpace.SSpace, new[] { "TeacherId" },
new[] { CreateStoreProperty("TeacherId", "int") }, null);
var storeTeacherEntitySet =
EntitySet.Create("TeachersSet", "dbo", "Teachers", null, storeTeacherEntityType, null);
var storeStudentEntityType =
EntityType.Create(
"Student", "ns.Store", DataSpace.SSpace, new[] { "StudentId" },
new[] { CreateStoreProperty("StudentId", "int") }, null);
var storeStudentEntitySet =
EntitySet.Create("StudentSet", "dbo", "Students", null, storeStudentEntityType, null);
var storeTeachersEndMember =
AssociationEndMember.Create(
"Teachers", storeTeacherEntityType.GetReferenceType(), RelationshipMultiplicity.Many,
OperationAction.None, null);
var storeTeacherStudentsfromTeachersEndMember =
AssociationEndMember.Create(
"TeacherStudents_fromTeachers", joinStoreEntityType.GetReferenceType(), RelationshipMultiplicity.One,
OperationAction.None, null);
var storeTeacherAssociationType =
AssociationType.Create(
"Teacher_TeacherStudentsAssociationType", "ns.Store", false, DataSpace.SSpace,
storeTeachersEndMember, storeTeacherStudentsfromTeachersEndMember,
new ReferentialConstraint(
storeTeachersEndMember, storeTeacherStudentsfromTeachersEndMember, storeTeacherEntityType.KeyProperties,
joinStoreEntityType.KeyProperties.Where(p => p.Name == "JoinTeacherId")),
null);
var storeTeacherAssociationSet =
AssociationSet.Create(
"Teacher_TeacherStudents", storeTeacherAssociationType, storeTeacherEntitySet, joinStoreEntitySet, null);
var storeStudentsEndMember =
AssociationEndMember.Create(
"Students", storeStudentEntityType.GetReferenceType(), RelationshipMultiplicity.Many,
OperationAction.None, null);
var storeTeacherStudentsfromStudentsEndMember =
AssociationEndMember.Create(
"TeacherStudents_fromStudents", joinStoreEntityType.GetReferenceType(), RelationshipMultiplicity.One,
OperationAction.None, null);
var storeStudentAssociationType =
AssociationType.Create(
"Student_TeacherStudentsAssociationType", "ns.Store", false, DataSpace.SSpace,
storeStudentsEndMember,
storeTeacherStudentsfromStudentsEndMember,
new ReferentialConstraint(
storeStudentsEndMember, storeTeacherStudentsfromStudentsEndMember, storeStudentEntityType.KeyProperties,
joinStoreEntityType.KeyProperties.Where(p => p.Name == "JoinStudentId")),
null);
var storeStudentAssociationSet =
AssociationSet.Create(
"Student_TeacherStudents", storeStudentAssociationType, storeStudentEntitySet, joinStoreEntitySet, null);
var collapsedAssociationSet = new CollapsibleEntityAssociationSets(joinStoreEntitySet);
collapsedAssociationSet.AssociationSets.Add(storeTeacherAssociationSet);
collapsedAssociationSet.AssociationSets.Add(storeStudentAssociationSet);
#endregion
#region Setting up many to many relationship in the CSpace Teacher * -- * Teachers
var conceptualContainer = EntityContainer.Create("ConceptualContainer", DataSpace.CSpace, null, null, null);
var edmIntTypeUsage =
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
var conceptualTeacherEntityType =
EntityType.Create(
"Teacher", "ns", DataSpace.CSpace, new[] { "TeacherId" },
new[] { EdmProperty.Create("TeacherId", edmIntTypeUsage) }, null);
var conceptualTeacherEntitySet =
EntitySet.Create("TeachersSet", null, null, null, conceptualTeacherEntityType, null);
var conceptualStudentEntityType =
EntityType.Create(
"Student", "ns", DataSpace.CSpace, new[] { "StudentId" },
new[] { EdmProperty.Create("StudentId", edmIntTypeUsage) }, null);
var conceptualStudentEntitySet =
EntitySet.Create("StudentSet", "dbo", "Students", null, conceptualStudentEntityType, null);
var conceptualTeachersEndMember =
AssociationEndMember.Create(
"TeachersEnd", conceptualTeacherEntityType.GetReferenceType(), RelationshipMultiplicity.Many,
OperationAction.None, null);
var conceptualStudentsEndMember =
AssociationEndMember.Create(
"StudentsEnd", conceptualStudentEntityType.GetReferenceType(), RelationshipMultiplicity.Many,
OperationAction.None, null);
var conceptualAssociationType =
AssociationType.Create(
"TeacherStudentAssociation",
"ns.Model",
false,
DataSpace.CSpace,
conceptualTeachersEndMember,
conceptualStudentsEndMember,
new ReferentialConstraint(
conceptualTeachersEndMember, conceptualStudentsEndMember,
conceptualTeacherEntityType.KeyProperties, conceptualStudentEntityType.KeyProperties),
null);
var conceptualAssociationSet =
AssociationSet.Create(
"TeacherStudentSet", conceptualAssociationType, conceptualTeacherEntitySet,
conceptualStudentEntitySet, null);
#endregion
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true);
mappingContext.AddMapping(collapsedAssociationSet, conceptualAssociationSet);
mappingContext.AddMapping(storeTeachersEndMember, conceptualTeachersEndMember);
mappingContext.AddMapping(storeStudentsEndMember, conceptualStudentsEndMember);
mappingContext.AddMapping(
storeTeacherAssociationSet.AssociationSetEnds.ElementAt(0),
conceptualAssociationSet.AssociationSetEnds.ElementAt(0));
mappingContext.AddMapping(
storeStudentAssociationSet.AssociationSetEnds.ElementAt(0),
conceptualAssociationSet.AssociationSetEnds.ElementAt(1));
mappingContext.AddMapping(
storeStudentEntityType.KeyProperties.Single(), conceptualStudentEntityType.KeyProperties.Single());
mappingContext.AddMapping(
storeTeacherEntityType.KeyProperties.Single(), conceptualTeacherEntityType.KeyProperties.Single());
var storageEntitySetMapping =
new EntityContainerMapping(conceptualContainer, null, null, false, false);
var associationSetMapping =
DbDatabaseMappingBuilder.BuildAssociationSetMappings(storageEntitySetMapping, mappingContext)
.SingleOrDefault();
Assert.NotNull(associationSetMapping);
var mappingFragment = associationSetMapping.TypeMappings.SingleOrDefault();
Assert.NotNull(mappingFragment);
var propertyMappings = mappingFragment.MappingFragments.Single().PropertyMappings;
Assert.Equal(2, propertyMappings.Count);
Assert.Same(conceptualTeachersEndMember, ((EndPropertyMapping)propertyMappings[0]).AssociationEnd);
Assert.Same(conceptualStudentsEndMember, ((EndPropertyMapping)propertyMappings[1]).AssociationEnd);
var scalarPropertyMapping = ((EndPropertyMapping)propertyMappings[0]).PropertyMappings.Single();
Assert.Same(conceptualTeacherEntityType.KeyMembers.Single(), scalarPropertyMapping.Property);
Assert.Same(
joinStoreEntityType.KeyMembers.Single(m => m.Name == "JoinTeacherId"),
scalarPropertyMapping.Column);
scalarPropertyMapping = ((EndPropertyMapping)propertyMappings[1]).PropertyMappings.Single();
Assert.Same(conceptualStudentEntityType.KeyMembers.Single(), scalarPropertyMapping.Property);
Assert.Same(
joinStoreEntityType.KeyMembers.Single(m => m.Name == "JoinStudentId"),
scalarPropertyMapping.Column);
}
