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)); } }