public void UpdateConfigForSqlDbFileUpgrade_updates_and_saves_config() { var xmlDoc = new XmlDocument(); xmlDoc.LoadXml( "<configuration>" + " <connectionStrings>" + " <add connectionString=\"Data source=.\\SQLExpress;AttachDbFilename=C:\\MyFolder\\MyDataFile.mdf;Database=dbname;Trusted_Connection=Yes;\" />" + " </connectionStrings>" + "</configuration>"); var mockConfigFileUtils = new Mock <ConfigFileUtils>(Mock.Of <Project>(), Mock.Of <IServiceProvider>(), null, Mock.Of <IVsUtils>(), null); mockConfigFileUtils .Setup(u => u.LoadConfig()) .Returns(xmlDoc); EdmUtils.UpdateConfigForSqlDbFileUpgrade( mockConfigFileUtils.Object, Mock.Of <Project>(), Mock.Of <IVsUpgradeLogger>()); mockConfigFileUtils.Verify(u => u.SaveConfig(It.IsAny <XmlDocument>()), Times.Once()); }
public void SafeLoadXmlFromString_can_load_xml_without_entities() { var xmlDoc = EdmUtils.SafeLoadXmlFromString("<entity-framework />"); Assert.NotNull(xmlDoc); Assert.Equal("entity-framework", xmlDoc.DocumentElement.Name); }
public void GetEntityFrameworkVersion_returns_version_when_ef_installed() { var helper = new MockDTE( ".NETFramework,Version=v4.5", references: new[] { MockDTE.CreateReference("EntityFramework", "6.0.0.0") }); var schemaVersion = EdmUtils.GetEntityFrameworkVersion(helper.Project, helper.ServiceProvider); Assert.Equal(EntityFrameworkVersion.Version3, schemaVersion); }
public void IsDataServicesEdmx_returns_false_for_no_data_services_edmx() { Assert.False( EdmUtils.IsDataServicesEdmx(XDocument.Parse("<Edmx xmlns=\"abc\"><DataServices /></Edmx>"))); Assert.False( EdmUtils.IsDataServicesEdmx( XDocument.Parse("<Edmx xmlns=\"http://schemas.microsoft.com/ado/2009/11/edmx\" />"))); }
public void GetEntityFrameworkVersion_returns_null_when_misc_files() { var project = MockDTE.CreateMiscFilesProject(); var serviceProvider = new Mock <IServiceProvider>(); var schemaVersion = EdmUtils.GetEntityFrameworkVersion(project, serviceProvider.Object); Assert.Null(schemaVersion); }
public void IsValidModelNamespace_returns_false_for_invalid_namespaces() { // the version does not matter since the definition // of allowed strings for namespaces have not changed since v1 Assert.False(EdmUtils.IsValidModelNamespace(null)); Assert.False(EdmUtils.IsValidModelNamespace(string.Empty)); Assert.False(EdmUtils.IsValidModelNamespace("\u0001\u0002")); Assert.False(EdmUtils.IsValidModelNamespace("<>")); }
public void ConstructValidModelNamespace_returns_sanitized_proposed_namespace_if_sanitized_proposed_namespace_valid() { Assert.Equal( "proposed", EdmUtils.ConstructValidModelNamespace("<proposed>", "default")); Assert.Equal( "proposed", EdmUtils.ConstructValidModelNamespace("<123_proposed>", "default")); }
public void ConstructValidModelNamespace_returns_default_namespace_if_proposed_namespace_null_or_empty_string() { Assert.Equal( "default", EdmUtils.ConstructValidModelNamespace(null, "default")); Assert.Equal( "default", EdmUtils.ConstructValidModelNamespace(string.Empty, "default")); }
public void SafeLoadXmlFromString_throws_if_xml_contains_entities() { var message = Assert.Throws <XmlException>( () => EdmUtils.SafeLoadXmlFromString( "<!ENTITY network \"network\">\n<entity-framework>&network;</entity-framework>")).Message; Assert.Contains("DTD", message); Assert.Contains("DtdProcessing", message); Assert.Contains("Parse", message); }
public void SafeLoadXmlFromPath_can_load_xml_without_entities() { var filePath = Path.GetTempFileName(); File.WriteAllText(filePath, "<entity-framework />"); var xmlDoc = EdmUtils.SafeLoadXmlFromPath(filePath); Assert.NotNull(xmlDoc); Assert.Equal("entity-framework", xmlDoc.DocumentElement.Name); }
public void UpdateConfigForSqlDbFileUpgrade_does_not_save_config_if_content_not_loaded() { var mockConfigFileUtils = new Mock <ConfigFileUtils>( Mock.Of <Project>(), Mock.Of <IServiceProvider>(), null, Mock.Of <IVsUtils>(), null); EdmUtils.UpdateConfigForSqlDbFileUpgrade( mockConfigFileUtils.Object, Mock.Of <Project>(), Mock.Of <IVsUpgradeLogger>()); mockConfigFileUtils.Verify(u => u.SaveConfig(It.IsAny <XmlDocument>()), Times.Never()); }
public void IsDataServicesEdmx_returns_true_for_known_data_services_edmx() { const string edmxTemplate = "<Edmx xmlns=\"{0}\"><DataServices /></Edmx>"; foreach (var edmxNs in SchemaManager.GetEDMXNamespaceNames()) { Assert.True( EdmUtils.IsDataServicesEdmx( XDocument.Parse( string.Format(edmxTemplate, edmxNs)))); } }
public void SafeLoadXmlFromPath_throws_if_xml_contains_entities() { var filePath = Path.GetTempFileName(); File.WriteAllText(filePath, "<!ENTITY network \"network\">\n<entity-framework>&network;</entity-framework>"); var message = Assert.Throws <XmlException>( () => EdmUtils.SafeLoadXmlFromPath(filePath)).Message; Assert.Contains("DTD", message); Assert.Contains("DtdProcessing", message); Assert.Contains("Parse", message); }
// <summary> // Project retargeting event handler. // 1. Check the project type, return immediately if project is misc project or a project that does not support EF. // 2. Find all the EDMX files in the project. Skip Data Services edmx files and linked files. // 3. Sync all the namespaces based on the new target framework // </summary> public void RetargetFilesInProject() { var project = VSHelpers.GetProject(_hierarchy); if (project == null || !VsUtils.EntityFrameworkSupportedInProject(project, _serviceProvider, allowMiscProject: false)) { return; } var targetSchemaVersion = EdmUtils.GetEntityFrameworkVersion(project, _serviceProvider, useLatestIfNoEF: false); Debug.Assert(targetSchemaVersion != null, "schema version must not be null for projects that support EF"); var documentMap = new Dictionary <string, object>(); foreach (var vsFileInfo in GetEdmxFileInfos()) { try { var projectItem = VsUtils.GetProjectItem(_hierarchy, vsFileInfo.ItemId); // skip the process for astoria edmx file or a linked edmx file if (IsDataServicesEdmx(projectItem.get_FileNames(1)) || VsUtils.IsLinkProjectItem(projectItem)) { continue; } var doc = RetargetFile(vsFileInfo.Path, targetSchemaVersion); if (doc != null) { documentMap.Add(vsFileInfo.Path, doc); } } catch (Exception ex) { // TODO: When there is an exception; should we continue? VsUtils.LogStandardError( string.Format(CultureInfo.CurrentCulture, Resources.ErrorSynchingEdmxNamespaces, vsFileInfo.Path, ex.Message), vsFileInfo.Path, 0, 0); throw; } } WriteModifiedFiles(project, documentMap); }
public void GetEntityFrameworkVersion_returns_latest_version_when_EF_dll_in_the_project_and_useLatestIfNoEf_true() { var netFxToSchemaVersionMapping = new[] { new KeyValuePair <string, Version>(".NETFramework,Version=v4.5", new Version(3, 0, 0, 0)), new KeyValuePair <string, Version>(".NETFramework,Version=v4.0", new Version(3, 0, 0, 0)), new KeyValuePair <string, Version>(".NETFramework,Version=v3.5", new Version(1, 0, 0, 0)) }; foreach (var mapping in netFxToSchemaVersionMapping) { var helper = new MockDTE(/* .NET Framework Moniker */ mapping.Key, references: new Reference[0]); var schemaVersion = EdmUtils.GetEntityFrameworkVersion(helper.Project, helper.ServiceProvider, useLatestIfNoEF: true); Assert.Equal(/*expected schema version */ mapping.Value, schemaVersion); } }
public void ConstructValidModelNamespace_returns_default_namespace_if_sanitized_proposed_namespace_invalid_or_empty_string() { Assert.Equal( "default", EdmUtils.ConstructValidModelNamespace("&", "default")); Assert.Equal( "default", EdmUtils.ConstructValidModelNamespace("&\u0001", "default")); Assert.Equal( "default", EdmUtils.ConstructValidModelNamespace("&123", "default")); Assert.Equal( "default", EdmUtils.ConstructValidModelNamespace("_a a", "default")); }
public void UpdateConfigForSqlDbFileUpgrade_logs_exceptions() { var mockConfigFileUtils = new Mock <ConfigFileUtils>( Mock.Of <Project>(), Mock.Of <IServiceProvider>(), null, Mock.Of <IVsUtils>(), null); mockConfigFileUtils .Setup(u => u.LoadConfig()) .Throws(new InvalidOperationException("Loading Failed")); var mockLogger = new Mock <IVsUpgradeLogger>(); EdmUtils.UpdateConfigForSqlDbFileUpgrade( mockConfigFileUtils.Object, Mock.Of <Project>(), mockLogger.Object); var expectedErrorMessage = string.Format(Resources.ErrorDuringSqlDatabaseFileUpgrade, null, "Loading Failed"); mockLogger .Verify(l => l.LogMessage(2, It.IsAny <string>(), It.IsAny <string>(), expectedErrorMessage), Times.Once()); }
public void CreateUpdateCodeGenStrategyCommand_returns_null_when_attempting_to_update_CodeGenStrategy_to_same_value() { var modelManager = new Mock <ModelManager>(null, null).Object; var modelProvider = new Mock <XmlModelProvider>().Object; var entityDesignArtifactMock = new Mock <EntityDesignArtifact>(modelManager, new Uri("urn:dummy"), modelProvider); using (var designerInfoRoot = new EFDesignerInfoRoot(entityDesignArtifactMock.Object, new XElement("_"))) { const string designerPropertyName = "CodeGenerationStrategy"; designerInfoRoot .AddDesignerInfo( "Options", SetupOptionsDesignerInfo(designerPropertyName, "None")); entityDesignArtifactMock .Setup(a => a.DesignerInfo) .Returns(designerInfoRoot); Assert.Null(EdmUtils.SetCodeGenStrategyToNoneCommand(entityDesignArtifactMock.Object)); } }
CreateUpdateCodeGenStrategyCommand_returns_UpdateDefaultableValueCommand_when_updating_CodeGenStrategy_value_from_empty_string() { var modelManager = new Mock <ModelManager>(null, null).Object; var modelProvider = new Mock <XmlModelProvider>().Object; var entityDesignArtifactMock = new Mock <EntityDesignArtifact>(modelManager, new Uri("urn:dummy"), modelProvider); using (var designerInfoRoot = new EFDesignerInfoRoot(entityDesignArtifactMock.Object, new XElement("_"))) { const string designerPropertyName = "CodeGenerationStrategy"; designerInfoRoot .AddDesignerInfo( "Options", SetupOptionsDesignerInfo(designerPropertyName, string.Empty)); entityDesignArtifactMock .Setup(a => a.DesignerInfo) .Returns(designerInfoRoot); Assert.IsType <UpdateDefaultableValueCommand <string> >( EdmUtils.SetCodeGenStrategyToNoneCommand(entityDesignArtifactMock.Object)); } }
public void IsDataServicesEdmx_returns_false_for_invalid_or_non_existing_path() { Assert.False(EdmUtils.IsDataServicesEdmx((string)null)); Assert.False(EdmUtils.IsDataServicesEdmx(string.Empty)); Assert.False(EdmUtils.IsDataServicesEdmx(Guid.NewGuid().ToString())); }
public void IsValidModelNamespace_returns_true_for_valid_namespaces() { // the version does not matter since the definition // of allowed strings for namespaces have not changed since v1 Assert.True(EdmUtils.IsValidModelNamespace("abc")); }
public void ConstructUniqueNamespaces_returns_proposed_namespace_if_existing_namespaces_null() { Assert.Equal("testNamespace", EdmUtils.ConstructUniqueNamespace("testNamespace", null)); }
public void ConstructUniqueNamespaces_returns_uniquified_namespace_() { Assert.Equal("Model1", EdmUtils.ConstructUniqueNamespace("Model", new HashSet <string> { "Model" })); }
// protected virtual to allow mocking protected virtual bool IsDataServicesEdmx(string filePath) { Debug.Assert(!string.IsNullOrWhiteSpace(filePath), "Invalid filePath"); return(EdmUtils.IsDataServicesEdmx(filePath)); }
public void IsDataServicesEdmx_returns_false_for_invalid_Xml_file() { Assert.False(EdmUtils.IsDataServicesEdmx(GetType().Assembly.Location)); }
internal static void SqlCeUpgradeService_OnUpgradeProject(IVsHierarchy hierarchy, IVsUpgradeLogger logger) { if (PackageManager.Package != null && PackageManager.Package.ModelManager != null) { // since this is about retargeting EDMX files on disk, no need to process other file extensions from any converters var fileFinder = new VSFileFinder(EntityDesignArtifact.ExtensionEdmx); fileFinder.FindInProject(hierarchy); var project = VSHelpers.GetProject(hierarchy); // skip the step if it is a miscellaneous project. if (project != null && !VsUtils.IsMiscellaneousProject(project)) { IDictionary <string, object> documentMap = new Dictionary <string, object>(); foreach (var vsFileInfo in fileFinder.MatchingFiles) { try { var projectItem = VsUtils.GetProjectItem(hierarchy, vsFileInfo.ItemId); // Dev 10 bug 648969: skip the process for astoria edmx file. if (EdmUtils.IsDataServicesEdmx(projectItem.get_FileNames(1))) { continue; } // Check whether project item is a linked item var isLinkItem = VsUtils.IsLinkProjectItem(projectItem); if (!isLinkItem) { var doc = MetadataConverterDriver.SqlCeInstance.Convert(SafeLoadXmlFromPath(vsFileInfo.Path)); if (doc != null) { documentMap.Add(vsFileInfo.Path, doc); } } } catch (Exception ex) { var errMsg = String.Format( CultureInfo.CurrentCulture, Resources.ErrorDuringSqlCeUpgrade, vsFileInfo.Path, ex.Message); logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, vsFileInfo.Path, errMsg); return; } } if (documentMap.Count > 0) { VsUtils.WriteCheckoutXmlFilesInProject(documentMap); } // now update the config file as needed var configFileUtils = new ConfigFileUtils(project, PackageManager.Package); try { var configXmlDoc = configFileUtils.LoadConfig(); if (configXmlDoc != null) // check config file exists { if (ConnectionManager.UpdateSqlCeProviderInConnectionStrings(configXmlDoc)) { configFileUtils.SaveConfig(configXmlDoc); } } } catch (Exception ex) { var errMsg = String.Format( CultureInfo.CurrentCulture, Resources.ErrorDuringSqlCeUpgrade, configFileUtils.GetConfigPath(), ex.Message); logger.LogMessage((uint)__VSUL_ERRORLEVEL.VSUL_ERROR, project.Name, configFileUtils.GetConfigPath(), errMsg); } } } }
// protected virtual to allow mocking protected virtual XmlDocument SafeLoadXmlFromPath(string filePath) { Debug.Assert(!string.IsNullOrWhiteSpace(filePath), "Invalid filePath"); return(EdmUtils.SafeLoadXmlFromPath(filePath, preserveWhitespace: true)); }