public void Create_creates_valid_EntityConnection_and_returns_EF_version() { var mockProviderServices = SetupMockProviderServices(); mockProviderServices .Protected() .Setup <DbProviderManifest>("GetDbProviderManifest", ItExpr.IsAny <string>()) .Returns(SqlProviderServices.Instance.GetProviderManifest("2008")); var mockResolver = SetupMockResolver(mockProviderServices); foreach (var targetEFVersion in EntityFrameworkVersion.GetAllVersions()) { Version actualEFVersion; var entityConnection = new StoreSchemaConnectionFactory().Create( mockResolver.Object, "System.Data.SqlClient", "Server=test", targetEFVersion, out actualEFVersion); Assert.NotNull(entityConnection); var expectedVersion = targetEFVersion == EntityFrameworkVersion.Version2 ? EntityFrameworkVersion.Version1 : targetEFVersion; Assert.Equal(expectedVersion, actualEFVersion); } }
public void CsdlVersion_was_added_if_EntityFramework_version_was_added() { // +1 to account for CSDL version 1.1 Assert.Equal( EntityFrameworkVersion.GetAllVersions().Count() + 1, CsdlVersion.GetAllVersions().Count()); }
public void GetInitialModelContents_returns_contents() { foreach (var targetSchemaVersion in EntityFrameworkVersion.GetAllVersions()) { Assert.Equal( EdmUtils.CreateEdmxString(targetSchemaVersion, string.Empty, string.Empty, string.Empty), new InitialModelContentsFactory().GetInitialModelContents(targetSchemaVersion)); } }
public void FunctionImportColumnInformation_always_enabled() { foreach (var targetSchemaVersion in EntityFrameworkVersion.GetAllVersions()) { Assert.Equal( FeatureState.VisibleAndEnabled, IsFeatureEnabledForArtifact( targetSchemaVersion, EdmFeatureManager.GetFunctionImportColumnInformationFeatureState)); } }
internal static HashSet <string> InitializeExistingNamespaces(Project project) { var existingNamespaces = new HashSet <string>(); if (project != null) { // find the namespace used in the CSDL section of each existing edmx file in the project var vsHierarchy = VsUtils.GetVsHierarchy(project, Services.ServiceProvider); var fileFinder = new VSFileFinder(EntityDesignArtifact.ExtensionEdmx); fileFinder.FindInProject(vsHierarchy); foreach (var fileInfo in fileFinder.MatchingFiles) { try { var xmlDocument = EdmUtils.SafeLoadXmlFromPath(fileInfo.Path); foreach (var schemaVersion in EntityFrameworkVersion.GetAllVersions()) { var nsMgr = SchemaManager.GetEdmxNamespaceManager(xmlDocument.NameTable, schemaVersion); foreach ( XmlElement e in xmlDocument.SelectNodes("/edmx:Edmx/edmx:Runtime/edmx:ConceptualModels/csdl:Schema", nsMgr)) { var namespaceValue = e.GetAttribute("Namespace"); if (!string.IsNullOrEmpty(namespaceValue)) { existingNamespaces.Add(namespaceValue); } } } } // swallow various exceptions that come from reading the file or parsing xml // We just skip this document in the event of an exception. catch (IOException) { } catch (UnauthorizedAccessException) { } catch (NotSupportedException) { } catch (SecurityException) { } catch (XmlException) { } } } return(existingNamespaces); }
public void CopyToSSDL_false_causes_CopyExtendedPropertiesToSsdlElement_to_not_copy_property() { foreach (var version in EntityFrameworkVersion.GetAllVersions()) { var csdlEntityTypeWithVersionedEdmxNamespaceCopyToSSDL = CreateEntityTypeWithExtendedProperty( SchemaManager.GetEDMXNamespaceName(EntityFrameworkVersion.Version1), "false"); var ssdlEntityTypeElement = new XElement( (XNamespace)(SchemaManager.GetSSDLNamespaceName(EntityFrameworkVersion.Version1)) + "EntityType", new XAttribute("Name", "TestEntityType")); OutputGeneratorHelpers.CopyExtendedPropertiesToSsdlElement( csdlEntityTypeWithVersionedEdmxNamespaceCopyToSSDL, ssdlEntityTypeElement); Assert.Empty(ssdlEntityTypeElement.Elements()); } }
public void GetAllPrimitiveTypes_returns_all_primitive_types_for_version() { foreach (var schemaVersion in EntityFrameworkVersion.GetAllVersions()) { // remove geo spatial types for schema versions V1 and V2 var expectedTypes = PrimitiveType .GetEdmPrimitiveTypes() .Where(t => schemaVersion == EntityFrameworkVersion.Version3 || !IsGeoSpatialType(t)) .Select(t => t.Name); Assert.Equal(expectedTypes, ModelHelper.AllPrimitiveTypes(schemaVersion)); } }
public void LoadFunctionReturnTableDetails_not_invoked_for_pre_V3_target_schema() { var mockEntityConnection = new Mock <EntityConnection>(); foreach (var version in EntityFrameworkVersion.GetAllVersions()) { var mockLoader = new Mock <EntityStoreSchemaGeneratorDatabaseSchemaLoader>( mockEntityConnection.Object, version) { CallBase = true }; mockLoader.Setup(l => l.LoadTableDetails(It.IsAny <IEnumerable <EntityStoreSchemaFilterEntry> >())) .Returns(Enumerable.Empty <TableDetailsRow>()); mockLoader.Setup(l => l.LoadViewDetails(It.IsAny <IEnumerable <EntityStoreSchemaFilterEntry> >())) .Returns(Enumerable.Empty <TableDetailsRow>()); mockLoader.Setup(l => l.LoadRelationships(It.IsAny <IEnumerable <EntityStoreSchemaFilterEntry> >())) .Returns(Enumerable.Empty <RelationshipDetailsRow>()); mockLoader.Setup(l => l.LoadFunctionDetails(It.IsAny <IEnumerable <EntityStoreSchemaFilterEntry> >())) .Returns(Enumerable.Empty <FunctionDetailsRowView>()); mockLoader.Setup( l => l.LoadFunctionReturnTableDetails(It.IsAny <IEnumerable <EntityStoreSchemaFilterEntry> >())) .Returns(Enumerable.Empty <TableDetailsRow>()); mockLoader.Object.LoadStoreSchemaDetails(new List <EntityStoreSchemaFilterEntry>()); mockLoader.Verify( l => l.LoadTableDetails(It.IsAny <IEnumerable <EntityStoreSchemaFilterEntry> >()), Times.Once()); mockLoader.Verify( l => l.LoadViewDetails(It.IsAny <IList <EntityStoreSchemaFilterEntry> >()), Times.Once()); mockLoader.Verify( l => l.LoadRelationships(It.IsAny <IList <EntityStoreSchemaFilterEntry> >()), Times.Once()); mockLoader.Verify( l => l.LoadFunctionDetails(It.IsAny <IList <EntityStoreSchemaFilterEntry> >()), Times.Once()); mockLoader.Verify( l => l.LoadFunctionReturnTableDetails(It.IsAny <IEnumerable <EntityStoreSchemaFilterEntry> >()), version == EntityFrameworkVersion.Version3 ? Times.Once() : Times.Never()); } }
public void CopyToSSDL_true_causes_CopyExtendedPropertiesToSsdlElement_to_copy_property() { foreach (var version in EntityFrameworkVersion.GetAllVersions()) { var csdlEntityTypeWithVersionedEdmxNamespaceCopyToSSDL = CreateEntityTypeWithExtendedProperty( SchemaManager.GetEDMXNamespaceName(version), "true"); var ssdlEntityTypeElement = new XElement( (XNamespace)(SchemaManager.GetSSDLNamespaceName(version)) + "EntityType", new XAttribute("Name", "TestEntityType")); OutputGeneratorHelpers.CopyExtendedPropertiesToSsdlElement( csdlEntityTypeWithVersionedEdmxNamespaceCopyToSSDL, ssdlEntityTypeElement); Assert.Equal( "<MyProp p1:MyAttribute=\"MyValue\" xmlns:p1=\"http://myExtendedProperties\" xmlns=\"http://myExtendedProperties\" />", ssdlEntityTypeElement.Elements().First().ToString()); } }
/// <summary> /// Creates an EntityConnection loaded with the providers metadata for the latest available store schema. /// Note that the targetEntityFrameworkVersion parameter uses internal EntityFramework version numbers as /// described in the <see cref="EntityFrameworkVersion" /> class. /// </summary> /// <param name="resolver">Resolver used to resolve provider services.</param> /// <param name="providerInvariantName">The provider invariant name.</param> /// <param name="connectionString">The connection for the providers connection.</param> /// <param name="maxAllowedSchemaVersion">The maximum allowed Entity Framework schema version that is being targeted.</param> /// <param name="storeSchemaModelVersion"> /// The version of the store schema model supported by the provider. Can be either v1 or v3 (store schema model in v2 did not change /// from v1, in v3 TVFs are supported and the provider needs to know how to handle Esql queries that ask for TVFs). /// Note that schema view artifacts themselves are v1 since there is nothing that is needed to ask for v3 concepts that /// cannot be expressed in v1 terms. /// **This value MUST NOT be used as the version of the model that will be created for the user (which can be /// any version regardless of this value), nor as the version of schema view artifacts (which is always v1) /// but rather it is a version of concepts we are asking the provider to return details for (to put it simply if this is v3 /// we will ask the provider about TVFs, otherwise this is v1 and we don't ask about TVFs)** /// </param> /// <returns>An EntityConnection that can query the ConceptualSchemaDefinition for the provider.</returns> /// <remarks>virtual for testing</remarks> public virtual EntityConnection Create( IDbDependencyResolver resolver, string providerInvariantName, string connectionString, Version maxAllowedSchemaVersion, out Version storeSchemaModelVersion) { Debug.Assert(resolver != null, "resolver != null"); Debug.Assert(!string.IsNullOrWhiteSpace(providerInvariantName), "providerInvarianName cannot be null or empty"); Debug.Assert(!string.IsNullOrWhiteSpace(connectionString), "connectionString cannot be null or empty"); Debug.Assert(EntityFrameworkVersion.IsValidVersion(maxAllowedSchemaVersion), "invalid maxAllowedSchemaVersion"); // We are going to try loading all versions of the store schema model starting from the newest. // The first version of the model that was shipped with EntityFrameworkVersions.Version1 and EntityFrameworkVersions.Version2 is the last one // we try, if it fails to load let the exception to propagate up to the caller. var versions = EntityFrameworkVersion .GetAllVersions() .Where(v => v > EntityFrameworkVersion.Version2 && v <= maxAllowedSchemaVersion) .OrderByDescending(v => v); foreach (var version in versions) { try { storeSchemaModelVersion = version; return (Create( resolver, providerInvariantName, connectionString, storeSchemaModelVersion)); } catch (Exception e) { // Ignore the exception with the current version and try the next one. if (!IsCatchableExceptionType(e)) { throw; } } } storeSchemaModelVersion = EntityFrameworkVersion.Version1; return(Create(resolver, providerInvariantName, connectionString, storeSchemaModelVersion)); }
protected internal override bool ExpectEFObjectForXObject(XObject xobject) { var xe = xobject as XElement; if (xe != null) { foreach (var n in SchemaManager.GetEDMXNamespaceNames()) { // see if this element is the "Edmx" element. We don't exepct a EFObject for this element if (xe.Name.NamespaceName.Equals(n, StringComparison.OrdinalIgnoreCase)) { if (xe.Name.LocalName.Equals("Edmx", StringComparison.OrdinalIgnoreCase)) { return(false); } } } // now look for items that are in the EF set of namespaces (ie, csdl/ssdl/msl/edmx namespaces. // If something isn't in this namespace, we return false below (since it won't have a model element) // if something is in this namespace, we'll base this to the base class, which will return true. // // the reason this is here is there will be asserts after undo/redo operations if we can't find // a model element for the xnode that is part of the undo/redo. Returning false from this method // tells us not to expect the model element. // foreach (var v in EntityFrameworkVersion.GetAllVersions()) { foreach (var s in SchemaManager.GetAllNamespacesForVersion(v)) { if (xe.Name.NamespaceName.Equals(s, StringComparison.OrdinalIgnoreCase)) { // we only expect EFObjects for items in the Entity Framework namespaces return(base.ExpectEFObjectForXObject(xobject)); } } } } return(false); }
public void RetargetWithMetadataConverter_does_not_modify_xml_if_converter_returns_null() { foreach (var schemaVersion in EntityFrameworkVersion.GetAllVersions()) { var model = new XDocument(new XElement("root")); model.Changed += (sender, args) => { throw new InvalidOperationException("Unexpected changes to model."); }; var mockConverter = new Mock <MetadataConverterDriver>(); mockConverter .Setup(c => c.Convert(It.IsAny <XmlDocument>(), It.IsAny <Version>())) .Returns( (XmlDocument doc, Version version) => { Assert.Same(schemaVersion, version); return(null); }); RetargetXmlNamespaceCommand.RetargetWithMetadataConverter(model, schemaVersion, mockConverter.Object); } }
private bool VerifyUserEdit(XName xn) { if (_namespaces == null) { _namespaces = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach (var v in EntityFrameworkVersion.GetAllVersions()) { foreach (var s in SchemaManager.GetAllNamespacesForVersion(v)) { _namespaces.Add(s); } } } if (_namespaces.Contains(xn.NamespaceName)) { return(false); } else { return(true); } }
public void ToLegacyMetadataWorkspace_creates_equivalent_legacy_MetadataWorkspace_for_all_versions() { const string ssdlTemplate = @"<Schema Namespace=""NorthwindEF5Model.Store"" Provider=""System.Data.SqlClient"" ProviderManifestToken=""2008"" Alias=""Self"" xmlns=""{0}"" xmlns:store=""http://schemas.microsoft.com/ado/2007/12/edm/EntityStoreSchemaGenerator"">" + @" <EntityType Name=""Customers"">" + @" <Key>" + @" <PropertyRef Name=""CustomerID"" />" + @" </Key>" + @" <Property Name=""CustomerID"" Type=""nchar"" MaxLength=""5"" Nullable=""false"" />" + @" <Property Name=""CompanyName"" Type=""nvarchar"" MaxLength=""40"" Nullable=""false"" />" + @" </EntityType>" + @" <EntityContainer Name=""Container"" />" + @"</Schema>"; const string csdlTemplate = @"<Schema xmlns=""{0}"" Namespace=""dummy"">" + @" <EntityContainer Name=""DummyContainer""/>" + @"</Schema>"; const string mslTemplate = @"<Mapping Space=""C-S"" xmlns=""{0}"">" + @" <EntityContainerMapping StorageEntityContainer=""Container"" CdmEntityContainer=""DummyContainer"" />" + @"</Mapping>"; foreach (var version in EntityFrameworkVersion.GetAllVersions()) { var storeItemCollection = Utils.CreateStoreItemCollection( string.Format( ssdlTemplate, SchemaManager.GetSSDLNamespaceName(version))); var edmItemCollection = new EdmItemCollection( new[] { XmlReader.Create( new StringReader( string.Format( csdlTemplate, SchemaManager.GetCSDLNamespaceName(version)))) }); var mappingItemCollection = new StorageMappingItemCollection( edmItemCollection, storeItemCollection, new[] { XmlReader.Create( new StringReader( string.Format( mslTemplate, SchemaManager.GetMSLNamespaceName(version)))) }); var workspace = new MetadataWorkspace( () => edmItemCollection, () => storeItemCollection, () => mappingItemCollection); var legacyWorkspace = workspace.ToLegacyMetadataWorkspace(); Assert.NotNull(legacyWorkspace); var legacyStoreItemCollection = legacyWorkspace.GetItemCollection(LegacyMetadata.DataSpace.SSpace); Assert.Equal( storeItemCollection.GetItems <GlobalItem>().Count, legacyStoreItemCollection.GetItems <LegacyMetadata.GlobalItem>().Count); Assert.NotNull( legacyStoreItemCollection.GetItem <LegacyMetadata.EntityType>("NorthwindEF5Model.Store.Customers")); var legacyEdmItemCollection = (LegacyMetadata.EdmItemCollection)legacyWorkspace.GetItemCollection(LegacyMetadata.DataSpace.CSpace); Assert.NotNull(legacyEdmItemCollection); Assert.Equal(version, EntityFrameworkVersion.DoubleToVersion(legacyEdmItemCollection.EdmVersion)); Assert.NotNull(legacyWorkspace.GetItemCollection(LegacyMetadata.DataSpace.CSSpace)); } }