public void Publish() { string projectFile = Path.Combine(_rootDir, @"src\project.csproj"); ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile); projectRootElement.DefaultTargets = "Publish"; projectRootElement.AddProperty(GetCopyToPublishDirectoryItemsGraphPredictor.PublishDirPropertyName, @"bin\Publish"); const bool shouldCopy = true; ProjectRootElement dep1 = CreateDependencyProject("dep1", shouldCopy); ProjectRootElement dep2 = CreateDependencyProject("dep2", shouldCopy); ProjectRootElement dep3 = CreateDependencyProject("dep3", shouldCopy); // The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1. Note that this should *not* be transitive projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj"); dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj"); dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.Save(); dep1.Save(); dep2.Save(); dep3.Save(); var expectedInputFiles = new[] { new PredictedItem(@"dep1\dep1.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"dep1\dep1.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"dep1\dep1.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"dep1\dep1.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"dep2\dep2.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), }; var expectedOutputFiles = new[] { new PredictedItem(@"src\bin\Publish\dep1.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\Publish\dep1.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\Publish\dep1.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\Publish\dep1.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\Publish\dep2.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\Publish\dep2.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\Publish\dep2.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), new PredictedItem(@"src\bin\Publish\dep2.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)), }; new GetCopyToPublishDirectoryItemsGraphPredictor() .GetProjectPredictions(projectFile) .AssertPredictions( _rootDir, expectedInputFiles, null, expectedOutputFiles, null); }
public void Roslyn_Settings_ValidSetup() { // Arrange BuildLogger logger = new BuildLogger(); // Set the config directory so the targets know where to look for the analysis config file string confDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "config"); // Create a valid config file containing analyzer settings string[] expectedAssemblies = new string[] { "c:\\data\\config.analyzer1.dll", "c:\\config2.dll" }; string[] expectedAdditionalFiles = new string[] { "c:\\config.1.txt", "c:\\config.2.txt" }; AnalysisConfig config = new AnalysisConfig(); AnalyzerSettings analyzerSettings = new AnalyzerSettings(); analyzerSettings.Language = "cs"; analyzerSettings.RuleSetFilePath = "d:\\my.ruleset"; analyzerSettings.AnalyzerAssemblyPaths = expectedAssemblies.ToList(); analyzerSettings.AdditionalFilePaths = expectedAdditionalFiles.ToList(); config.AnalyzersSettings = new List <AnalyzerSettings>(); config.AnalyzersSettings.Add(analyzerSettings); string configFilePath = Path.Combine(confDir, FileConstants.ConfigFileName); config.Save(configFilePath); // Create the project WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeConfigPath = confDir; properties.ResolvedCodeAnalysisRuleset = "c:\\should.be.overridden.ruleset"; ProjectRootElement projectRoot = CreateValidProjectSetup(properties); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "should.be.removed.analyzer1.dll"); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\should.be.removed.analyzer2.dll"); projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "should.be.removed.additional1.txt"); projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "should.be.removed.additional2.txt"); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget); // Assert logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); logger.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.OverrideRoslynAnalysisTarget); // Check the error log and ruleset properties are set AssertErrorLogIsSetBySonarQubeTargets(result); AssertExpectedResolvedRuleset(result, "d:\\my.ruleset"); AssertExpectedItemValuesExists(result, TargetProperties.AdditionalFilesItemType, expectedAdditionalFiles); AssertExpectedItemValuesExists(result, TargetProperties.AnalyzerItemType, expectedAssemblies); BuildAssertions.AssertWarningsAreNotTreatedAsErrorsNorIgnored(result); }
public void E2E_FxCop_NoFilesToAnalyse() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.RunCodeAnalysis = "false"; preImportProperties.CodeAnalysisLogFile = fxCopLogFile; preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset"; preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder; CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs")); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); // Add some files to the project string itemPath = CreateTextFile(rootInputFolder, "content1.txt", "aaaa"); projectRoot.AddItem("Content", itemPath); itemPath = CreateTextFile(rootInputFolder, "code1.cs", "class myclassXXX{} // wrong item type"); projectRoot.AddItem("CompileXXX", itemPath); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertExpectedTargetOrdering( TargetConstants.CategoriseProjectTarget, TargetConstants.OverrideFxCopSettingsTarget, TargetConstants.FxCopTarget, TargetConstants.SetFxCopResultsTarget, // should set the FxCop results after the platform "run Fx Cop" target TargetConstants.DefaultBuildTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.WriteProjectDataTarget); logger.AssertTargetExecuted(TargetConstants.SetFxCopResultsTarget); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString()); }
private static ProjectInstance CreateTestProjectInstance(string fileName) { ProjectRootElement projectRootElement = ProjectRootElement.Create(fileName); #pragma warning disable SA1118 // Parameter should not span multiple lines. Justification: Used to help match formatting in real projects projectRootElement.AddItemDefinitionGroup() .AddItemDefinition(AdditionalIncludeDirectoriesPredictor.ClCompileItemName) .AddMetadata( AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata, @"..\ClCompileIncludes ;%(AdditionalIncludeDirectories)"); projectRootElement.AddItemDefinitionGroup() .AddItemDefinition(AdditionalIncludeDirectoriesPredictor.FxCompileItemName) .AddMetadata( AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata, @"..\FxCompileIncludes ;%(AdditionalIncludeDirectories)"); projectRootElement.AddItemDefinitionGroup() .AddItemDefinition(AdditionalIncludeDirectoriesPredictor.MidlItemName) .AddMetadata( AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata, @"..\MidlIncludes ;%(AdditionalIncludeDirectories)"); projectRootElement.AddItemDefinitionGroup() .AddItemDefinition(AdditionalIncludeDirectoriesPredictor.ResourceCompileItemName) .AddMetadata( AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata, @"..\ResourceCompileIncludes ;%(AdditionalIncludeDirectories)"); #pragma warning restore SA1118 // Parameter should not span multiple lines // No change to AdditionalIncludeDirectories projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.ClCompileItemName, "foo.cpp"); // Overrieds AdditionalIncludeDirectories projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.FxCompileItemName, "foo.fx") .AddMetadata( AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata, @"..\ReplacedFxCompileIncludes"); // Appends to AdditionalIncludeDirectories projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.MidlItemName, "foo.idl") .AddMetadata( AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata, @"..\AnotherMidlIncludes;%(AdditionalIncludeDirectories)"); // Has duplicates and spaces projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.ResourceCompileItemName, "foo.rc") .AddMetadata( AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata, @"%(AdditionalIncludeDirectories); ;;%(AdditionalIncludeDirectories);..\AnotherResourceCompileIncludes;%(AdditionalIncludeDirectories)"); return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement)); }
protected virtual void ProjectFiles_InsertedItem(object sender, CollectionChangedEventArgs e) { var file = (e.TargetObject as ProjectFileEntry); string hintPath = file.FilePath.GetRelativePath(file.ParentProject); var item = _msBuildProject.AddItem(GetItemType(hintPath), hintPath); AddFileEventHandlers(file); foreach (var dependency in file.Dependencies) { item.AddMetadata("DependentUpon", dependency); } }
public void SkipOtherProjectTypes() { string projectFile = Path.Combine(_rootDir, @"src\project.csproj"); ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile); projectRootElement.AddProperty(ServiceFabricPackageRootFilesGraphPredictor.ServicePackageRootFolderPropertyName, "PackageRoot"); projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.csproj"); projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.csproj"); projectRootElement.AddItem("ProjectReference", @"..\dep3\dep3.csproj"); projectRootElement.AddItem("ProjectReference", @"..\dep4\dep4.csproj"); // Content package file string dependency1File = Path.Combine(_rootDir, @"dep1\dep1.csproj"); ProjectRootElement dependency1RootElement = ProjectRootElement.Create(dependency1File); dependency1RootElement.AddItem(ContentItemsPredictor.ContentItemName, @"PackageRoot\Config\Settings.xml"); Directory.CreateDirectory(Path.Combine(_rootDir, @"dep1\PackageRoot")); // None package file string dependency2File = Path.Combine(_rootDir, @"dep2\dep2.csproj"); ProjectRootElement dependency2RootElement = ProjectRootElement.Create(dependency2File); dependency2RootElement.AddItem(NoneItemsPredictor.NoneItemName, @"PackageRoot\Config\Settings.xml"); Directory.CreateDirectory(Path.Combine(_rootDir, @"dep2\PackageRoot")); // Linked package file string dependency3File = Path.Combine(_rootDir, @"dep3\dep3.csproj"); ProjectRootElement dependency3RootElement = ProjectRootElement.Create(dependency3File); dependency3RootElement.AddItem(ContentItemsPredictor.ContentItemName, @"..\dep3_linked\PackageRoot\Config\Settings.xml") .AddMetadata("Link", @"PackageRoot\Config\Settings.xml"); Directory.CreateDirectory(Path.Combine(_rootDir, @"dep3\PackageRoot")); // Package file on disk string dependency4File = Path.Combine(_rootDir, @"dep4\dep4.csproj"); ProjectRootElement dependency4RootElement = ProjectRootElement.Create(dependency4File); Directory.CreateDirectory(Path.Combine(_rootDir, @"dep4\PackageRoot\Config")); File.WriteAllText(Path.Combine(_rootDir, @"dep4\PackageRoot\Config\Settings.xml"), "dummy"); projectRootElement.Save(); dependency1RootElement.Save(); dependency2RootElement.Save(); dependency3RootElement.Save(); dependency4RootElement.Save(); new ServiceFabricPackageRootFilesGraphPredictor() .GetProjectPredictions(projectFile) .AssertNoPredictions(); }
public void SkipOtherProjectTypes() { ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"project.csproj")); projectRootElement.AddItem(LinkItemsPredictor.LinkItemName, "foo.lib"); projectRootElement.AddItem(LinkItemsPredictor.LinkItemName, "bar.lib"); projectRootElement.AddItem(LinkItemsPredictor.LinkItemName, "baz.lib"); ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement); new AdditionalIncludeDirectoriesPredictor() .GetProjectPredictions(projectInstance) .AssertNoPredictions(); }
public void Roslyn_Settings_SettingsMissing_NoError() { // Arrange BuildLogger logger = new BuildLogger(); // Set the config directory so the targets know where to look for the analysis config file string confDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "config"); // Create a valid config file that does not contain analyzer settings AnalysisConfig config = new AnalysisConfig(); string configFilePath = Path.Combine(confDir, FileConstants.ConfigFileName); config.Save(configFilePath); // Create the project WellKnownProjectProperties properties = new WellKnownProjectProperties { SonarQubeConfigPath = confDir, ResolvedCodeAnalysisRuleset = "c:\\should.be.overridden.ruleset" }; ProjectRootElement projectRoot = CreateValidProjectSetup(properties); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "should.be.removed.analyzer1.dll"); const string additionalFileName = "should.not.be.removed.additional1.txt"; projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, additionalFileName); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget); string projectSpecificConfFilePath = result.ProjectStateAfterBuild.GetPropertyValue(TargetProperties.ProjectConfFilePath); string[] expectedRoslynAdditionalFiles = new string[] { projectSpecificConfFilePath, additionalFileName /* additional files are not removed any longer */ }; // Assert logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); logger.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.OverrideRoslynAnalysisTarget); // Check the error log and ruleset properties are set AssertErrorLogIsSetBySonarQubeTargets(result); AssertExpectedResolvedRuleset(result, string.Empty); BuildAssertions.AssertExpectedItemGroupCount(result, TargetProperties.AnalyzerItemType, 0); AssertExpectedItemValuesExists(result, TargetProperties.AdditionalFilesItemType, expectedRoslynAdditionalFiles); }
public void FindItemsForClickOnceWithBaseApplicationManifests() { ProjectRootElement projectRootElement = CreateProjectRootElement(); // This is generally set by the toolset for certain output types projectRootElement.AddProperty(ManifestsPredictor.GenerateClickOnceManifestsPropertyName, "true"); projectRootElement.AddItem(ManifestsPredictor.BaseApplicationManifestItemName, @"Properties\app.manifest"); ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement); var expectedInputFiles = new[] { new PredictedItem(@"Properties\app.manifest", nameof(ManifestsPredictor)), }; var expectedOutputFiles = new[] { new PredictedItem(@"obj\Release\MyApplication.exe.manifest", nameof(ManifestsPredictor)), new PredictedItem(@"bin\Release\MyApplication.exe.manifest", nameof(ManifestsPredictor)), new PredictedItem(@"obj\Release\MyApplication.application", nameof(ManifestsPredictor)), new PredictedItem(@"bin\Release\MyApplication.application", nameof(ManifestsPredictor)), }; new ManifestsPredictor() .GetProjectPredictions(projectInstance) .AssertPredictions( projectInstance, expectedInputFiles.MakeAbsolute(_rootDir), null, expectedOutputFiles.MakeAbsolute(_rootDir), null); }
public void UseCommonOutputDirectory() { string projectFile = Path.Combine(_rootDir, @"src\project.csproj"); ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile); projectRootElement.AddProperty(GetCopyToOutputDirectoryItemsGraphPredictor.OutDirPropertyName, @"bin\"); projectRootElement.AddProperty(GetCopyToOutputDirectoryItemsGraphPredictor.UseCommonOutputDirectoryPropertyName, "true"); const bool shouldCopy = true; ProjectRootElement dep1 = CreateDependencyProject("dep1", shouldCopy); ProjectRootElement dep2 = CreateDependencyProject("dep2", shouldCopy); ProjectRootElement dep3 = CreateDependencyProject("dep3", shouldCopy); // The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1. Note that this predictor should *not* be transitive projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj"); dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj"); dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.Save(); dep1.Save(); dep2.Save(); dep3.Save(); new GetCopyToOutputDirectoryItemsGraphPredictor() .GetProjectPredictions(projectFile) .AssertNoPredictions(); }
private static ProjectItemElement AddVirtualEnvironment( ProjectRootElement project, string sourcePath, string id, InterpreterConfiguration config ) { var prefixPath = config.PrefixPath ?? string.Empty; var interpreterPath = string.IsNullOrEmpty(config.InterpreterPath) ? string.Empty : PathUtils.GetRelativeFilePath(prefixPath, config.InterpreterPath); var windowInterpreterPath = string.IsNullOrEmpty(config.WindowsInterpreterPath) ? string.Empty : PathUtils.GetRelativeFilePath(prefixPath, config.WindowsInterpreterPath); prefixPath = PathUtils.GetRelativeDirectoryPath(sourcePath, prefixPath); return(project.AddItem( MSBuildConstants.InterpreterItem, prefixPath, new Dictionary <string, string> { { MSBuildConstants.IdKey, id }, { MSBuildConstants.DescriptionKey, config.Description }, { MSBuildConstants.InterpreterPathKey, interpreterPath }, { MSBuildConstants.WindowsPathKey, windowInterpreterPath }, { MSBuildConstants.VersionKey, config.Version.ToString() }, { MSBuildConstants.ArchitectureKey, config.Architecture.ToString("X") }, { MSBuildConstants.PathEnvVarKey, config.PathEnvironmentVariable } } )); }
private ProjectRootElement CreateProject() { Microsoft.Build.Evaluation.Project project = null; try { project = Microsoft.Expression.Project.Build.BuildManager.GetProject(DocumentReference.Create(this.originalProjectFilePath)); } catch (ArgumentException argumentException) { } ProjectRootElement projectRootElement = ProjectRootElement.Create(); projectRootElement.ToolsVersion = "4.0"; this.AddBuildProperties(projectRootElement, project); projectRootElement.AddItemGroup(); projectRootElement.AddPropertyGroup(); projectRootElement.AddProperty("IntermediateOutputPath", Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath)); this.AddAssemblyReferences(projectRootElement, project); this.AddImports(projectRootElement, project); if (!this.IsSilverlightApplication(project)) { this.AddWpfImports(projectRootElement); } projectRootElement.AddItem("Page", this.xamlPath); string str = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath), "MarkupCompileAssembly.proj"); projectRootElement.Save(str); return(projectRootElement); }
private static ProjectItemElement AddVirtualEnvironment( ProjectRootElement project, string sourcePath, InterpreterFactoryCreationOptions options ) { var prefixPath = options.PrefixPath ?? string.Empty; var interpreterPath = string.IsNullOrEmpty(options.InterpreterPath) ? string.Empty : CommonUtils.GetRelativeFilePath(prefixPath, options.InterpreterPath); var windowInterpreterPath = string.IsNullOrEmpty(options.WindowInterpreterPath) ? string.Empty : CommonUtils.GetRelativeFilePath(prefixPath, options.WindowInterpreterPath); var libraryPath = string.IsNullOrEmpty(options.LibraryPath) ? string.Empty : CommonUtils.GetRelativeDirectoryPath(prefixPath, options.LibraryPath); prefixPath = CommonUtils.GetRelativeDirectoryPath(sourcePath, prefixPath); return(project.AddItem( MSBuildProjectInterpreterFactoryProvider.InterpreterItem, prefixPath, new Dictionary <string, string> { { MSBuildProjectInterpreterFactoryProvider.IdKey, Guid.NewGuid().ToString("B") }, { MSBuildProjectInterpreterFactoryProvider.DescriptionKey, options.Description }, { MSBuildProjectInterpreterFactoryProvider.BaseInterpreterKey, options.IdString }, { MSBuildProjectInterpreterFactoryProvider.InterpreterPathKey, interpreterPath }, { MSBuildProjectInterpreterFactoryProvider.WindowsPathKey, windowInterpreterPath }, { MSBuildProjectInterpreterFactoryProvider.LibraryPathKey, libraryPath }, { MSBuildProjectInterpreterFactoryProvider.VersionKey, options.LanguageVersionString }, { MSBuildProjectInterpreterFactoryProvider.ArchitectureKey, options.ArchitectureString }, { MSBuildProjectInterpreterFactoryProvider.PathEnvVarKey, options.PathEnvironmentVariableName } } )); }
public void SaveWithTransformsToFile() { ProjectRootElement project = ProjectRootElement.Create(); project.AddItem("i", "@(h->'%(x)')"); string file = null; try { file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); project.Save(file); string expected = ObjectModelHelpers.CleanupFileContents( @"<?xml version=""1.0"" encoding=""utf-8""?> <Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""@(h->'%(x)')"" /> </ItemGroup> </Project>"); string actual = File.ReadAllText(file); Helpers.VerifyAssertLineByLine(expected, actual); } finally { File.Delete(file); } }
public static void AddItemChecked(this ProjectRootElement root, string itemType, string include) { if (!root.HasItem(itemType, include)) { root.AddItem(itemType, include); } }
private static void GenAssemblyInfoFile(ProjectRootElement root, string dir, string name, string[] assemblyLines = null, string[] usingDirectives = null) { string propertiesDir = Path.Combine(dir, "Properties"); if (!Directory.Exists(propertiesDir)) { Directory.CreateDirectory(propertiesDir); } string usingDirectivesText = string.Empty; if (usingDirectives != null) { foreach (var usingDirective in usingDirectives) { usingDirectivesText += "\nusing " + usingDirective + ";"; } } string assemblyLinesText = string.Empty; if (assemblyLines != null) { assemblyLinesText += string.Join("\n", assemblyLines) + "\n"; } string content = string.Format(AssemblyInfoTemplate, usingDirectivesText, name, assemblyLinesText); string assemblyInfoFile = Path.Combine(propertiesDir, "AssemblyInfo.cs"); File.WriteAllText(assemblyInfoFile, content); root.AddItem("Compile", assemblyInfoFile.RelativeToPath(dir).Replace("/", "\\")); }
public void FindRobocopyForExistingFile() { ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"src\project.csproj")); projectRootElement.AddProperty(ArtifactsSdkPredictor.UsingMicrosoftArtifactsSdkPropertyName, "true"); projectRootElement.AddProperty("ArtifactsPath", Path.Combine(_rootDir, "out")); var artifactItem = projectRootElement.AddItem(ArtifactsSdkPredictor.RobocopyItemName, "Robocopy.txt"); artifactItem.AddMetadata(ArtifactsSdkPredictor.DestinationFolderMetadata, @"$(ArtifactsPath)\Project"); Directory.CreateDirectory(Path.Combine(_rootDir, "src")); File.WriteAllText(Path.Combine(_rootDir, @"src\Robocopy.txt"), "SomeContent"); ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement); var expectedInputFiles = new[] { new PredictedItem(@"src\Robocopy.txt", nameof(ArtifactsSdkPredictor)), }; var expectedOutputFiles = new[] { new PredictedItem(@"out\Project\Robocopy.txt", nameof(ArtifactsSdkPredictor)), }; new ArtifactsSdkPredictor() .GetProjectPredictions(projectInstance) .AssertPredictions( projectInstance, expectedInputFiles.MakeAbsolute(_rootDir), null, expectedOutputFiles.MakeAbsolute(_rootDir), null); }
public void FindArtifactsForGeneratedDirectory() { ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"foo\foo.csproj")); projectRootElement.AddProperty(ArtifactsSdkPredictor.UsingMicrosoftArtifactsSdkPropertyName, "true"); projectRootElement.AddProperty("EnlistmentRoot", _rootDir); projectRootElement.AddProperty("OutputPath", @"bin\x64"); // Copying another project's output dir to this project's output dir var artifactItem = projectRootElement.AddItem(ArtifactsSdkPredictor.ArtifactsItemName, @"$(EnlistmentRoot)\bar\$(OutputPath)"); artifactItem.AddMetadata(ArtifactsSdkPredictor.DestinationFolderMetadata, @"$(OutputPath)"); artifactItem.AddMetadata(ArtifactsSdkPredictor.FileMatchMetadata, "*.dll *.pdb"); ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement); var expectedInputDirectories = new[] { new PredictedItem(@"bar\bin\x64", nameof(ArtifactsSdkPredictor)), }; var expectedOutputDirectories = new[] { new PredictedItem(@"foo\bin\x64", nameof(ArtifactsSdkPredictor)), }; new ArtifactsSdkPredictor() .GetProjectPredictions(projectInstance) .AssertPredictions( projectInstance, null, expectedInputDirectories.MakeAbsolute(_rootDir), null, expectedOutputDirectories.MakeAbsolute(_rootDir)); }
public void ValidXmlXmlTextReaderNotCache() { string content = @" <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'> </Project> "; string path = null; try { path = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile(); File.WriteAllText(path, content); XmlTextReader reader1 = new XmlTextReader(path); ProjectRootElement root1 = ProjectRootElement.Create(reader1); root1.AddItem("type", "include"); // If it's in the cache, then the 2nd document won't see the add. XmlTextReader reader2 = new XmlTextReader(path); ProjectRootElement root2 = ProjectRootElement.Create(reader2); Assert.AreEqual(1, root1.Items.Count); Assert.AreEqual(0, root2.Items.Count); reader1.Close(); reader2.Close(); } finally { File.Delete(path); } }
public void FindItems() { string projectFile = Path.Combine(_rootDir, @"src\project.csproj"); ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile); ProjectRootElement dep1 = CreateDependencyProject("dep1"); ProjectRootElement dep2 = CreateDependencyProject("dep2"); ProjectRootElement dep3 = CreateDependencyProject("dep3"); ProjectRootElement dep4 = CreateDependencyProject("dep4"); // The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1 and 4. // This tests both transitivity and deduping. projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj"); projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj"); dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj"); dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj"); dep3.AddItem("ProjectReference", @"..\dep4\dep4.proj"); projectRootElement.Save(); dep1.Save(); dep2.Save(); dep3.Save(); dep4.Save(); var expectedInputFiles = new[] { new PredictedItem(@"dep1\dep1.proj", nameof(ProjectFileAndImportsGraphPredictor)), new PredictedItem(@"dep1\dep1.targets", nameof(ProjectFileAndImportsGraphPredictor)), new PredictedItem(@"dep2\dep2.proj", nameof(ProjectFileAndImportsGraphPredictor)), new PredictedItem(@"dep2\dep2.targets", nameof(ProjectFileAndImportsGraphPredictor)), new PredictedItem(@"dep3\dep3.proj", nameof(ProjectFileAndImportsGraphPredictor)), new PredictedItem(@"dep3\dep3.targets", nameof(ProjectFileAndImportsGraphPredictor)), new PredictedItem(@"dep4\dep4.proj", nameof(ProjectFileAndImportsGraphPredictor)), new PredictedItem(@"dep4\dep4.targets", nameof(ProjectFileAndImportsGraphPredictor)), }; new ProjectFileAndImportsGraphPredictor() .GetProjectPredictions(projectFile) .AssertPredictions( _rootDir, expectedInputFiles, null, null, null); }
private static ProjectInstance CreateTestProjectInstance(string fileName) { ProjectRootElement projectRootElement = ProjectRootElement.Create(fileName); projectRootElement.AddItemDefinitionGroup() .AddItemDefinition(ModuleDefinitionFilePredictor.LinkItemName) .AddMetadata(ModuleDefinitionFilePredictor.ModuleDefinitionFileMetadata, @".\Link.def"); projectRootElement.AddItem(ModuleDefinitionFilePredictor.LinkItemName, "Link.lib"); projectRootElement.AddItem(ModuleDefinitionFilePredictor.LibItemName, "Lib.lib") .AddMetadata(ModuleDefinitionFilePredictor.ModuleDefinitionFileMetadata, @".\Lib.def"); // Has spaces projectRootElement.AddItem(ModuleDefinitionFilePredictor.ImpLibItemName, "ImpLib.lib") .AddMetadata(ModuleDefinitionFilePredictor.ModuleDefinitionFileMetadata, @" .\ImpLib.def "); return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement)); }
public void Globs() { ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"project.csproj")); projectRootElement.AddItem(TsConfigPredictor.ContentItemName, TsConfigPredictor.TsConfigFileName); const string TsConfigContent = @" { ""compilerOptions"": { ""outFile"": ""dist/out.js"", }, ""include"": [ ""**/*.ts"" ], ""exclude"": [ ""node_modules"", ""**/*.spec.ts"" ] }"; File.WriteAllText(Path.Combine(_rootDir, TsConfigPredictor.TsConfigFileName), TsConfigContent); WriteDummyFiles( "foo.ts", "foo.spec.ts", "bar.ts", "bar.spec.ts", "baz.ts", "baz.spec.ts", "unrelatedFile.txt", @"node_modules\a\index.ts", @"node_modules\b\index.ts", @"node_modules\c\index.ts"); ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement); var expectedInputFiles = new[] { new PredictedItem(@"foo.ts", nameof(TsConfigPredictor)), new PredictedItem(@"bar.ts", nameof(TsConfigPredictor)), new PredictedItem(@"baz.ts", nameof(TsConfigPredictor)), }; var expectedOutputFiles = new[] { new PredictedItem(@"dist\out.js", nameof(TsConfigPredictor)), }; new TsConfigPredictor() .GetProjectPredictions(projectInstance) .AssertPredictions( projectInstance, expectedInputFiles.MakeAbsolute(_rootDir), null, expectedOutputFiles.MakeAbsolute(_rootDir), null); }
public void FindItems() { string projectFile = Path.Combine(_rootDir, @"src\project.sfproj"); ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile); projectRootElement.AddProperty(GetCopyToPublishDirectoryItemsGraphPredictor.PublishDirPropertyName, @"bin\Publish"); ProjectRootElement service1 = CreateServiceProject("service1"); ProjectRootElement service2 = CreateServiceProject("service2"); ProjectRootElement service3 = CreateServiceProject("service3"); projectRootElement.AddItem("ProjectReference", @"..\service1\service1.csproj"); projectRootElement.AddItem("ProjectReference", @"..\service2\service2.csproj"); projectRootElement.AddItem("ProjectReference", @"..\service3\service3.csproj"); projectRootElement.Save(); service1.Save(); service2.Save(); service3.Save(); var expectedInputFiles = new[] { new PredictedItem(@"service1_dep1\service1_dep1.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)), new PredictedItem(@"service1_dep2\service1_dep2.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)), new PredictedItem(@"service2_dep1\service2_dep1.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)), new PredictedItem(@"service2_dep2\service2_dep2.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)), new PredictedItem(@"service3_dep1\service3_dep1.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)), new PredictedItem(@"service3_dep2\service3_dep2.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)), }; var expectedOutputDirectories = new[] { new PredictedItem(@"src\bin\Publish", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)), }; new ServiceFabricCopyFilesToPublishDirectoryGraphPredictor() .GetProjectPredictions(projectFile) .AssertPredictions( _rootDir, expectedInputFiles, null, null, expectedOutputDirectories); }
/// <summary> /// Creates and returns an empty MSBuild project using the data in the supplied descriptor. /// The project will import the SonarQube analysis targets file and the standard C# targets file. /// The project name and GUID will be set if the values are supplied in the descriptor. /// </summary> private static ProjectRootElement CreateAnalysisProject(TestContext testContext, ProjectDescriptor descriptor, IDictionary <string, string> preImportProperties) { if (testContext == null) { throw new ArgumentNullException("testContext"); } if (descriptor == null) { throw new ArgumentNullException("descriptor"); } string sqTargetFile = TestUtils.EnsureAnalysisTargetsExists(testContext); Assert.IsTrue(File.Exists(sqTargetFile), "Test error: the SonarQube analysis targets file could not be found. Full path: {0}", sqTargetFile); testContext.AddResultFile(sqTargetFile); IDictionary <string, string> properties = preImportProperties ?? new Dictionary <string, string>(); // Disable the standard "ImportBefore/ImportAfter" behaviour if the caller // hasn't defined what they want to happen explicitly if (!properties.ContainsKey(StandardImportBeforePropertyName)) { DisableStandardTargetsWildcardImporting(properties); } ProjectRootElement root = CreateMinimalBuildableProject(properties, descriptor.IsVbProject, sqTargetFile); // Set the location of the task assembly if (!properties.ContainsKey(TargetProperties.SonarBuildTasksAssemblyFile)) { root.AddProperty(TargetProperties.SonarBuildTasksAssemblyFile, typeof(WriteProjectInfoFile).Assembly.Location); } if (descriptor.ProjectGuid != Guid.Empty) { root.AddProperty(TargetProperties.ProjectGuid, descriptor.ProjectGuid.ToString("D")); } foreach (ProjectDescriptor.FileInProject file in descriptor.Files) { root.AddItem(file.ItemGroup, file.FilePath); } if (descriptor.IsTestProject && !root.Properties.Any(p => string.Equals(p.Name, TargetProperties.SonarQubeTestProject))) { root.AddProperty(TargetProperties.SonarQubeTestProject, "true"); } if (descriptor.Encoding != null) { root.AddProperty(TargetProperties.CodePage, descriptor.Encoding.CodePage.ToString()); } return(root); }
public void E2E_FxCop_AllConditionsMet_VB() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.RunCodeAnalysis = "false"; preImportProperties.CodeAnalysisLogFile = fxCopLogFile; preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset"; preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder; CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "vbnet")); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties, isVBProject: true); string itemPath = TestUtils.CreateTextFile(rootInputFolder, "my.vb", @"Public Class Class1 Public Sub DoStuff() End Sub End Class"); projectRoot.AddItem(TargetProperties.ItemType_Compile, itemPath); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertExpectedTargetOrdering( TargetConstants.DetectFxCopRulesetTarget, TargetConstants.CategoriseProjectTarget, TargetConstants.OverrideFxCopSettingsTarget, TargetConstants.FxCopTarget, TargetConstants.SetFxCopResultsTarget, TargetConstants.DefaultBuildTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.WriteProjectDataTarget); AssertAllFxCopTargetsExecuted(logger); Assert.IsTrue(File.Exists(fxCopLogFile), "FxCop log file should have been produced"); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultExists(projectInfo, AnalysisType.FxCop.ToString(), fxCopLogFile); }
public static bool AddItemChecked(this ProjectRootElement root, string itemType, string include) { if (!root.HasItem(itemType, include, noCondition: true)) { root.AddItem(itemType, include); return(true); } return(false); }
/// <summary> /// Adds a file to the project, and optionally adds a reference to the project file /// </summary> /// <param name="path"></param> /// <param name="stream"></param> public override void AddFile(string path, System.IO.Stream stream) { base.AddFile(path, stream); if (AddReferenceToProject) { ProjectRootElement rootElement = ProjectRootElement.Open(ProjectPath); rootElement.AddItem("Content", path); } }
public void WithCopy() { ProjectRootElement projectRootElement = ProjectRootElement.Create(); projectRootElement.AddProperty(EmbeddedResourceItemsPredictor.OutDirPropertyName, @"bin\"); ProjectItemElement item1 = projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource1.resx"); item1.AddMetadata("CopyToOutputDirectory", "PreserveNewest"); ProjectItemElement item2 = projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource2.resx"); item2.AddMetadata("CopyToOutputDirectory", "PreserveNewest"); ProjectItemElement item3 = projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource3.resx"); item3.AddMetadata("CopyToOutputDirectory", "PreserveNewest"); ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement); var expectedInputFiles = new[] { new PredictedItem("Resource1.resx", nameof(EmbeddedResourceItemsPredictor)), new PredictedItem("Resource2.resx", nameof(EmbeddedResourceItemsPredictor)), new PredictedItem("Resource3.resx", nameof(EmbeddedResourceItemsPredictor)), }; var expectedoutputFiles = new[] { new PredictedItem(@"bin\Resource1.resx", nameof(EmbeddedResourceItemsPredictor)), new PredictedItem(@"bin\Resource2.resx", nameof(EmbeddedResourceItemsPredictor)), new PredictedItem(@"bin\Resource3.resx", nameof(EmbeddedResourceItemsPredictor)), }; new EmbeddedResourceItemsPredictor() .GetProjectPredictions(projectInstance) .AssertPredictions( projectInstance, expectedInputFiles, null, expectedoutputFiles, null); }
public void EmptyPredictionsResultInEmptyAggregateResult() { var graphPredictors = new IProjectGraphPredictor[] { new MockGraphPredictor(null, null, null, null), new MockGraphPredictor(null, null, null, null), }; var predictors = new IProjectPredictor[] { new MockPredictor(null, null, null, null), new MockPredictor(null, null, null, null), }; var executor = new ProjectGraphPredictionExecutor(graphPredictors, predictors); ProjectRootElement projectA = CreateProject("a"); ProjectRootElement projectB = CreateProject("b"); ProjectRootElement projectC = CreateProject("c"); ProjectRootElement projectD = CreateProject("d"); // A depends on B, D; B depends on C, D; C depends on D projectA.AddItem("ProjectReference", @"..\b\b.proj"); projectA.AddItem("ProjectReference", @"..\d\d.proj"); projectB.AddItem("ProjectReference", @"..\c\c.proj"); projectB.AddItem("ProjectReference", @"..\d\d.proj"); projectC.AddItem("ProjectReference", @"..\d\d.proj"); projectA.Save(); projectB.Save(); projectC.Save(); projectD.Save(); var projectGraph = new ProjectGraph(projectA.FullPath, new ProjectCollection()); ProjectGraphPredictions graphPredictions = executor.PredictInputsAndOutputs(projectGraph); AssertPredictionsMadeForEveryNode(projectGraph, graphPredictions); foreach (ProjectPredictions projectPredictions in graphPredictions.PredictionsPerNode.Values) { projectPredictions.AssertNoPredictions(); } }
public void E2E_FxCop_TestProject_TestProjectTypeGuid() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.CodeAnalysisLogFile = fxCopLogFile; preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset"; preImportProperties.ProjectTypeGuids = "X;" + TargetConstants.MsTestProjectTypeGuid.ToUpperInvariant() + ";Y"; preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder; CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs")); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); // Add a file to the project string itemPath = CreateTextFile(rootInputFolder, "code1.cs", "class myclassXXX{}"); projectRoot.AddItem(TargetProperties.ItemType_Compile, itemPath); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertExpectedTargetOrdering( TargetConstants.CategoriseProjectTarget, TargetConstants.OverrideFxCopSettingsTarget, TargetConstants.FxCopTarget, TargetConstants.DefaultBuildTarget, TargetConstants.CalculateFilesToAnalyzeTarget, TargetConstants.WriteProjectDataTarget); // We expect the FxCop target to be executed... logger.AssertTargetExecuted(TargetConstants.FxCopTarget); // ... but we don't expect the FxCop *task* to have executed logger.AssertTaskNotExecuted(TargetConstants.FxCopTask); logger.AssertTargetNotExecuted(TargetConstants.SetFxCopResultsTarget); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString()); }