public void CloneWithDefiningQuery_does_not_creat_schema_and_table_extended_attributes_if_they_are_null()
{
var property =
EdmProperty.CreatePrimitive(
"Id",
ProviderManifest.GetStoreTypes().Single(t => t.PrimitiveTypeKind == PrimitiveTypeKind.Int32));
var customMetadataProperty =
MetadataProperty.Create(
"http://tempUri:myProperty",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
"value");
var entityType =
EntityType.Create("EntityType", "MyModel", DataSpace.SSpace, new[] { "Id" }, new[] { property }, null);
var entitySet = EntitySet.Create("EntityTypeSet", null, null, null, entityType, new[] { customMetadataProperty });
var clonedEntitySet = EntitySetDefiningQueryConverter.CloneWithDefiningQuery(entitySet, "definingQuery");
Assert.Null(clonedEntitySet.Schema);
Assert.Null(clonedEntitySet.Table);
Assert.False(entitySet.MetadataProperties.Any(p => p.Name.EndsWith(StoreSchemaAttributeNamespace + ":Schema")));
Assert.False(entitySet.MetadataProperties.Any(p => p.Name.EndsWith(StoreSchemaAttributeNamespace + ":Name")));
}
private static EntityType CreateEntityTypeWithExtendedProperty(XNamespace copyToSSDLNamespace, string copyToSSDLValue)
{
var extendedPropertyContents =
new XElement(
(XNamespace)"http://myExtendedProperties" + "MyProp",
new XAttribute(
(XNamespace)"http://myExtendedProperties" + "MyAttribute", "MyValue"),
new XAttribute(
copyToSSDLNamespace + "CopyToSSDL", copyToSSDLValue));
var extendedPropertyMetadataProperty =
MetadataProperty.Create(
"http://myExtendedProperties:MyProp",
TypeUsage.CreateStringTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String),
true,
false),
extendedPropertyContents
);
return(EntityType.Create(
"TestEntityType",
"Model1",
DataSpace.CSpace,
new[] { "Id" },
new[] { EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)) },
new[] { extendedPropertyMetadataProperty }));
}
public void CreateTransientMetadataWorkspace_creates_workspace_with_provided_store_entity_sets()
{
var property =
EdmProperty.CreatePrimitive(
"Id",
ProviderManifest.GetStoreTypes().Single(t => t.PrimitiveTypeKind == PrimitiveTypeKind.Int32));
property.Nullable = false;
var entityType =
EntityType.Create("EntityType", "MyModel", DataSpace.SSpace, new[] { "Id" }, new[] { property }, null);
var entitySet = EntitySet.Create("EntityTypeSet", "dbo", "EntityTypes", null, entityType, null);
var workspace =
EntitySetDefiningQueryConverter.CreateTransientMetadataWorkspace(
new List <EntitySet> {
entitySet
},
EntityFrameworkVersion.Version3,
"System.Data.SqlClient", "2008", ProviderManifest);
Assert.NotNull(workspace);
var storeItemCollection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);
Assert.NotNull(storeItemCollection);
Assert.Equal(1, storeItemCollection.GetEntityContainer("StoreModelContainer").EntitySets.Count);
Assert.Equal(
"EntityTypeSet",
storeItemCollection.GetEntityContainer("StoreModelContainer").EntitySets.Single().Name);
Assert.Equal(1, storeItemCollection.GetItems <EntityType>().Count);
Assert.Equal("EntityType", storeItemCollection.GetItems <EntityType>().Single().Name);
Assert.NotNull(workspace.GetItemCollection(DataSpace.CSpace));
Assert.NotNull(workspace.GetItemCollection(DataSpace.CSSpace));
}
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 void UpdateConceptualModel_does_not_update_csdl_when_ReplaceEdmxSection_returns_false()
{
// This test is really only to test that EdmxHelper.ReplaceEdmxSection() returns false
// when the underlying XmlWriter returns null (because of errors in the model it is trying
// to write) - but that method is private so need to test through one of the other methods
var edmx = XDocument.Parse(EdmxTemplate);
// create EntityType with no members (and hence no keys) which will cause error
var edmModel = new EdmModel(DataSpace.CSpace);
edmModel.AddItem(
EntityType.Create(
"TestEntity", "TestNamespace", DataSpace.CSpace,
new string[0], new EdmMember[0], new MetadataProperty[0]));
new EdmxHelper(edmx).UpdateConceptualModels(edmModel, "modelNamespace");
var conceptualModelsElements =
edmx.Descendants(EdmxV3Namespace + "ConceptualModels").Single();
Assert.Equal(1, conceptualModelsElements.Elements().Count());
Assert.Equal(
XNamespace.None + "dummy",
conceptualModelsElements.Elements().Single().Name);
}
public void CollectStoreModelErrors_returns_errors_on_model_items()
{
var edmSchemaError = new EdmSchemaError("msg", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List <EdmSchemaError> {
edmSchemaError
});
var entityType =
EntityType.Create(
"foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0],
new[] { errorMetadataProperty });
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(entityType);
var schemaErrors = ModelGenerator.CollectStoreModelErrors(model);
Assert.NotNull(schemaErrors);
Assert.Equal(1, schemaErrors.Count);
Assert.Same(edmSchemaError, schemaErrors.Single());
}
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 EntityTypeShouldBeEscaped()
{
var edmType = EntityType.Create("string", "Transient", DataSpace.CSSpace, null, null, null);
var typeUsage = TypeUsage.Create(edmType, Enumerable.Empty <Facet>());
this.escaper.Escape(typeUsage).Should().Be("@string");
}
public void IsKey_returns_true_when_key()
{
var property = EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
EntityType.Create("Person", "MyModel", DataSpace.CSpace, new[] { "Id" }, new[] { property }, null);
Assert.True(property.IsKey());
}
public static EntitySetBase CreateEntitySet(string containerName, string entitySetName, string entityTypeName = "E", string modelNamespace = "Model")
{
var entity = EntityType.Create(entityTypeName, modelNamespace, DataSpace.CSpace, new string[0], new EdmMember[0], null);
var entitySet = EntitySet.Create(entitySetName, modelNamespace, null, null, entity, null);
EntityContainer.Create(containerName, DataSpace.CSpace, new[] { entitySet }, null, null);
return(entitySet);
}
private EntityType GetEntityType(DbModel model)
{
string name = this.mType.Name;
List <EdmMember> members = this.GetEdmMembers(model);
return(EntityType.Create(name, constant.Namespace, DataSpace.SSpace, new List <string>()
{
members.First().Name
}, members, null));
}
public void HasConventionalKeyName_returns_true_when_type_and_id()
{
var property = EdmProperty.CreatePrimitive(
"PersonId",
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
EntityType.Create("Person", "MyModel", DataSpace.CSpace, null, new[] { property }, null);
Assert.True(property.HasConventionalKeyName());
}
private static SimpleMappingContext CreateSimpleMappingContext(bool isForeignKey)
{
var int32TypeUsage = TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
var storeP1 = new[] { CreateStoreProperty("storeSourceId", "int") };
var storeP2 = new[] { CreateStoreProperty("storeTargetId", "int") };
var modelP1 = new[] { EdmProperty.Create("modelSourceId", int32TypeUsage) };
var modelP2 = new[] { EdmProperty.Create("modelTargetId", int32TypeUsage) };
var storeET1 = EntityType.Create("storeET1", "N", DataSpace.SSpace, new[] { "storeSourceId" }, storeP1, null);
var storeET2 = EntityType.Create("storeET2", "N", DataSpace.SSpace, new[] { "storeTargetId" }, storeP2, null);
var modelET1 = EntityType.Create("modelET1", "N", DataSpace.CSpace, new[] { "modelSourceId" }, modelP1, null);
var modelET2 = EntityType.Create("modelET2", "N", DataSpace.CSpace, new[] { "modelTargetId" }, modelP2, null);
var storeES1 = EntitySet.Create("storeES1", null, null, null, storeET1, null);
var storeES2 = EntitySet.Create("storeES2", null, null, null, storeET2, null);
var modelES1 = EntitySet.Create("modelES1", null, null, null, modelET1, null);
var modelES2 = EntitySet.Create("modelES2", null, null, null, modelET2, null);
var storeEM1 = AssociationEndMember.Create(
"storeEM1", storeET1.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null);
var storeEM2 = AssociationEndMember.Create(
"storeEM2", storeET2.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null);
var modelEM1 = AssociationEndMember.Create(
"modelEM1", modelET1.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null);
var modelEM2 = AssociationEndMember.Create(
"modelEM2", modelET2.GetReferenceType(), RelationshipMultiplicity.Many, OperationAction.None, null);
var storeRC = new ReferentialConstraint(storeEM1, storeEM2, storeP1, storeP2);
var modelRC = new ReferentialConstraint(modelEM1, modelEM2, modelP1, modelP2);
var storeAT = AssociationType.Create("storeAT", "N", isForeignKey, DataSpace.SSpace, storeEM1, storeEM2, storeRC, null);
var modelAT = AssociationType.Create("modelAT", "N", isForeignKey, DataSpace.CSpace, modelEM1, modelEM2, modelRC, null);
var storeAS = AssociationSet.Create("storeAS", storeAT, storeES1, storeES2, null);
var modelAS = AssociationSet.Create("modelAS", modelAT, modelES1, modelES2, null);
var storeContainer = EntityContainer.Create(
"storeContainer", DataSpace.SSpace, new EntitySetBase[] { storeES1, storeES2, storeAS }, null, null);
var modelContainer = EntityContainer.Create(
"modelContainer", DataSpace.CSpace, new EntitySetBase[] { modelES1, modelES2, modelAS }, null, null);
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true);
mappingContext.AddMapping(storeP1[0], modelP1[0]);
mappingContext.AddMapping(storeP2[0], modelP2[0]);
mappingContext.AddMapping(storeET1, modelET1);
mappingContext.AddMapping(storeET2, modelET2);
mappingContext.AddMapping(storeES1, modelES1);
mappingContext.AddMapping(storeES2, modelES2);
mappingContext.AddMapping(storeEM1, modelEM1);
mappingContext.AddMapping(storeEM2, modelEM2);
mappingContext.AddMapping(storeAT, modelAT);
mappingContext.AddMapping(storeAS, modelAS);
mappingContext.AddMapping(storeAS.AssociationSetEnds[0], modelAS.AssociationSetEnds[0]);
mappingContext.AddMapping(storeAS.AssociationSetEnds[1], modelAS.AssociationSetEnds[1]);
mappingContext.AddMapping(storeContainer, modelContainer);
return(mappingContext);
}
private static EntityType CreateEntityType()
{
var idProperty = EdmProperty.Create(
"Id",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)));
var nameProperty = EdmProperty.Create(
"Name",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)));
return
(EntityType.Create("TestEntityType", "Model", DataSpace.CSpace, new[] { "Id" },
new[] { idProperty, nameProperty }, null));
}
public void CollectStoreModelErrors_returns_empty_error_list_for_model_without_errors()
{
var entityType =
EntityType.Create("foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0], null);
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(entityType);
var schemaErrors = ModelGenerator.CollectStoreModelErrors(model);
Assert.NotNull(schemaErrors);
Assert.Empty(schemaErrors);
}
public void Convert_can_convert_entitysets_without_defining_queries_to_entitysets_with_defining_queries()
{
var property1 =
EdmProperty.CreatePrimitive(
"Id",
ProviderManifest.GetStoreTypes().Single(t => t.PrimitiveTypeKind == PrimitiveTypeKind.Int32));
property1.Nullable = false;
var entityType1 =
EntityType.Create("EntityType1", "MyModel", DataSpace.SSpace, new[] { "Id" }, new[] { property1 }, null);
var property2 =
EdmProperty.CreatePrimitive(
"Id",
ProviderManifest.GetStoreTypes().Single(t => t.PrimitiveTypeKind == PrimitiveTypeKind.Int32));
property2.Nullable = false;
var entityType2 =
EntityType.Create("EntityType2", "MyModel", DataSpace.SSpace, new[] { "Id" }, new[] { property2 }, null);
var entitySets =
new List <EntitySet>
{
EntitySet.Create("EntityType1Set", "dbo", "EntityTypes1", null, entityType1, null),
EntitySet.Create("EntityType2Set", "dbo", "EntityTypes2", null, entityType2, null)
};
var mockResolver = new Mock <IDbDependencyResolver>();
mockResolver.Setup(
r => r.GetService(
It.Is <Type>(t => t == typeof(DbProviderServices)),
It.IsAny <string>())).Returns(SqlProviderServices.Instance);
var convertedEntitySets =
EntitySetDefiningQueryConverter.Convert(
entitySets,
EntityFrameworkVersion.Version3,
"System.Data.SqlClient",
"2008",
mockResolver.Object).ToList();
Assert.NotNull(convertedEntitySets);
Assert.Equal(entitySets.Select(e => e.Name), convertedEntitySets.Select(e => e.Name));
Assert.True(convertedEntitySets.All(e => e.DefiningQuery != null));
}
public void HasConventionalKeyName_ignores_case()
{
var property1 = EdmProperty.CreatePrimitive(
"ID",
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
Assert.True(property1.HasConventionalKeyName());
var property2 = EdmProperty.CreatePrimitive(
"PERSONID",
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32));
EntityType.Create("Person", "MyModel", DataSpace.CSpace, null, new[] { property2 }, null);
Assert.True(property2.HasConventionalKeyName());
}
public void Mapping_context_created_with_CreateMappingContext_will_not_pluralize_if_pluralization_disabled()
{
var entityType = EntityType.Create("entities", "ns", DataSpace.SSpace, new string[0], new EdmMember[0], null);
var entitySet = EntitySet.Create("entitySet", "dbo", "t", null, entityType, null);
var container = EntityContainer.Create("container", DataSpace.SSpace, new[] { entitySet }, null, null);
var storeModel = EdmModel.CreateStoreModel(container, null, null);
var mappingContext =
new ModelGenerator(new ModelBuilderSettings {
UsePluralizationService = false
}, "storeNamespace")
.CreateMappingContext(storeModel);
Assert.Equal("entities", mappingContext[entityType].Name);
Assert.Equal("entitySet", mappingContext[entitySet].Name);
}
public void UpdateStorageModel_add_errors_if_validation_fails()
{
var edmx = XDocument.Parse(EdmxTemplate);
var storeModel = new EdmModel(DataSpace.SSpace);
var providerInfo = new DbProviderInfo("ProviderInvariantName", "20081");
storeModel.AddItem(
EntityType.Create("entities", "ns", DataSpace.SSpace, new string[0], new EdmMember[0], null));
var errors = new List <EdmSchemaError>();
new EdmxHelper(edmx)
.UpdateStorageModels(storeModel, "myNamespace", providerInfo, errors);
Assert.NotEmpty(errors);
}
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 Ctor_sets_parameters()
{
var entityType = EntityType.Create("Entity", "ns", DataSpace.CSpace, new string[0], new EdmMember[0], null);
var entitySet = EntitySet.Create("EntitySet", "ns", null, null, entityType, null);
var commandDefinition = new CachingCommandDefinition(
new Mock <DbCommandDefinition>().Object,
new CommandTreeFacts(
new List <EntitySetBase> {
entitySet
}.AsReadOnly(), true, true),
new Mock <CacheTransactionHandler>(Mock.Of <ICache>()).Object,
Mock.Of <CachingPolicy>());
Assert.Equal(new[] { entitySet }, commandDefinition.AffectedEntitySets);
Assert.True(commandDefinition.IsQuery);
Assert.False(commandDefinition.IsCacheable);
}
public void GenerateModel_combines_store_model_and_mapping_errors()
{
var storeModelError = new EdmSchemaError("storeError", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List <EdmSchemaError> {
storeModelError
});
var entityType =
EntityType.Create(
"foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0],
new[] { errorMetadataProperty });
var storeModel = new EdmModel(DataSpace.SSpace);
storeModel.AddItem(entityType);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(
storeModel.Containers.Single(),
EntityContainer.Create("C", DataSpace.CSpace, null, null, null));
mappingContext.Errors.Add(new EdmSchemaError("mappingError", 911, EdmSchemaErrorSeverity.Warning));
var mockModelGenerator = new Mock <ModelGenerator>(new ModelBuilderSettings(), "storeNamespace");
mockModelGenerator
.Setup(g => g.CreateStoreModel())
.Returns(() => storeModel);
mockModelGenerator
.Setup(g => g.CreateMappingContext(It.IsAny <EdmModel>()))
.Returns(() => mappingContext);
var errors = new List <EdmSchemaError>();
mockModelGenerator.Object.GenerateModel(errors);
Assert.Equal(new[] { storeModelError, mappingContext.Errors.Single() }, errors);
}
// internal for testing
internal EntityType GenerateEntityType(
SimpleMappingContext mappingContext, EntityType storeEntityType, UniqueIdentifierService globallyUniqueTypeNames)
{
Debug.Assert(mappingContext != null, "mappingContext != null");
Debug.Assert(storeEntityType != null, "storeEntityType != null");
Debug.Assert(globallyUniqueTypeNames != null, "globallyUniqueTypeNames != null");
var conceptualEntityTypeName = CreateModelName(
(_pluralizationService != null) ? _pluralizationService.Singularize(storeEntityType.Name) : storeEntityType.Name,
globallyUniqueTypeNames);
var uniquePropertyNameService = new UniqueIdentifierService();
uniquePropertyNameService.AdjustIdentifier(conceptualEntityTypeName);
var edmMembers = new List <EdmMember>();
var keyMemberNames = new List <string>();
foreach (var storeProperty in storeEntityType.Properties)
{
// cannot skip this even if the store property is foreign key and generating foreign keys is disabled
// since it creates property mappings the will be used when mapping association types.
var conceptualProperty = GenerateScalarProperty(mappingContext, storeProperty, uniquePropertyNameService);
if (_generateForeignKeyProperties ||
!mappingContext.StoreForeignKeyProperties.Contains(storeProperty) ||
storeEntityType.KeyMembers.Contains(storeProperty))
{
edmMembers.Add(conceptualProperty);
if (storeEntityType.KeyMembers.Contains(storeProperty))
{
keyMemberNames.Add(conceptualProperty.Name);
}
}
}
var conceptualEntity = EntityType.Create(
conceptualEntityTypeName, _namespaceName, DataSpace.CSpace, keyMemberNames, edmMembers, null);
mappingContext.AddMapping(storeEntityType, conceptualEntity);
return(conceptualEntity);
}
public void ProcessModel_validates_conceptual_model()
{
var conceptualModel = EdmModel.CreateConceptualModel();
conceptualModel.AddItem(EntityType.Create("E", "ns", DataSpace.CSpace, new string[0], new EdmMember[0], null));
var model = CreateDbModel(conceptualModel, null);
var errors = new List <EdmSchemaError>();
new CodeFirstModelBuilderEngineInvoker()
.InvokeProcessModel(model, null, null, null, errors);
Assert.Equal(1, errors.Count);
Assert.Contains(
string.Format(Strings.EdmModel_Validator_Semantic_KeyMissingOnEntityType("E")),
errors.Single().Message);
}
public static ReadOnlyCollection <EntitySetBase> CreateEntitySetsEx(string[] setNames, string[] tableSchemas, string[] tableNames)
{
if (setNames == null)
{
throw new ArgumentNullException(nameof(setNames));
}
if (tableSchemas == null)
{
throw new ArgumentNullException(nameof(tableSchemas));
}
if (tableNames == null)
{
throw new ArgumentNullException(nameof(tableNames));
}
if (tableSchemas.Length != tableNames.Length)
{
throw new ArgumentException(
"The number of table schemas must be the same as the number of set names.", nameof(tableSchemas));
}
if (setNames.Length != tableNames.Length)
{
throw new ArgumentException(
"The number of table names must be the same as the number of set names.", nameof(tableNames));
}
var entitySets = new List <EntitySetBase>();
for (var i = 0; i < setNames.Length; i++)
{
var setName = setNames[i];
var entityType =
EntityType.Create(setName + "EntityType", "ns", DataSpace.CSpace,
new string[0], new EdmMember[0], null);
entitySets.Add(EntitySet.Create(setName, tableSchemas[i], tableNames[i], null, entityType, null));
}
return(entitySets.AsReadOnly());
}
public void IsKey_returns_false_when_not_key()
{
var property = EdmProperty.CreatePrimitive(
"Name",
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
EntityType.Create(
"Person",
"MyModel",
DataSpace.CSpace,
new[] { "Id" },
new[]
{
EdmProperty.CreatePrimitive("Id", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)),
property
},
null);
Assert.False(property.IsKey());
}
public void Affected_entity_sets_discovered_for_modification_commands()
{
var entityType = EntityType.Create("e", "ns", DataSpace.CSpace, new string[0], new EdmMember[0], null);
var entitySet = EntitySet.Create("es", "ns", null, null, entityType, null);
EntityContainer.Create("ec", DataSpace.CSpace, new[] { entitySet }, null, null);
var commandTreeFacts =
new CommandTreeFacts(
new DbInsertCommandTree(
new MetadataWorkspace(),
DataSpace.CSpace,
entitySet.Scan().Bind(),
new List <DbModificationClause>().AsReadOnly(),
TypeUsage.CreateDefaultTypeUsage(entityType).Null()));
Assert.Equal(
new[] { "es" },
commandTreeFacts.AffectedEntitySets.Select(s => s.Name));
}
public void ProcessModel_validates_store_model()
{
var storeModel = EdmModel.CreateStoreModel(
new DbProviderInfo("System.Data.SqlClient", "2012"),
SqlProviderServices.Instance.GetProviderManifest("2012"));
storeModel.AddItem(EntityType.Create("E", "ns", DataSpace.SSpace, new string[0], new EdmMember[0], null));
var model = CreateDbModel(null, storeModel);
var errors = new List <EdmSchemaError>();
new CodeFirstModelBuilderEngineInvoker()
.InvokeProcessModel(model, null, null, null, errors);
Assert.Equal(1, errors.Count);
Assert.Contains(
string.Format(Strings.EdmModel_Validator_Semantic_KeyMissingOnEntityType("E")),
errors.Single().Message);
}
public void Can_set_get_association_set_end_details()
{
var entity = EntityType.Create("E", "ns", DataSpace.CSpace, new string[0], new EdmMember[0], null);
var entitySet = EntitySet.Create("es1", null, null, null, entity, null);
var endMember = AssociationEndMember.Create(
"aem1", entity.GetReferenceType(), RelationshipMultiplicity.One, OperationAction.None, null);
var associationType = AssociationType.Create("at1", "ns", false, DataSpace.CSpace, endMember, null, null, null);
var assocationSet = AssociationSet.Create("as1", associationType, entitySet, null, null);
var associationSetEnd = assocationSet.AssociationSetEnds[0];
var associationSetEndDetails =
new AssociationSetEndDetails(
associationSetEnd,
(RelationshipMultiplicity)(-42),
(OperationAction)(-100));
Assert.Same(associationSetEnd, associationSetEndDetails.AssociationSetEnd);
Assert.Equal(-42, (int)associationSetEndDetails.Multiplicity);
Assert.Equal(-100, (int)associationSetEndDetails.DeleteBehavior);
}
public void Validation_error_not_reported_for_types_marked_as_invalid()
{
var invalidAttribute =
MetadataProperty.Create(
"EdmSchemaInvalid",
TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
true);
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(
EntityType.Create("E", "N", DataSpace.SSpace, new string[0], new EdmMember[0], new[] { invalidAttribute }));
using (var writer = XmlWriter.Create(new StringBuilder()))
{
var ssdlSerializer = new SsdlSerializer();
ssdlSerializer.OnError += (_, e) => { throw new Exception("Should not be invoked."); };
Assert.True(ssdlSerializer.Serialize(model, "N", "invName", "42", writer));
}
}