private void CheckMergedRulesetFile(GetAnalyzerSettings executedTask, string originalRulesetFullPath)
{
var expectedMergedRulesetFilePath = RuleSetAssertions.CheckMergedRulesetFile(executedTask.ProjectSpecificConfigDirectory, originalRulesetFullPath);
TestContext.AddResultFile(expectedMergedRulesetFilePath);
executedTask.RuleSetFilePath.Should().Be(expectedMergedRulesetFilePath);
}
public void MergeRulesets_IncludeRulesets_RelativePaths()
{
// Arrange
var absoluteRulesetPath = CreateValidRuleset("relative.ruleset");
var projectDir = Path.GetDirectoryName(absoluteRulesetPath);
string mergedRuleset;
// 1. Relative ruleset path that can be resolved -> included
var primaryRuleset = CreateValidRuleset("found.relative.ruleset.txt");
mergedRuleset = ExecuteAndCheckSuccess(projectDir, primaryRuleset, "relative.ruleset");
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset, absoluteRulesetPath);
// 1. Relative ruleset path that can be resolved -> included
primaryRuleset = CreateValidRuleset("found.relative2.ruleset.txt");
mergedRuleset = ExecuteAndCheckSuccess(projectDir, primaryRuleset,
".\\relative.ruleset", // should be resolved correctly...
".\\.\\relative.ruleset"); // ... but only added once.
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset, absoluteRulesetPath);
// 2. Relative ruleset path that cannot be resolved -> not included
primaryRuleset = CreateValidRuleset("not.found.relative.ruleset.txt");
mergedRuleset = ExecuteAndCheckSuccess(projectDir, primaryRuleset, "not.found\\relative.ruleset");
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset /* ruleset should not have been resolved */);
}
public void MergeRulesets_ExistingInclude()
{
// Arrange
var testDir = TestUtils.CreateTestSpecificFolder(TestContext);
var primaryRuleset = TestUtils.CreateTextFile(testDir, "existing.ruleset.txt",
@"<?xml version=""1.0"" encoding=""utf-8""?>
<RuleSet Name=""RulesetName"" ToolsVersion=""14.0"">
<Include Path=""d:\error.include.ruleset"" Action=""Error"" />
<Include Path=""d:\info.include.ruleset"" Action=""Info"" />
<Include Path=""d:\warning.include.ruleset"" Action=""Warning"" />
<Include Path=""d:\default.include.ruleset"" Action=""Default"" />
<Rules AnalyzerId=""My.Analyzer"" RuleNamespace=""My.Analyzers"">
<Rule Id=""Rule002"" Action=""Error"" />
</Rules>
</RuleSet>
");
// Act
var mergedRuleset = ExecuteAndCheckSuccess(testDir, primaryRuleset,
"d:\\error.include.ruleset",
"d:\\info.include.ruleset",
"d:\\warning.include.ruleset",
"d:\\default.include.ruleset");
// Assert
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset,
// Action value should be "Warning" for all included rulesets
"d:\\error.include.ruleset",
"d:\\info.include.ruleset",
"d:\\warning.include.ruleset",
"d:\\default.include.ruleset");
}
public void MergeRulesets_EmptyRuleset()
{
// Arrange
var testDir = TestUtils.CreateTestSpecificFolder(TestContext);
var primaryRuleset = TestUtils.CreateTextFile(testDir, "empty.ruleset.txt",
@"<RuleSet Name = 'RulesetName' ToolsVersion = '14.0' />");
// Act
var mergedRuleset = ExecuteAndCheckSuccess(testDir, primaryRuleset, "c:\\foo\\added.ruleset");
// Assert
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset, "c:\\foo\\added.ruleset");
}
public void MergeRulesets_EmptyRuleset()
{
// Arrange
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string primaryRuleset = TestUtils.CreateTextFile(testDir, "empty.ruleset.txt",
@"<RuleSet Name = 'RulesetName' ToolsVersion = '14.0' />");
// Act
ExecuteAndCheckSuccess(primaryRuleset, "c:\\foo\\added.ruleset");
// Assert
RuleSetAssertions.AssertExpectedIncludeFiles(primaryRuleset, "c:\\foo\\added.ruleset");
}
public void MergeRulesets_ExistingInclude()
{
// Arrange
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string primaryRuleset = TestUtils.CreateTextFile(testDir, "existing.ruleset.txt",
@"<?xml version=""1.0"" encoding=""utf-8""?>
<RuleSet Name=""RulesetName"" ToolsVersion=""14.0"">
<Include Path=""d:\include1.ruleset"" Action=""Error"" />
<Rules AnalyzerId=""My.Analyzer"" RuleNamespace=""My.Analyzers"">
<Rule Id=""Rule002"" Action=""Error"" />
</Rules>
</RuleSet>
");
// Act
ExecuteAndCheckSuccess(primaryRuleset, "d:\\include1.ruleset");
// Assert
RuleSetAssertions.AssertExpectedIncludeFiles(primaryRuleset, "d:\\include1.ruleset");
RuleSetAssertions.AssertExpectedIncludeAction(primaryRuleset, "d:\\include1.ruleset", ErrorActionValue); // action value should still be Error
}
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 MergeRulesets_IncludeRulesets_AbsolutePaths()
{
// Arrange
var projectDir = TestContext.TestDeploymentDir;
string mergedRuleset;
// 1. No included rulesets
var primaryRuleset = CreateValidRuleset("no-added-includes.ruleset.txt");
mergedRuleset = ExecuteAndCheckSuccess(projectDir, primaryRuleset);
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset /* no included files*/);
// 2. Adding includes
primaryRuleset = CreateValidRuleset("added-includes1.ruleset.txt");
mergedRuleset = ExecuteAndCheckSuccess(projectDir, primaryRuleset, "c:\\include1.ruleset");
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset, "c:\\include1.ruleset");
// 3. Adding an include that already exists
primaryRuleset = CreateValidRuleset("added-includes.existing.ruleset.txt");
var rulesetWithExistingInclude = ExecuteAndCheckSuccess(projectDir, primaryRuleset, "c:\\include1.ruleset", "c:\\include2.ruleset"); // create a file with includes
mergedRuleset = ExecuteAndCheckSuccess(projectDir, rulesetWithExistingInclude, "c:\\include1.ruleset", "c:\\INCLUDE2.RULESET", "c:\\include3.ruleset"); // add the same includes again with one extra
RuleSetAssertions.AssertExpectedIncludeFilesAndDefaultAction(mergedRuleset, "c:\\include1.ruleset", "c:\\include2.ruleset", "c:\\include3.ruleset");
}
public void MergeRulesets_IncludeRulesets()
{
// 1. No included rulesets
string primaryRuleset = this.CreateValidRuleset("no-added-includes.ruleset.txt");
ExecuteAndCheckSuccess(primaryRuleset);
RuleSetAssertions.AssertExpectedIncludeFiles(primaryRuleset /* no included files*/);
// 2. Adding includes
primaryRuleset = this.CreateValidRuleset("added-includes1.ruleset.txt");
ExecuteAndCheckSuccess(primaryRuleset, "include1.ruleset");
RuleSetAssertions.AssertExpectedIncludeFiles(primaryRuleset, "include1.ruleset");
RuleSetAssertions.AssertExpectedIncludeAction(primaryRuleset, "include1.ruleset", RuleSetAssertions.DefaultActionValue);
// 3. Adding an include that already exists
primaryRuleset = this.CreateValidRuleset("added-includes.existing.ruleset.txt");
ExecuteAndCheckSuccess(primaryRuleset, "include1.ruleset", "include2.ruleset"); // create a file with incldues
ExecuteAndCheckSuccess(primaryRuleset, "include1.ruleset", "INCLUDE2.RULESET", "include3.ruleset"); // add the same includes again with one extra
RuleSetAssertions.AssertExpectedIncludeFiles(primaryRuleset, "include1.ruleset", "include2.ruleset", "include3.ruleset");
RuleSetAssertions.AssertExpectedIncludeAction(primaryRuleset, "include1.ruleset", RuleSetAssertions.DefaultActionValue);
RuleSetAssertions.AssertExpectedIncludeAction(primaryRuleset, "include2.ruleset", RuleSetAssertions.DefaultActionValue);
RuleSetAssertions.AssertExpectedIncludeAction(primaryRuleset, "include3.ruleset", RuleSetAssertions.DefaultActionValue);
}
public void Roslyn_Settings_ValidSetup_NonLegacyServer_MergeSettings()
{
// Arrange
var dir = TestUtils.CreateTestSpecificFolder(TestContext);
var dummyQpRulesetPath = TestUtils.CreateValidEmptyRuleset(dir, "dummyQp");
// Create a valid config containing analyzer settings
var config = new AnalysisConfig
{
SonarQubeVersion = "7.5", // non-legacy version
ServerSettings = new AnalysisProperties
{
new Property {
Id = "sonar.cs.roslyn.ignoreIssues", Value = "false"
}
},
AnalyzersSettings = new List <AnalyzerSettings>
{
new AnalyzerSettings
{
Language = "cs",
RuleSetFilePath = dummyQpRulesetPath,
AnalyzerPlugins = new List <AnalyzerPlugin>
{
CreateAnalyzerPlugin("c:\\data\\new\\analyzer1.dll", "c:\\new.analyzer2.dll")
},
AdditionalFilePaths = new List <string> {
"c:\\config\\duplicate.1.txt", "c:\\duplicate.2.txt"
}
}
}
};
var testSpecificProjectXml = @"
<PropertyGroup>
<ResolvedCodeAnalysisRuleSet>c:\original.ruleset</ResolvedCodeAnalysisRuleSet>
<Language>C#</Language>
</PropertyGroup>
<ItemGroup>
<!-- all analyzers specified in the project file should be preserved -->
<Analyzer Include='c:\original\should.be.removed\analyzer1.dll' />
<Analyzer Include='original\should.be.preserved\analyzer3.dll' />
</ItemGroup>
<ItemGroup>
<!-- These additional files don't match ones in the config and should be preserved -->
<AdditionalFiles Include='should.not.be.removed.additional1.txt' />
<AdditionalFiles Include='should.not.be.removed.additional2.txt' />
<!-- This additional file matches one in the config and should be replaced -->
<AdditionalFiles Include='d:/should.be.removed/DUPLICATE.1.TXT' />
<AdditionalFiles Include='d:\should.be.removed\duplicate.2.TXT' />
</ItemGroup>
";
var projectFilePath = CreateProjectFile(config, testSpecificProjectXml);
// Act
var result = BuildRunner.BuildTargets(TestContext, projectFilePath, TargetConstants.OverrideRoslynAnalysisTarget);
// Assert
result.AssertTargetExecuted(TargetConstants.CreateProjectSpecificDirs);
result.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget);
result.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget);
result.BuildSucceeded.Should().BeTrue();
// Check the error log and ruleset properties are set
AssertErrorLogIsSetBySonarQubeTargets(result);
var actualProjectSpecificConfFolder = result.GetCapturedPropertyValue(TargetProperties.ProjectSpecificConfDir);
Directory.Exists(actualProjectSpecificConfFolder).Should().BeTrue();
var expectedMergedRuleSetFilePath = Path.Combine(actualProjectSpecificConfFolder, "merged.ruleset");
AssertExpectedResolvedRuleset(result, expectedMergedRuleSetFilePath);
RuleSetAssertions.CheckMergedRulesetFile(actualProjectSpecificConfFolder,
@"c:\original.ruleset");
AssertExpectedAdditionalFiles(result,
result.GetCapturedPropertyValue(TargetProperties.ProjectConfFilePath),
"should.not.be.removed.additional1.txt",
"should.not.be.removed.additional2.txt",
"c:\\config\\duplicate.1.txt",
"c:\\duplicate.2.txt");
AssertExpectedAnalyzers(result,
"c:\\data\\new\\analyzer1.dll",
"c:\\new.analyzer2.dll",
"original\\should.be.preserved\\analyzer3.dll");
AssertWarningsAreNotTreatedAsErrorsNorIgnored(result);
}
