public void StyleCop_TargetExecutionOrder() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; properties.SonarQubeOutputPath = rootInputFolder; properties.SonarQubeConfigPath = rootOutputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); // Add some settings we expect to be ignored AddAnalysisSetting("sonar.other.setting", "other value", projectRoot); AddAnalysisSetting("sonar.other.setting.2", "other value 2", projectRoot); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.DefaultBuildTarget); // Assert logger.AssertTargetExecuted(TargetConstants.SetStyleCopSettingsTarget); logger.AssertExpectedTargetOrdering(TargetConstants.SetStyleCopSettingsTarget, TargetConstants.WriteProjectDataTarget); AssertExpectedStyleCopSetting(projectRoot.ProjectFileLocation.File, result); }
public void Roslyn_Settings_RuleSetDoesNotExist() { // Arrange BuildLogger logger = new BuildLogger(); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.ResolvedCodeAnalysisRuleset = "pre-existing.ruleset"; properties.ErrorLog = "pre-existing.log"; ProjectRootElement projectRoot = CreateValidProjectSetup(properties); this.DeleteDummyRulesetFile(); // 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 intermediate working properties have the expected values BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarQubeRoslynRulesetExists", "False"); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarQubeRoslynAssemblyExists", "True"); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarLintFound", "false"); AssertExpectedAnalysisProperties(result, "pre-existing.log", "pre-existing.ruleset"); }
public void ImportsBefore_MissingAnalysisTargets() { // 1. Prebuild // Arrange WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = "nonExistentPath"; preImportProperties.MSBuildExtensionsPath = "nonExistentPath"; preImportProperties.TeamBuild2105BuildDirectory = ""; preImportProperties.TeamBuildLegacyBuildDirectory = ""; // Act ProjectInstance projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetsPath, @"nonExistentPath\bin\targets"); BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetFilePath, @"nonExistentPath\bin\targets\SonarQube.Integration.targets"); AssertAnalysisTargetsAreNotImported(projectInstance); // Targets should not be imported // 2. Now build -> fails with an error message BuildLogger logger = new BuildLogger(); BuildResult result = BuildUtilities.BuildTargets(projectInstance, logger); BuildAssertions.AssertTargetFailed(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetExecuted(TargetConstants.ImportBeforeInfoTarget); logger.AssertExpectedErrorCount(1); string projectName = Path.GetFileName(projectInstance.FullPath); Assert.IsTrue(logger.Errors[0].Message.Contains(projectName), "Expecting the error message to contain the project file name"); }
public void ImportsBefore_SonarQubeTargetsPathNotSet() { // 1. Prebuild // Arrange string dummyAnalysisTargetsDir = this.EnsureDummyIntegrationTargetsFileExists(); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTargetsPath = ""; preImportProperties.TeamBuild2105BuildDirectory = ""; preImportProperties.TeamBuildLegacyBuildDirectory = ""; // Act ProjectInstance projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.SonarQubeTargetFilePath); AssertAnalysisTargetsAreNotImported(projectInstance); // 2. Now build -> succeeds. Info target not executed BuildLogger logger = new BuildLogger(); BuildResult result = BuildUtilities.BuildTargets(projectInstance, logger); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetNotExecuted(TargetConstants.ImportBeforeInfoTarget); logger.AssertExpectedErrorCount(0); }
public void E2E_FxCop_OutputFolderNotSet() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); // Don't set the output folder WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); // Clear all of the variables that could be used to look up the output path // (necessary so the test works correctly when run under TeamBuild on a machine // that has the integration targets installed) preImportProperties.SonarQubeOutputPath = ""; preImportProperties.TeamBuild2105BuildDirectory = ""; preImportProperties.TeamBuildLegacyBuildDirectory = ""; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); BuildLogger logger = new BuildLogger(); // 1. No code analysis properties BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetNotExecuted(TargetConstants.OverrideFxCopSettingsTarget); logger.AssertTargetNotExecuted(TargetConstants.SetFxCopResultsTarget); AssertFxCopNotExecuted(logger); ProjectInfoAssertions.AssertNoProjectInfoFilesExists(rootOutputFolder); }
public void Roslyn_SetResults_ResultsFileExists() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string resultsFile = TestUtils.CreateTextFile(rootInputFolder, "error.report.txt", "dummy report content"); WellKnownProjectProperties properties = new WellKnownProjectProperties { SonarQubeTempPath = rootInputFolder }; properties[TargetProperties.ErrorLog] = resultsFile; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.CreateProjectSpecificDirs, TargetConstants.SetRoslynResultsTarget); string projectSpecificOutDir = result.ProjectStateAfterBuild.GetPropertyValue(TargetProperties.ProjectSpecificOutDir); // Assert logger.AssertTargetExecuted(TargetConstants.CreateProjectSpecificDirs); logger.AssertTargetExecuted(TargetConstants.SetRoslynResultsTarget); BuildAssertions.AssertExpectedAnalysisSetting(result, RoslynAnalysisResultsSettingName, resultsFile); BuildAssertions.AssertExpectedAnalysisSetting(result, AnalyzerWorkDirectoryResultsSettingName, projectSpecificOutDir); }
public void Roslyn_SetResults_ResultsFileExists() { // Arrange var rootInputFolder = TestUtils.CreateTestSpecificFolder(TestContext, "Inputs"); var resultsFile = TestUtils.CreateTextFile(rootInputFolder, "error.report.txt", "dummy report content"); var properties = new WellKnownProjectProperties { SonarQubeTempPath = rootInputFolder }; properties[TargetProperties.ErrorLog] = resultsFile; var projectRoot = BuildUtilities.CreateValidProjectRoot(TestContext, rootInputFolder, properties); AddCaptureTargetsImport(rootInputFolder, projectRoot); projectRoot.Save(); // Act var result = BuildRunner.BuildTargets(TestContext, projectRoot.FullPath, TargetConstants.CreateProjectSpecificDirs, TargetConstants.SetRoslynResultsTarget); var projectSpecificOutDir = result.GetCapturedPropertyValue(TargetProperties.ProjectSpecificOutDir); // Assert result.AssertTargetExecuted(TargetConstants.CreateProjectSpecificDirs); result.AssertTargetExecuted(TargetConstants.SetRoslynResultsTarget); AssertExpectedAnalysisSetting(result, RoslynAnalysisResultsSettingName, resultsFile); AssertExpectedAnalysisSetting(result, AnalyzerWorkDirectoryResultsSettingName, projectSpecificOutDir); }
[TestCategory("E2E"), TestCategory("Targets")] // SONARMSBRU-12: Analysis build fails if the build definition name contains brackets public void E2E_UsingTaskHandlesBracketsInName() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "folder with brackets in name (SONARMSBRU-12)"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); ProjectDescriptor descriptor = BuildUtilities.CreateValidProjectDescriptor(rootInputFolder); AddEmptyAnalysedCodeFile(descriptor, rootInputFolder); // Copy the task assembly to a folder with brackets in the name string taskAssemblyFilePath = typeof(WriteProjectInfoFile).Assembly.Location; string asmName = Path.GetFileName(taskAssemblyFilePath); string copiedTaskAssemblyFilePath = Path.Combine(rootInputFolder, Path.GetFileName(asmName)); File.Copy(taskAssemblyFilePath, copiedTaskAssemblyFilePath); // Set the project property to use that file. To reproduce the bug, we need to have MSBuild search for // the assembly using "GetDirectoryNameOfFileAbove". string val = @"$([MSBuild]::GetDirectoryNameOfFileAbove('{0}', '{1}'))\{1}"; val = string.Format(System.Globalization.CultureInfo.InvariantCulture, val, rootInputFolder, asmName); WellKnownProjectProperties preImportProperties = CreateDefaultAnalysisProperties(rootInputFolder, rootOutputFolder); preImportProperties.Add(TargetProperties.SonarBuildTasksAssemblyFile, val); // Act string projectDir = CreateAndBuildSonarProject(descriptor, rootOutputFolder, preImportProperties); AssertFileExists(projectDir, ExpectedAnalysisFilesListFileName); CheckProjectOutputFolder(descriptor, projectDir); }
public void StyleCop_ValueAlreadySet() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; properties.SonarQubeOutputPath = rootInputFolder; properties.SonarQubeConfigPath = rootOutputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); // Apply some SonarQubeSettings, one of which specifies the StyleCop setting AddAnalysisSetting("sonar.other.setting", "other value", projectRoot); AddAnalysisSetting(TargetConstants.StyleCopProjectPathItemName, "xxx.yyy", projectRoot); AddAnalysisSetting("sonar.other.setting.2", "other value 2", projectRoot); projectRoot.Save(); BuildLogger logger = new BuildLogger(); BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.SetStyleCopSettingsTarget); // Assert logger.AssertTargetExecuted(TargetConstants.SetStyleCopSettingsTarget); AssertExpectedStyleCopSetting("xxx.yyy", result); }
public void ImportsBefore_SonarQubeTargetsPathNotSet() { // 1. Prebuild // Arrange this.EnsureDummyIntegrationTargetsFileExists(); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTargetsPath = ""; preImportProperties.TeamBuild2105BuildDirectory = ""; preImportProperties.TeamBuildLegacyBuildDirectory = ""; // Act ProjectInstance projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.SonarQubeTargetFilePath); AssertAnalysisTargetsAreNotImported(projectInstance); // 2. Now build -> succeeds. Info target not executed BuildLogger logger = new BuildLogger(); BuildResult result = BuildUtilities.BuildTargets(projectInstance, logger); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetNotExecuted(TargetConstants.ImportBeforeInfoTarget); logger.AssertExpectedErrorCount(0); }
public void ImportsBefore_TargetsExist() { // 1. Pre-build // Arrange var dummySonarTargetsDir = EnsureDummyIntegrationTargetsFileExists(); var preImportProperties = new WellKnownProjectProperties { SonarQubeTempPath = Path.GetTempPath(), SonarQubeTargetsPath = Path.GetDirectoryName(dummySonarTargetsDir), TeamBuild2105BuildDirectory = "", TeamBuildLegacyBuildDirectory = "" }; // Act var projectInstance = CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetFilePath, dummySonarTargetsDir); AssertAnalysisTargetsAreImported(projectInstance); // 2. Now build -> succeeds var logger = new BuildLogger(); var result = BuildUtilities.BuildTargets(projectInstance, logger); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetExecuted(TargetConstants.ImportBeforeInfoTarget); logger.AssertExpectedErrorCount(0); }
public void E2E_FxCop_FailIfEnabledButNotInstalled() { string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.SonarQubeConfigPath = rootInputFolder; // FxCop's targets is imported when Visual Studio is installed, see Microsoft.Common.CurrentVersion.targets preImportProperties["CodeAnalysisTargets"] = Path.Combine(rootInputFolder, "non-existing.targets"); CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs")); ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetFailed(result, TargetConstants.DefaultBuildTarget); logger.AssertExpectedTargetOrdering( TargetConstants.DetectFxCopRulesetTarget, TargetConstants.FailIfFxCopNotInstalledTarget); AssertFxCopNotExecuted(logger); }
public void ImportsBefore_BuildingInsideVS_NotImported() { // 1. Pre-build // Arrange string dummySonarTargetsDir = this.EnsureDummyIntegrationTargetsFileExists(); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = Path.GetTempPath(); preImportProperties.SonarQubeTargetsPath = Path.GetDirectoryName(dummySonarTargetsDir); preImportProperties.BuildingInsideVS = "tRuE"; // should not be case-sensitive // Act ProjectInstance projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetFilePath, dummySonarTargetsDir); AssertAnalysisTargetsAreNotImported(projectInstance); // 2. Now build -> succeeds BuildLogger logger = new BuildLogger(); BuildResult result = BuildUtilities.BuildTargets(projectInstance, logger); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetNotExecuted(TargetConstants.ImportBeforeInfoTarget); logger.AssertExpectedErrorCount(0); }
public void IntTargets_SonarPaths_OutputAndConfigPathsAreSet() { // The SonarQubeTempPath and TeamBuild paths should be ignored if the output and config are set explicitly // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties { SonarQubeOutputPath = @"c:\output", SonarQubeConfigPath = @"c:\config", SonarQubeTempPath = @"c:\sonarQTemp", TeamBuildLegacyBuildDirectory = @"t:\Legacy TeamBuildPath\", TeamBuild2105BuildDirectory = @"t:\New TeamBuildPath\" }; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); // Act ProjectInstance projectInstance = new ProjectInstance(projectRoot.FullPath); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeOutputPath, @"c:\output"); BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeConfigPath, @"c:\config"); }
public void ImportsBefore_SonarQubeTargetsPathNotSet() { // 1. Prebuild // Arrange EnsureDummyIntegrationTargetsFileExists(); var preImportProperties = new WellKnownProjectProperties { SonarQubeTargetsPath = "", TeamBuild2105BuildDirectory = "", TeamBuildLegacyBuildDirectory = "" }; // Act var projectInstance = CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.SonarQubeTargetFilePath); AssertAnalysisTargetsAreNotImported(projectInstance); // 2. Now build -> succeeds. Info target not executed var result = BuildRunner.BuildTargets(TestContext, projectInstance.FullPath); result.AssertTargetSucceeded(TargetConstants.DefaultBuildTarget); result.AssertTargetNotExecuted(TargetConstants.ImportBeforeInfoTarget); result.AssertExpectedErrorCount(0); }
public void E2E_FxCop_NotExecutedOnCppProjects() { string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.SonarQubeConfigPath = rootInputFolder; preImportProperties["Language"] = "C++"; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); BuildAssertions.AssertPropertyDoesNotExist(result.ProjectStateAfterBuild, "RunCodeAnalysisOnce"); AssertFxCopNotExecuted(logger); }
public void ImportsBefore_BuildingInsideVS_NotImported() { // 1. Pre-build // Arrange var dummySonarTargetsDir = EnsureDummyIntegrationTargetsFileExists(); var preImportProperties = new WellKnownProjectProperties { SonarQubeTempPath = Path.GetTempPath(), SonarQubeTargetsPath = Path.GetDirectoryName(dummySonarTargetsDir), BuildingInsideVS = "tRuE" // should not be case-sensitive }; // Act var projectInstance = CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetFilePath, dummySonarTargetsDir); AssertAnalysisTargetsAreNotImported(projectInstance); // 2. Now build -> succeeds var result = BuildRunner.BuildTargets(TestContext, projectInstance.FullPath); result.AssertTargetSucceeded(TargetConstants.DefaultBuildTarget); result.AssertTargetNotExecuted(TargetConstants.ImportBeforeInfoTarget); result.AssertExpectedErrorCount(0); }
public void Roslyn_Settings_TempFolderIsNotSet() { // Arrange var properties = new WellKnownProjectProperties { ErrorLog = "pre-existing.log", ResolvedCodeAnalysisRuleset = "pre-existing.ruleset", WarningsAsErrors = "CS101", TreatWarningsAsErrors = "true" }; var projectRoot = CreateValidProjectSetup(properties); projectRoot.AddProperty(TargetProperties.SonarQubeTempPath, string.Empty); // needs to overwritten once the valid project has been created projectRoot.Save(); // re-save the modified project // Act var result = BuildRunner.BuildTargets(TestContext, projectRoot.FullPath, TargetConstants.OverrideRoslynAnalysisTarget); // Assert result.AssertTargetNotExecuted(TargetConstants.OverrideRoslynAnalysisTarget); result.AssertTargetNotExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); // Existing properties should not be changed AssertExpectedErrorLog(result, "pre-existing.log"); AssertExpectedResolvedRuleset(result, "pre-existing.ruleset"); result.AssertExpectedItemGroupCount(TargetProperties.AnalyzerItemType, 0); result.AssertExpectedItemGroupCount(TargetProperties.AdditionalFilesItemType, 0); result.AssertExpectedCapturedPropertyValue(TargetProperties.TreatWarningsAsErrors, "true"); result.AssertExpectedCapturedPropertyValue(TargetProperties.WarningsAsErrors, "CS101"); }
public void E2E_FxCop_OutputFolderSet_SonarRulesetNotSpecified() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); // Set the output folder but not the config folder string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.SonarQubeConfigPath = rootInputFolder; preImportProperties.RunCodeAnalysis = "TRUE"; preImportProperties.CodeAnalysisLogFile = fxCopLogFile; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetExecuted(TargetConstants.OverrideFxCopSettingsTarget); // output folder is set so this should be executed logger.AssertTargetNotExecuted(TargetConstants.SetFxCopResultsTarget); AssertFxCopNotExecuted(logger); Assert.IsFalse(File.Exists(fxCopLogFile), "FxCop log file should not have been produced"); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString()); }
public void E2E_HasManagedAndContentFiles_VB() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); ProjectDescriptor descriptor = BuildUtilities.CreateValidProjectDescriptor(rootInputFolder); descriptor.ProjectLanguage = ProjectLanguages.VisualBasic; AddEmptyAnalysedCodeFile(descriptor, rootInputFolder, ".vb"); AddEmptyAnalysedCodeFile(descriptor, rootInputFolder, ".vb"); AddEmptyContentFile(descriptor, rootInputFolder); AddEmptyContentFile(descriptor, rootInputFolder); WellKnownProjectProperties preImportProperties = CreateDefaultAnalysisProperties(rootInputFolder, rootOutputFolder); // Act string projectDir = CreateAndBuildSonarProject(descriptor, rootOutputFolder, preImportProperties); AssertFileExists(projectDir, ExpectedAnalysisFilesListFileName); CheckProjectOutputFolder(descriptor, projectDir); }
public void E2E_FxCop_TempFolderIsNotSet() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeOutputPath = rootOutputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); BuildLogger logger = new BuildLogger(); // 1. No code analysis properties BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetNotExecuted(TargetConstants.OverrideFxCopSettingsTarget); logger.AssertTargetNotExecuted(TargetConstants.SetFxCopResultsTarget); AssertFxCopNotExecuted(logger); ProjectInfoAssertions.AssertNoProjectInfoFilesExists(rootOutputFolder); }
public void ImportsBefore_AutoImport_IsAutoImported() { // 0. Set up WellKnownProjectProperties preImportProperties; string testDir = TestUtils.EnsureTestSpecificFolder(this.TestContext); string configFilePath = EnsureDummyAnalysisConfigFileExists(testDir); // 1. RunSonarAnalysisQube is not set, Legacy TFS path -> auto-import preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = ""; preImportProperties.TeamBuild2105BuildDirectory = ""; preImportProperties.TeamBuildLegacyBuildDirectory = testDir; preImportProperties.SonarQubeTargetsPath = "shouldn't matter if this is set"; // Act ProjectInstance projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.AutoImportProperty, "true"); // 2. RunSonarAnalysisQube is not set, non-legacy TFS path -> auto-import preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = ""; preImportProperties.TeamBuild2105BuildDirectory = testDir; preImportProperties.TeamBuildLegacyBuildDirectory = ""; preImportProperties.SonarQubeTargetsPath = "shouldn't matter if this is set"; // Act projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.AutoImportProperty, "true"); }
public void WriteProjectInfo_FakesProjects_ExplicitSonarTestPropertyIsIgnored() { // Checks that fakes projects are recognised and marked as test // projects, irrespective of whether the SonarQubeTestProject is // already set. // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); EnsureAnalysisConfig(rootInputFolder, "pattern that won't match anything"); WellKnownProjectProperties preImportProperties = CreateDefaultAnalysisProperties(rootInputFolder, rootOutputFolder); preImportProperties.SonarTestProject = "false"; preImportProperties.AssemblyName = "MyFakeProject.fakes"; ProjectDescriptor descriptor = BuildUtilities.CreateValidProjectDescriptor(rootInputFolder, "f.proj"); // Act ProjectInfo projectInfo = ExecuteWriteProjectInfo(descriptor, preImportProperties, rootOutputFolder); // Assert AssertIsTestProject(projectInfo); AssertProjectIsExcluded(projectInfo); }
public void Roslyn_Settings_TempFolderIsNotSet() { // Arrange BuildLogger logger = new BuildLogger(); WellKnownProjectProperties properties = new WellKnownProjectProperties { ErrorLog = "pre-existing.log", ResolvedCodeAnalysisRuleset = "pre-existing.ruleset", WarningsAsErrors = "CS101", TreatWarningsAsErrors = "true" }; ProjectRootElement projectRoot = CreateValidProjectSetup(properties); projectRoot.AddProperty(TargetProperties.SonarQubeTempPath, string.Empty); // needs to overwritten once the valid project has been created // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget); // Assert logger.AssertTargetNotExecuted(TargetConstants.OverrideRoslynAnalysisTarget); logger.AssertTargetNotExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); // Existing properties should not be changed AssertExpectedErrorLog(result, "pre-existing.log"); AssertExpectedResolvedRuleset(result, "pre-existing.ruleset"); BuildAssertions.AssertExpectedItemGroupCount(result, TargetProperties.AnalyzerItemType, 0); BuildAssertions.AssertExpectedItemGroupCount(result, TargetProperties.AdditionalFilesItemType, 0); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, TargetProperties.TreatWarningsAsErrors, "true"); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, TargetProperties.WarningsAsErrors, "CS101"); }
public void ImportsBefore_MissingAnalysisTargets() { // 1. Prebuild // Arrange var preImportProperties = new WellKnownProjectProperties { SonarQubeTempPath = "nonExistentPath", MSBuildExtensionsPath = "nonExistentPath", TeamBuild2105BuildDirectory = "", TeamBuildLegacyBuildDirectory = "" }; // Act var projectInstance = CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetsPath, @"nonExistentPath\bin\targets"); BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetFilePath, @"nonExistentPath\bin\targets\SonarQube.Integration.targets"); AssertAnalysisTargetsAreNotImported(projectInstance); // Targets should not be imported // 2. Now build -> fails with an error message var result = BuildRunner.BuildTargets(TestContext, projectInstance.FullPath, buildShouldSucceed: false); result.BuildSucceeded.Should().BeFalse(); result.AssertTargetExecuted(TargetConstants.ImportBeforeInfoTarget); result.AssertExpectedErrorCount(1); var projectName = Path.GetFileName(projectInstance.FullPath); result.Errors[0].Contains(projectName).Should().BeTrue("Expecting the error message to contain the project file name"); }
public void Roslyn_Settings_ErrorLogAlreadySet() { // Arrange BuildLogger logger = new BuildLogger(); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties[TargetProperties.ErrorLog] = "already.set.txt"; ProjectRootElement projectRoot = CreateValidProjectSetup(properties); // 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 intermediate working properties have the expected values BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarQubeRoslynRulesetExists", "True"); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarQubeRoslynAssemblyExists", "True"); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarLintFound", "true"); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, TargetProperties.ErrorLog, "already.set.txt"); }
/// <summary> /// Creates a default set of properties sufficient to trigger test analysis /// </summary> /// <param name="inputPath">The analysis config directory</param> /// <param name="outputPath">The output path into which results should be written</param> /// <returns></returns> private static WellKnownProjectProperties CreateDefaultAnalysisProperties(string configPath, string outputPath) { WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = configPath; preImportProperties.SonarQubeOutputPath = outputPath; preImportProperties.SonarQubeConfigPath = configPath; return(preImportProperties); }
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 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()); }
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()); }
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(); config.AnalyzerSettings = new AnalyzerSettings(); config.AnalyzerSettings.RuleSetFilePath = "d:\\my.ruleset"; config.AnalyzerSettings.AnalyzerAssemblyPaths = expectedAssemblies.ToList(); config.AnalyzerSettings.AdditionalFilePaths = expectedAdditionalFiles.ToList(); 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 SQBeforeClCompile_DefaultBinPath_BinariesFound_TaskExecuted() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); BuildLogger logger = new BuildLogger(); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; properties.BuildWrapperSkipFlag = "false"; properties.SonarQubeOutputPath = rootOutputFolder; // By default, the targets try to find the build wrapper binaries in a specific folder // below the folder containing the integration tasks assembly ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); // Check we can find the integration targets file in the expected location string targetsDir = TestUtils.GetTestSpecificFolderName(this.TestContext); string integrationTargetsPath = Path.Combine(targetsDir, TestUtils.AnalysisTargetFile); Assert.IsTrue(File.Exists(integrationTargetsPath), "Test setup error: did not find the integration targets in the expected location: {0}", integrationTargetsPath); // The targets expect to find the build wrapper binaries in a folder under // the folder containing the tasks assembly. // Create a dummy tasks assembly string dummyAsmFilePath = Path.Combine(targetsDir, "SonarQube.Integration.Tasks.dll"); Assert.IsFalse(File.Exists(dummyAsmFilePath), "Test setup error: not expecting the integration tasks assembly to exist at {0}", dummyAsmFilePath); File.WriteAllText(dummyAsmFilePath, "dummy content"); // Create the build wrapper sub directory string buildWrapperBinDir = Path.Combine(targetsDir, "build-wrapper-win-x86"); Directory.CreateDirectory(buildWrapperBinDir); // Create the required build wrapper files relative to this location CreateBuildWrapperMarkerFile(buildWrapperBinDir); // Act BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.BuildWrapperBeforeClCompileTarget); // Assert logger.AssertTargetExecuted(TargetConstants.BuildWrapperBeforeClCompileTarget); logger.AssertTargetExecuted(TargetConstants.BuildWrapperAttachTarget); // Note: task should fail because not all required files are present. However, // the important thing for this test is that is executed. logger.AssertTaskExecuted(TargetConstants.BuildWrapperAttachTask); }
public void IntTargets_SonarPaths_TeamBuildBuildDirNotSet() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.TeamBuildLegacyBuildDirectory = ""; preImportProperties.TeamBuild2105BuildDirectory = ""; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); // Act ProjectInstance projectInstance = new ProjectInstance(projectRoot.FullPath); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.SonarQubeOutputPath); BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.SonarQubeConfigPath); }
public void E2E_FxCop_AllConditionsMet() { // 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); string itemPath = TestUtils.CreateTextFile(rootInputFolder, "my.cs", "class myclass{}"); 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); 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 void StyleCop_TempFolderIsNotSet() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = ""; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); BuildLogger logger = new BuildLogger(); // Act BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.SetStyleCopSettingsTarget); // Assert logger.AssertTargetNotExecuted(TargetConstants.SetStyleCopSettingsTarget); }
public void IntTargets_SonarPaths_TeamBuildPropertySet_Legacy() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = @"t:\TeamBuildDir_Legacy\.sonarqube"; preImportProperties.TeamBuildLegacyBuildDirectory = @"t:\TeamBuildDir_Legacy"; preImportProperties.TeamBuild2105BuildDirectory = ""; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); // Act ProjectInstance projectInstance = new ProjectInstance(projectRoot.FullPath); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeOutputPath, @"t:\TeamBuildDir_Legacy\.sonarqube\out\"); BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeConfigPath, @"t:\TeamBuildDir_Legacy\.sonarqube\conf\"); }
public void Roslyn_SetResults_ResultsFileDoesNotExist() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.SetRoslynResultsTarget); // Assert logger.AssertTargetExecuted(TargetConstants.SetRoslynResultsTarget); BuildAssertions.AssertAnalysisSettingDoesNotExist(result, RoslynAnalysisResultsSettingName); }
public void Roslyn_Settings_ValidSetup_OverrideExistingSettings_AbsolutePath() { // Arrange BuildLogger logger = new BuildLogger(); // Set the ruleset property WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.ResolvedCodeAnalysisRuleset = "c:\\existing.ruleset"; // Add some existing analyzer settings ProjectRootElement projectRoot = CreateValidProjectSetup(properties); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "Analyzer1.dll"); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\Analyzer2.dll"); projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "additional1.txt"); projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "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 string sourceRulesetFilePath = GetDummyRulesetFilePath(); this.TestContext.AddResultFile(sourceRulesetFilePath); string targetDir = result.ProjectStateAfterBuild.GetPropertyValue(TargetProperties.TargetDir); string expectedErrorLog = Path.Combine(targetDir, ErrorLogFileName); AssertExpectedAnalysisProperties(result, expectedErrorLog, sourceRulesetFilePath, GetDummySonarLintXmlFilePath()); BuildAssertions.AssertWarningsAreNotTreatedAsErrorsNorIgnored(result); // Check the analyzer properties are set as expected List<string> expectedAnalyzers = new List<string>(GetSonarLintAnalyzerFilePaths()); AssertExpectedItemValuesExists(result, TargetProperties.AnalyzerItemType, expectedAnalyzers.ToArray()); }
public void Roslyn_SetResults_ResultsFileExists() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string resultsFile = TestUtils.CreateTextFile(rootInputFolder, "error.report.txt", "dummy report content"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; properties[TargetProperties.ErrorLog] = resultsFile; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.SetRoslynResultsTarget); // Assert logger.AssertTargetExecuted(TargetConstants.SetRoslynResultsTarget); BuildAssertions.AssertExpectedAnalysisSetting(result, RoslynAnalysisResultsSettingName, resultsFile); }
/// <summary> /// Creates a valid project with the necessary ruleset and assembly files on disc /// to successfully run the "OverrideRoslynCodeAnalysisProperties" target /// </summary> private ProjectRootElement CreateValidProjectSetup(WellKnownProjectProperties properties) { string sqTempFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); CreateDummySonarLintFiles(); CreateDummyRuleset(); WellKnownProjectProperties projectProperties = properties ?? new WellKnownProjectProperties(); string projectFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Project"); projectProperties.SonarQubeTempPath = sqTempFolder; projectProperties[TargetProperties.Language] = "C#"; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, projectFolder, projectProperties); return projectRoot; }
public void E2E_FxCop_TestProject_TestProjectByName() { // 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.SonarQubeConfigPath = rootInputFolder; preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder; CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs")); // Create a config file in the config folder containing a reg ex to identify tests projects AnalysisConfig config = new AnalysisConfig(); config.LocalSettings = new AnalysisProperties(); config.LocalSettings.Add(new Property() { Id = IsTestFileByName.TestRegExSettingId, Value = ".testp." }); string configFullPath = Path.Combine(rootInputFolder, FileConstants.ConfigFileName); config.Save(configFullPath); // Create a project with a file name that will match the reg ex ProjectDescriptor descriptor = BuildUtilities.CreateValidProjectDescriptor(rootInputFolder, "MyTestProject.proj"); ProjectRootElement projectRoot = BuildUtilities.CreateInitializedProjectRoot(this.TestContext, descriptor, preImportProperties); // Add a file to the project string itemPath = TestUtils.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()); }
public void Roslyn_Settings_Analyzer_AssemblyExists() { // Arrange BuildLogger logger = new BuildLogger(); WellKnownProjectProperties properties = new WellKnownProjectProperties(); ProjectRootElement projectRoot = CreateValidProjectSetup(properties); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "analyzer1.dll"); // additional -> preserve projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\myfolder\\analyzer2.dll"); // additional -> preserve projectRoot.AddItem(TargetProperties.AnalyzerItemType, "sonarlint.dll"); // relative path -> remove projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\myfolder\\sonarlint.dll"); // absolute path -> remove projectRoot.AddItem(TargetProperties.AnalyzerItemType, "XXSONARLINT.dll"); // case-sensitivity -> remove projectRoot.AddItem(TargetProperties.AnalyzerItemType, "sonarLint.dll.xxx"); // doesn't match -> preserve projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\sonarLint\\my.dll"); // doesn't match -> preserve // 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 intermediate working properties have the expected values BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarQubeRoslynRulesetExists", "True"); BuildAssertions.AssertExpectedPropertyValue(result.ProjectStateAfterBuild, "SonarLintFound", "true"); // Check the analyzer properties are set as expected List<string> expectedAnalyzers = new List<string>(GetSonarLintAnalyzerFilePaths()); expectedAnalyzers.Add("analyzer1.dll"); expectedAnalyzers.Add("c:\\myfolder\\analyzer2.dll"); expectedAnalyzers.Add("sonarLint.dll.xxx"); expectedAnalyzers.Add("c:\\sonarLint\\my.dll"); AssertExpectedAnalyzersExists(result, expectedAnalyzers.ToArray()); }
public void E2E_FxCop_OutputFolderSet_SonarRulesetNotFound() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); // Set the output folder and config path // Don't create a ruleset file on disc string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml"); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME preImportProperties.SonarQubeOutputPath = rootOutputFolder; preImportProperties.RunCodeAnalysis = "true"; // our targets should override this value preImportProperties.CodeAnalysisLogFile = fxCopLogFile; preImportProperties.SonarQubeConfigPath = rootInputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger); // Assert BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetExecuted(TargetConstants.OverrideFxCopSettingsTarget); // output folder is set so this should be executed logger.AssertTargetNotExecuted(TargetConstants.SetFxCopResultsTarget); // We expect the core FxCop *target* to have been started, but it should then be skipped // executing the FxCop *task* because the condition on the target is false // -> the FxCop output file should not be produced AssertFxCopNotExecuted(logger); Assert.IsFalse(File.Exists(fxCopLogFile), "FxCop log file should not have been produced"); ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath); ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString()); }
public void Roslyn_Settings_NotRunForTestProject() { // Arrange BuildLogger logger = new BuildLogger(); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.ProjectTypeGuids = TargetConstants.MsTestProjectTypeGuid; // mark the project as a test project ProjectRootElement projectRoot = CreateValidProjectSetup(properties); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget); // Assert logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); logger.AssertTargetNotExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.OverrideRoslynAnalysisTarget); AssertCodeAnalysisIsDisabled(result); }
public void ImportsBefore_TargetsExist() { // 1. Pre-build // Arrange string dummySonarTargetsDir = this.EnsureDummyIntegrationTargetsFileExists(); WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = Path.GetTempPath(); preImportProperties.SonarQubeTargetsPath = Path.GetDirectoryName(dummySonarTargetsDir); preImportProperties.TeamBuild2105BuildDirectory = ""; preImportProperties.TeamBuildLegacyBuildDirectory = ""; // Act ProjectInstance projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeTargetFilePath, dummySonarTargetsDir); AssertAnalysisTargetsAreImported(projectInstance); // 2. Now build -> succeeds BuildLogger logger = new BuildLogger(); BuildResult result = BuildUtilities.BuildTargets(projectInstance, logger); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetExecuted(TargetConstants.ImportBeforeInfoTarget); logger.AssertExpectedErrorCount(0); }
public void Roslyn_TargetExecutionOrder() { // Arrange string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs"); string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs"); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.SonarQubeTempPath = rootInputFolder; properties.SonarQubeOutputPath = rootInputFolder; properties.SonarQubeConfigPath = rootOutputFolder; ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, properties); // Add some settings we expect to be ignored AddAnalysisSetting("sonar.other.setting", "other value", projectRoot); projectRoot.Save(); BuildLogger logger = new BuildLogger(); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.DefaultBuildTarget); // Assert // Checks that should succeed irrespective of the MSBuild version BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget); logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); // Note: use VS2013 to run this test using MSBuild 12.0. // Use VS2015 to run this test using MSBuild 14.0. if (result.ProjectStateAfterBuild.ToolsVersion.CompareTo("14.0") < 0) { logger.AssertTargetNotExecuted(TargetConstants.ResolveCodeAnalysisRuleSet); // sanity-check: should only be in MSBuild 14.0+ Assert.Inconclusive("This test requires MSBuild 14.0 to be installed. Version used: {0}", result.ProjectStateAfterBuild.ToolsVersion); } else { // MSBuild 14.0+ checks logger.AssertExpectedTargetOrdering( TargetConstants.ResolveCodeAnalysisRuleSet, TargetConstants.CategoriseProjectTarget, TargetConstants.OverrideRoslynAnalysisTarget, TargetConstants.SetRoslynAnalysisPropertiesTarget, TargetConstants.CoreCompile, TargetConstants.DefaultBuildTarget, TargetConstants.SetRoslynResultsTarget, TargetConstants.WriteProjectDataTarget); } }
public void Roslyn_Settings_ValidSetup_MergeWithExistingSettings() { // Arrange BuildLogger logger = new BuildLogger(); // Set the ruleset property WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.ResolvedCodeAnalysisRuleset = "c:\\existing.ruleset"; // Add some existing analyzer settings ProjectRootElement projectRoot = CreateValidProjectSetup(properties); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "Analyzer1.dll"); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\Analyzer2.dll"); // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget); // Assert logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); logger.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); logger.AssertTaskExecuted(TargetConstants.MergeResultSetsTask); BuildAssertions.AssertTargetSucceeded(result, TargetConstants.OverrideRoslynAnalysisTarget); // Check the error log and ruleset properties are set string finalRulesetFilePath = GetDummyRulesetFilePath(); this.TestContext.AddResultFile(finalRulesetFilePath); string targetDir = result.ProjectStateAfterBuild.GetPropertyValue(TargetProperties.TargetDir); string expectedErrorLog = Path.Combine(targetDir, ErrorLogFileName); AssertExpectedAnalysisProperties(result, expectedErrorLog, finalRulesetFilePath); RuleSetAssertions.AssertExpectedIncludeFiles(finalRulesetFilePath, "c:\\existing.ruleset"); RuleSetAssertions.AssertExpectedIncludeAction(finalRulesetFilePath, "c:\\existing.ruleset", RuleSetAssertions.DefaultActionValue); }
public void Roslyn_Settings_TempFolderIsNotSet() { // Arrange BuildLogger logger = new BuildLogger(); WellKnownProjectProperties properties = new WellKnownProjectProperties(); properties.ErrorLog = "pre-existing.log"; properties.ResolvedCodeAnalysisRuleset = "pre-existing.ruleset"; ProjectRootElement projectRoot = CreateValidProjectSetup(properties); projectRoot.AddProperty(TargetProperties.SonarQubeTempPath, string.Empty); // needs to overwritten once the valid project has been created // Act BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget); // Assert logger.AssertTargetNotExecuted(TargetConstants.OverrideRoslynAnalysisTarget); logger.AssertTargetNotExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); AssertExpectedAnalysisProperties(result, "pre-existing.log", "pre-existing.ruleset"); // existing properties should not be changed }
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 = TestUtils.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()); }
public void ImportsBefore_AutoImport_NotAutoImported() { // 0. Set up WellKnownProjectProperties preImportProperties; string testDir = TestUtils.EnsureTestSpecificFolder(this.TestContext); string configFilePath = EnsureDummyAnalysisConfigFileExists(testDir); // 1. Temp path is set -> not auto-imported preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = "foo"; preImportProperties.TeamBuild2105BuildDirectory = testDir; preImportProperties.TeamBuildLegacyBuildDirectory = ""; preImportProperties.SonarQubeTargetsPath = "shouldn't matter if this is set"; // Act ProjectInstance projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.AutoImportProperty); // 2. TeamBuild paths are not set -> not auto-imported preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = ""; preImportProperties.TeamBuild2105BuildDirectory = ""; preImportProperties.TeamBuildLegacyBuildDirectory = ""; preImportProperties.SonarQubeTargetsPath = "shouldn't matter if this is set"; // Act projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.AutoImportProperty); // 3. File does not exist -> not auto-imported File.Delete(configFilePath); preImportProperties = new WellKnownProjectProperties(); preImportProperties.SonarQubeTempPath = ""; preImportProperties.TeamBuild2105BuildDirectory = testDir; preImportProperties.TeamBuildLegacyBuildDirectory = ""; preImportProperties.SonarQubeTargetsPath = "shouldn't matter if this is set"; // Act projectInstance = this.CreateAndEvaluateProject(preImportProperties); // Assert BuildAssertions.AssertPropertyDoesNotExist(projectInstance, TargetProperties.AutoImportProperty); }