public void Roslyn_Settings_ValidSetup()
{
// Arrange
BuildLogger logger = new BuildLogger();
ProjectRootElement projectRoot = CreateValidProjectSetup(null);
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget);
// Assert
logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget);
logger.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget);
logger.AssertTaskNotExecuted(TargetConstants.MergeResultSetsTask);
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");
// Check the error log and ruleset properties are set
string targetDir = result.ProjectStateAfterBuild.GetPropertyValue(TargetProperties.TargetDir);
string expectedErrorLog = Path.Combine(targetDir, ErrorLogFileName);
AssertExpectedAnalysisProperties(result, expectedErrorLog, GetDummyRulesetFilePath());
AssertExpectedAnalyzersExists(result, GetSonarLintAnalyzerFilePaths());
}
public void Roslyn_Settings_Analyzer_AssemblyDoesNotExist()
{
// Arrange
BuildLogger logger = new BuildLogger();
ProjectRootElement projectRoot = CreateValidProjectSetup(null);
this.DeleteDummySonarLintFiles();
// The downloaded SonarLint.dll could not be found so any existing settings should be preserved
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "analyzer1.dll");
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\myfolder\\analyzer2.dll");
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\myfolder\\sonarlint.dll");
// 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", "false");
// Check the analyzer properties are set as expected
AssertExpectedAnalyzersExists(result,
"analyzer1.dll",
"c:\\myfolder\\analyzer2.dll",
"c:\\myfolder\\sonarlint.dll");
}
public void ImportsBefore_SonarQubeTargetsPathNotSet()
{
// 1. Prebuild
// Arrange
var projectXml = @"
<PropertyGroup>
<SonarQubeTargetsPath />
<AGENT_BUILDDIRECTORY />
<TF_BUILD_BUILDDIRECTORY />
</PropertyGroup>
";
var projectFilePath = CreateProjectFile(projectXml);
// Act
var projectInstance = CreateAndEvaluateProject(projectFilePath);
// 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);
}
/// <summary>
/// Creates and builds a new Sonar-enabled project using the supplied descriptor.
/// The method will check the build succeeded and that a single project output file was created.
/// </summary>
/// <returns>The full path of the project-specsific directory that was created during the build</returns>
private string CreateAndBuildSonarProject(ProjectDescriptor descriptor, string rootOutputFolder, WellKnownProjectProperties preImportProperties)
{
ProjectRootElement projectRoot = BuildUtilities.CreateInitializedProjectRoot(this.TestContext, descriptor, preImportProperties);
BuildLogger logger = new BuildLogger();
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger);
// Assert
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget);
// We expect the compiler to warn if there are no compiler inputs
int expectedWarnings = (descriptor.ManagedSourceFiles == null || !descriptor.ManagedSourceFiles.Any()) ? 1 : 0;
logger.AssertExpectedErrorCount(0);
logger.AssertExpectedWarningCount(expectedWarnings);
logger.AssertExpectedTargetOrdering(TargetConstants.CoreCompileTarget,
TargetConstants.CalculateSonarQubeFileListsTarget,
TargetConstants.DefaultBuildTarget,
TargetConstants.WriteProjectDataTarget);
// Check expected folder structure exists
CheckRootOutputFolder(rootOutputFolder);
// Check expected project outputs
Assert.AreEqual(1, Directory.EnumerateDirectories(rootOutputFolder).Count(), "Only expecting one child directory to exist under the root analysis output folder");
ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath);
return(Directory.EnumerateDirectories(rootOutputFolder).Single());
}
public void IntTargets_SonarPaths_OutputAndConfigPathsAreSet()
{
// The SonarQubeTempPath and TeamBuild paths should be ignored if the output and config are set explicitly
// Arrange
string projectXml = $@"
<PropertyGroup>
<SonarQubeOutputPath>c:\output</SonarQubeOutputPath>
<SonarQubeConfigPath>c:\config</SonarQubeConfigPath>
<SonarQubeTempPath>c:\sonarQTemp</SonarQubeTempPath>
<!-- SonarQubeTempPath setting should take precedence -->
<TF_BUILD_BUILDDIRECTORY>t:\Legacy TeamBuildPath\</TF_BUILD_BUILDDIRECTORY>
<AGENT_BUILDDIRECTORY>x:\New TeamBuildPath\</AGENT_BUILDDIRECTORY>
</PropertyGroup>
";
var filePath = CreateProjectFile(null, projectXml);
// Act
var projectInstance = new ProjectInstance(filePath);
// Assert
BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeOutputPath, @"c:\output");
BuildAssertions.AssertExpectedPropertyValue(projectInstance, TargetProperties.SonarQubeConfigPath, @"c:\config");
}
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_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 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 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 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 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");
}
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_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_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 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 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_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 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_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 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_MissingAnalysisTargets()
{
// 1. Prebuild
// Arrange
var projectXml = @"
<PropertyGroup>
<SonarQubeTempPath>nonExistentPath</SonarQubeTempPath>
<MSBuildExtensionsPath>nonExistentPath</MSBuildExtensionsPath>
<AGENT_BUILDDIRECTORY />
<TF_BUILD_BUILDDIRECTORY />
</PropertyGroup>
";
var projectFilePath = CreateProjectFile(projectXml);
// Act
var projectInstance = CreateAndEvaluateProject(projectFilePath);
// 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_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_BuildingInsideVS_NotImported()
{
// 1. Pre-build
// Arrange
var dummySonarTargetsDir = EnsureDummyIntegrationTargetsFileExists();
var projectXml = $@"
<PropertyGroup>
<SonarQubeTempPath>{Path.GetTempPath()}</SonarQubeTempPath>
<SonarQubeTargetsPath>{Path.GetDirectoryName(dummySonarTargetsDir)}</SonarQubeTargetsPath>
<BuildingInsideVisualStudio>tRuE</BuildingInsideVisualStudio>
</PropertyGroup>
";
var projectFilePath = CreateProjectFile(projectXml);
// Act
var projectInstance = CreateAndEvaluateProject(projectFilePath);
// 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 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);
}
/// <summary>
/// Executes the WriteProjectInfoFile target in the the supplied project.
/// The method will check the build succeeded and that a single project
/// output file was created.
/// </summary>
/// <returns>The project info file that was created during the build</returns>
private ProjectInfo ExecuteWriteProjectInfo(ProjectRootElement projectRoot, string rootOutputFolder, bool noWarningOrErrors = true)
{
projectRoot.Save();
BuildLogger logger = new BuildLogger();
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger,
// The "write" target depends on a couple of other targets having executed first to set properties appropriately
TargetConstants.CategoriseProjectTarget,
TargetConstants.CalculateFilesToAnalyzeTarget,
TargetConstants.CreateProjectSpecificDirs,
TargetConstants.WriteProjectDataTarget);
// Assert
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.CalculateFilesToAnalyzeTarget);
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.CreateProjectSpecificDirs);
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.WriteProjectDataTarget);
logger.AssertTargetExecuted(TargetConstants.WriteProjectDataTarget);
if (noWarningOrErrors)
{
logger.AssertNoWarningsOrErrors();
}
// Check expected project outputs
Assert.AreEqual(1, Directory.EnumerateDirectories(rootOutputFolder).Count(), "Only expecting one child directory to exist under the root analysis output folder");
ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath);
return(projectInfo);
}
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");
}
private void AssertExpectedItemValuesExists(BuildResult result, string itemType, params string[] expectedValues)
{
this.DumpLists(result, itemType, expectedValues);
foreach (string expectedValue in expectedValues)
{
BuildAssertions.AssertSingleItemExists(result, itemType, expectedValue);
}
BuildAssertions.AssertExpectedItemGroupCount(result, itemType, expectedValues.Length);
}
private void AssertExpectedAnalyzersExists(BuildResult result, params string[] analyzerFilePaths)
{
this.DumpAnalyzerLists(result, analyzerFilePaths);
foreach (string filePath in analyzerFilePaths)
{
BuildAssertions.AssertSingleItemExists(result, TargetProperties.AnalyzerItemType, filePath);
}
BuildAssertions.AssertExpectedItemGroupCount(result, TargetProperties.AnalyzerItemType, analyzerFilePaths.Length);
}
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);
}