public void RuleSetUpdater_FindAllIncludesUnderRoot()
{
// Arrange
const string slnRoot = @"X:\SolutionDir\";
string projectRoot = Path.Combine(slnRoot, @"Project\");
string sonarRoot = Path.Combine(slnRoot, @"Sonar\");
string commonRoot = Path.Combine(slnRoot, @"Common\");
const string sonarRs1FileName = "Sonar1.ruleset";
const string sonarRs2FileName = "Sonar2.ruleset";
const string projectRsBaseFileName = "ProjectBase.ruleset";
const string commonRs1FileName = "SolutionCommon1.ruleset";
const string commonRs2FileName = "SolutionCommon2.ruleset";
var sonarRs1 = TestRuleSetHelper.CreateTestRuleSet(sonarRoot, sonarRs1FileName);
var sonarRs2 = TestRuleSetHelper.CreateTestRuleSet(sonarRoot, sonarRs2FileName);
var projectBaseRs = TestRuleSetHelper.CreateTestRuleSet(projectRoot, projectRsBaseFileName);
var commonRs1 = TestRuleSetHelper.CreateTestRuleSet(commonRoot, commonRs1FileName);
var commonRs2 = TestRuleSetHelper.CreateTestRuleSet(commonRoot, commonRs2FileName);
var inputRuleSet = TestRuleSetHelper.CreateTestRuleSet(projectRoot, "test.ruleset");
AddRuleSetInclusion(inputRuleSet, projectBaseRs, useRelativePath: true);
AddRuleSetInclusion(inputRuleSet, commonRs1, useRelativePath: true);
AddRuleSetInclusion(inputRuleSet, commonRs2, useRelativePath: false);
var expected1 = AddRuleSetInclusion(inputRuleSet, sonarRs1, useRelativePath: true);
var expected2 = AddRuleSetInclusion(inputRuleSet, sonarRs2, useRelativePath: false);
// Act
RuleSetInclude[] actual = RuleSetUpdater.FindAllIncludesUnderRoot(inputRuleSet, sonarRoot).ToArray();
// Assert
CollectionAssert.AreEquivalent(new[] { expected1, expected2 }, actual);
}
private static RuleConflictInfo CreateConflictsBasedOnNumberOfCalls(int findConflictCalls)
{
RuleSet temp = TestRuleSetHelper.CreateTestRuleSet(2);
Dictionary <RuleReference, RuleAction> map = new Dictionary <RuleReference, RuleAction>();
switch (findConflictCalls)
{
case 1:
return(new RuleConflictInfo()); // No conflicts
case 2:
return(new RuleConflictInfo(temp.Rules)); // Missing rules
case 3:
map[temp.Rules[0]] = RuleAction.Error;
return(new RuleConflictInfo(map)); // Weakened rules
case 4:
map[temp.Rules[0]] = RuleAction.Error;
return(new RuleConflictInfo(temp.Rules.Skip(1), map)); // One of each
default:
FluentAssertions.Execution.Execute.Assertion.FailWith("Called unexpected number of times");
return(null);
}
}
public void HasInclude_RelativePaths()
{
// Arrange
var target = TestRuleSetHelper.CreateTestRuleSet(@"c:\aaa\Solution\SomeFolder\fullFilePath.ruleset");
var relativeInclude = @"Solution\SomeFolder\fullFilePath.ruleset".ToLowerInvariant(); // Catch casing errors
var sourceWithRelativeInclude = TestRuleSetHelper.CreateTestRuleSetWithIncludes(@"c:\aaa\fullFilePath.ruleset",
relativeInclude, "otherInclude.ruleset");
// Alternative directory separator, different relative path format
var relativeInclude2 = @"./Solution/SomeFolder/fullFilePath.ruleset";
var sourceWithRelativeInclude2 = TestRuleSetHelper.CreateTestRuleSetWithIncludes(@"c:\aaa\fullFilePath.ruleset",
"c://XXX/Solution/SomeFolder/another.ruleset", relativeInclude2);
// Case 1: Relative include
// Act
var hasInclude = RuleSetIncludeChecker.HasInclude(sourceWithRelativeInclude, target);
// Assert
hasInclude.Should().BeTrue();
// Case 2: Relative include, alternative path separators
// Act
hasInclude = RuleSetIncludeChecker.HasInclude(sourceWithRelativeInclude2, target);
// Assert
hasInclude.Should().BeTrue();
}
public async Task GetConfig_LegacyMode_WithNoNugetPackage_Fails()
{
// Arrange
const string QualityProfileName = "SQQualityProfileName";
const string ProjectName = "SQProjectName";
var legacyNuGetBinding = new NuGetBindingOperation(new ConfigurableHost(), this.logger);
var testSubject = this.CreateTestSubject("key", ProjectName, legacyNuGetBinding);
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(new[] { "Key1", "Key2" });
var additionalFiles = new[] { new AdditionalFileResponse {
FileName = "abc.xml", Content = new byte[] { 1, 2, 3 }
} };
RoslynExportProfileResponse export = RoslynExportProfileHelper.CreateExport(ruleSet, Enumerable.Empty <PackageName>(), additionalFiles);
var language = Language.VBNET;
var profile = this.ConfigureProfileExport(export, language, QualityProfileName);
// Act
var result = await testSubject.GetConfigurationAsync(profile, null, language, CancellationToken.None)
.ConfigureAwait(false);
// Assert
result.Should().BeNull();
this.logger.AssertOutputStrings(1);
var expectedOutput = string.Format(Strings.SubTextPaddingFormat,
string.Format(Strings.NoNuGetPackageForQualityProfile, language.Name));
this.logger.AssertOutputStrings(expectedOutput);
}
public async Task GetConfig_WithNoActiveRules_Fails()
{
// Arrange
const string QualityProfileName = "SQQualityProfileName";
const string ProjectName = "SQProjectName";
var testSubject = this.CreateTestSubject(ProjectName, "http://connected");
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(new[] { "Key1", "Key2" });
foreach (var rule in ruleSet.Rules)
{
rule.Action = RuleAction.None;
}
var nugetPackages = new[] { new PackageName("myPackageId", new SemanticVersion("1.0.0")) };
var additionalFiles = new[] { new AdditionalFileResponse {
FileName = "abc.xml", Content = new byte[] { 1, 2, 3 }
} };
RoslynExportProfileResponse export = RoslynExportProfileHelper.CreateExport(ruleSet, nugetPackages, additionalFiles);
var language = Language.VBNET;
var profile = this.ConfigureProfileExport(export, language, QualityProfileName);
// Act
var result = await testSubject.GetConfigurationAsync(profile, null, language, CancellationToken.None)
.ConfigureAwait(false);
// Assert
result.Should().BeNull();
this.logger.AssertOutputStrings(1);
var expectedOutput = string.Format(Strings.SubTextPaddingFormat,
string.Format(Strings.NoSonarAnalyzerActiveRulesForQualityProfile, QualityProfileName, language.Name));
this.logger.AssertOutputStrings(expectedOutput);
}
public async Task BindingWorkflow_DownloadQualityProfile_WithNoRules_Fails()
{
// Arrange
const string QualityProfileName = "SQQualityProfileName";
const string ProjectName = "SQProjectName";
BindingWorkflow testSubject = this.CreateTestSubject("key", ProjectName);
ConfigurableProgressController controller = new ConfigurableProgressController();
var notifications = new ConfigurableProgressStepExecutionEvents();
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(Enumerable.Empty <string>());
var nugetPackages = new[] { new PackageName("myPackageId", new SemanticVersion("1.0.0")) };
var additionalFiles = new[] { new AdditionalFileResponse {
FileName = "abc.xml", Content = new byte[] { 1, 2, 3 }
} };
RoslynExportProfileResponse export = RoslynExportProfileHelper.CreateExport(ruleSet, nugetPackages, additionalFiles);
var language = Language.VBNET;
SonarQubeQualityProfile profile = this.ConfigureProfileExport(export, language, QualityProfileName);
// Act
await testSubject.DownloadQualityProfileAsync(controller, notifications, new[] { language }, CancellationToken.None);
// Assert
testSubject.Rulesets.Should().NotContainKey(Language.VBNET, "Not expecting any rules for this language");
testSubject.Rulesets.Should().NotContainKey(language, "Not expecting any rules");
controller.NumberOfAbortRequests.Should().Be(1);
notifications.AssertProgressMessages(Strings.DownloadingQualityProfileProgressMessage);
this.outputWindowPane.AssertOutputStrings(1);
var expectedOutput = string.Format(Strings.SubTextPaddingFormat,
string.Format(Strings.NoSonarAnalyzerActiveRulesForQualityProfile, QualityProfileName, language.Name));
this.outputWindowPane.AssertOutputStrings(expectedOutput);
}
private static void AssertConfigSectionEqual(Configuration expected, Configuration actual)
{
CollectionAssert.AreEqual(expected.AdditionalFiles, actual.AdditionalFiles, "Additional files differ");
RuleSet expectedRuleSet = TestRuleSetHelper.XmlToRuleSet(expected.RuleSet.OuterXml);
RuleSet actualRuleSet = TestRuleSetHelper.XmlToRuleSet(actual.RuleSet.OuterXml);
RuleSetAssert.AreEqual(expectedRuleSet, actualRuleSet, "Rule sets differ");
}
private static void AssertConfigSectionEqual(ConfigurationResponse expected, ConfigurationResponse actual)
{
actual.AdditionalFiles.Should().BeEquivalentTo(expected.AdditionalFiles, "Additional files differ");
RuleSet expectedRuleSet = TestRuleSetHelper.XmlToRuleSet(expected.RuleSet.OuterXml);
RuleSet actualRuleSet = TestRuleSetHelper.XmlToRuleSet(actual.RuleSet.OuterXml);
RuleSetAssert.AreEqual(expectedRuleSet, actualRuleSet, "Rule sets differ");
}
public void RuleSetSerializer_WriteRuleSetFile_ArgChecks()
{
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSet(this.TestContext.TestRunDirectory, this.TestContext.TestName + ".ruleset");
Exceptions.Expect <ArgumentNullException>(() => this.testSubject.WriteRuleSetFile(null, @"c:\file.ruleSet"));
Exceptions.Expect <ArgumentNullException>(() => this.testSubject.WriteRuleSetFile(ruleSet, null));
Exceptions.Expect <ArgumentNullException>(() => this.testSubject.WriteRuleSetFile(ruleSet, ""));
Exceptions.Expect <ArgumentNullException>(() => this.testSubject.WriteRuleSetFile(ruleSet, "\t\n"));
}
private RuleSet CreateCommonRuleSet(string ruleSetFileName = "SonarQube.ruleset", RuleAction defaultAction = RuleAction.Warning, int rules = DefaultNumberOfRules)
{
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSet(rules);
ruleSet.Rules.ToList().ForEach(r => r.Action = defaultAction);
ruleSet.FilePath = Path.Combine(this.SonarQubeRuleSetFolder, ruleSetFileName);
ruleSet.WriteToFile(ruleSet.FilePath);
this.temporaryFiles.AddFile(ruleSet.FilePath, false);
return(ruleSet);
}
public static ProjectRuleSetConflict CreateConflict(string projectFilePath = "project.csproj", string baselineRuleSet = "baseline.ruleset", string projectRuleSet = "project.csproj", int numberOfConflictingRules = 1)
{
IEnumerable <string> ids = Enumerable.Range(0, numberOfConflictingRules).Select(i => "id" + i);
var ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(ids);
var conflict = new ProjectRuleSetConflict(
new RuleConflictInfo(ruleSet.Rules, new Dictionary <RuleReference, RuleAction>()),
new RuleSetInformation(projectFilePath, baselineRuleSet, projectRuleSet, null));
return(conflict);
}
public void HasInclude_NoIncludes()
{
// Arrange
var ruleSet = TestRuleSetHelper.CreateTestRuleSet(@"c:\Solution\SomeFolder\fullFilePath.ruleset");
var unreferencedRuleset = TestRuleSetHelper.CreateTestRuleSet(@"c:\unreferenced.ruleset");
// Act No includes at all
var include = RuleSetIncludeChecker.HasInclude(ruleSet, unreferencedRuleset);
// Assert
include.Should().BeFalse();
}
private RuleSet CreateVsRuleSet(int rules, string ruleSetFileName, RuleAction defaultAction = RuleAction.Warning)
{
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSet(rules);
ruleSet.Rules.ToList().ForEach(r => r.Action = defaultAction);
ruleSet.FilePath = Path.Combine(this.VsRuleSetsDirectory, ruleSetFileName);
ruleSet.WriteToFile(ruleSet.FilePath);
this.temporaryFiles.AddFile(ruleSet.FilePath, false);
return(ruleSet);
}
public void ToRuleSet_DumpsContentToRuleSetFileAndLoadsIt()
{
// Arrange
var ruleset = TestRuleSetHelper.CreateTestRuleSet(numRules: 10);
var roslynProfileExporter = RoslynExportProfileHelper.CreateExport(ruleset);
// Act
var result = RulesHelper.ToRuleSet(roslynProfileExporter);
// Assert
TestRuleSetHelper.RuleSetToXml(result).Should().Be(TestRuleSetHelper.RuleSetToXml(ruleset));
}
public async Task BindingWorkflow_DownloadQualityProfile_Success()
{
// Arrange
const string QualityProfileName = "SQQualityProfileName";
const string ProjectName = "SQProjectName";
// Record all of the calls to NuGetBindingOperation.ProcessExport
var actualProfiles = new List <Tuple <Language, RoslynExportProfileResponse> >();
Mock <INuGetBindingOperation> nuGetOpMock = new Mock <INuGetBindingOperation>();
nuGetOpMock.Setup(x => x.ProcessExport(It.IsAny <Language>(), It.IsAny <RoslynExportProfileResponse>()))
.Callback <Language, RoslynExportProfileResponse>((l, r) => actualProfiles.Add(new Tuple <Language, RoslynExportProfileResponse>(l, r)))
.Returns(true);
BindingWorkflow testSubject = this.CreateTestSubject("key", ProjectName, nuGetOpMock.Object);
ConfigurableProgressController controller = new ConfigurableProgressController();
var notifications = new ConfigurableProgressStepExecutionEvents();
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(new[] { "Key1", "Key2" });
var expectedRuleSet = new RuleSet(ruleSet)
{
NonLocalizedDisplayName = string.Format(Strings.SonarQubeRuleSetNameFormat, ProjectName, QualityProfileName),
NonLocalizedDescription = "\r\nhttp://connected/profiles/show?key="
};
var nugetPackages = new[] { new PackageName("myPackageId", new SemanticVersion("1.0.0")) };
var additionalFiles = new[] { new AdditionalFileResponse {
FileName = "abc.xml", Content = new byte[] { 1, 2, 3 }
} };
RoslynExportProfileResponse export = RoslynExportProfileHelper.CreateExport(ruleSet, nugetPackages, additionalFiles);
var language = Language.VBNET;
SonarQubeQualityProfile profile = this.ConfigureProfileExport(export, language, QualityProfileName);
// Act
await testSubject.DownloadQualityProfileAsync(controller, notifications, new[] { language }, CancellationToken.None);
// Assert
RuleSetAssert.AreEqual(expectedRuleSet, testSubject.Rulesets[language], "Unexpected rule set");
testSubject.QualityProfiles[language].Should().Be(profile);
VerifyNuGetPackgesDownloaded(nugetPackages, language, actualProfiles);
controller.NumberOfAbortRequests.Should().Be(0);
notifications.AssertProgress(0.0, 1.0);
notifications.AssertProgressMessages(Strings.DownloadingQualityProfileProgressMessage, string.Empty);
this.outputWindowPane.AssertOutputStrings(1);
var expectedOutput = string.Format(Strings.SubTextPaddingFormat,
string.Format(Strings.QualityProfileDownloadSuccessfulMessageFormat, QualityProfileName, string.Empty, language.Name));
this.outputWindowPane.AssertOutputStrings(expectedOutput);
}
public void ToQualityProfile_SelectRulesNotMarkedAsNone()
{
// Arrange
var ruleset = TestRuleSetHelper.CreateTestRuleSet(numRules: 5);
var nonNoneRulesCount = ruleset.Rules.Count(x => x.Action != RuleAction.None);
// Act
var result = RulesHelper.ToQualityProfile(ruleset, Language.CSharp);
// Assert
result.Language.Should().Be(Language.CSharp);
result.Rules.Should().HaveCount(nonNoneRulesCount);
}
public void HasInclude_NoIncludesFromSourceToTarget()
{
// Arrange
var target = TestRuleSetHelper.CreateTestRuleSet(@"c:\Solution\SomeFolder\fullFilePath.ruleset");
var sourceWithInclude = TestRuleSetHelper.CreateTestRuleSetWithIncludes(@"c:\fullFilePath.ruleset",
"include1", "c:\\foo\\include2", "fullFilePath.ruleset");
// Act - No includes from source to target
var include = RuleSetIncludeChecker.HasInclude(sourceWithInclude, target);
// Assert
include.Should().BeFalse();
}
public void BindingWorkflow_DownloadQualityProfile_WithNoActiveRules_Fails()
{
// Arrange
const string QualityProfileName = "SQQualityProfileName";
const string SonarQubeProjectName = "SQProjectName";
var projectInfo = new ProjectInformation {
Key = "key", Name = SonarQubeProjectName
};
BindingWorkflow testSubject = this.CreateTestSubject(projectInfo);
ConfigurableProgressController controller = new ConfigurableProgressController();
var notifications = new ConfigurableProgressStepExecutionEvents();
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(new[] { "Key1", "Key2" });
foreach (var rule in ruleSet.Rules)
{
rule.Action = RuleAction.None;
}
var expectedRuleSet = new RuleSet(ruleSet)
{
NonLocalizedDisplayName = string.Format(Strings.SonarQubeRuleSetNameFormat, SonarQubeProjectName, QualityProfileName),
NonLocalizedDescription = "\r\nhttp://connected/profiles/show?key="
};
var nugetPackages = new[] { new PackageName("myPackageId", new SemanticVersion("1.0.0")) };
var additionalFiles = new[] { new AdditionalFile {
FileName = "abc.xml", Content = new byte[] { 1, 2, 3 }
} };
RoslynExportProfile export = RoslynExportProfileHelper.CreateExport(ruleSet, nugetPackages, additionalFiles);
var language = Language.VBNET;
QualityProfile profile = this.ConfigureProfileExport(export, language);
profile.Name = QualityProfileName;
// Act
testSubject.DownloadQualityProfile(controller, CancellationToken.None, notifications, new[] { language });
// Assert
testSubject.Rulesets.Should().NotContainKey(Language.VBNET, "Not expecting any rules for this language");
testSubject.Rulesets.Should().NotContainKey(language, "Not expecting any rules");
controller.NumberOfAbortRequests.Should().Be(1);
notifications.AssertProgressMessages(Strings.DownloadingQualityProfileProgressMessage);
this.outputWindowPane.AssertOutputStrings(1);
var expectedOutput = string.Format(Strings.SubTextPaddingFormat,
string.Format(Strings.NoSonarAnalyzerActiveRulesForQualityProfile, QualityProfileName, language.Name));
this.outputWindowPane.AssertOutputStrings(expectedOutput);
}
public void HasInclude_AbsolutePaths()
{
// Arrange
var target = TestRuleSetHelper.CreateTestRuleSet(@"c:\Solution\SomeFolder\fullFilePath.ruleset");
var absoluteInclude = target.FilePath.ToUpperInvariant(); // Catch casing errors
var sourceWithAbsoluteInclude = TestRuleSetHelper.CreateTestRuleSetWithIncludes(@"c:\fullFilePath.ruleset",
".\\include1.ruleset", absoluteInclude, "c:\\dummy\\include2.ruleset");
// Act
var hasInclude = RuleSetIncludeChecker.HasInclude(sourceWithAbsoluteInclude, target);
// Assert
hasInclude.Should().BeTrue();
}
public void HasInclude_SourceIsTarget_ReturnsTrue()
{
// Covers the case where the ruleset is included directly in the project, rather
// than indirectly as a RuleSetInclude in another ruleset.
// Arrange
var source = TestRuleSetHelper.CreateTestRuleSet(@"c:\Solution\SomeFolder\fullFilePath.ruleset");
var target = TestRuleSetHelper.CreateTestRuleSet(@"C:/SOLUTION\./SomeFolder\fullFilePath.ruleset");
// Act
var include = RuleSetIncludeChecker.HasInclude(source, target);
// Assert
include.Should().BeTrue();
}
public void HasInclude_RelativePaths_Complex2()
{
// Arrange
var target = TestRuleSetHelper.CreateTestRuleSet(@"c:\Solution\SomeFolder\fullFilePath.ruleset");
var relativeInclude = @"./.\..\..\Dummy1\Dummy2\..\.././Solution\SomeFolder\fullFilePath.ruleset";
var sourceWithRelativeInclude = TestRuleSetHelper.CreateTestRuleSetWithIncludes(@"c:\aaa\bbb\fullFilePath.ruleset",
relativeInclude);
// Act
var hasInclude = RuleSetIncludeChecker.HasInclude(sourceWithRelativeInclude, target);
// Assert
hasInclude.Should().BeTrue();
}
public void BindingWorkflow_DownloadQualityProfile_Success()
{
// Setup
const string QualityProfileName = "SQQualityProfileName";
const string SonarQubeProjectName = "SQProjectName";
var projectInfo = new ProjectInformation {
Key = "key", Name = SonarQubeProjectName
};
BindingWorkflow testSubject = this.CreateTestSubject(projectInfo);
ConfigurableProgressController controller = new ConfigurableProgressController();
var notifications = new ConfigurableProgressStepExecutionEvents();
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(new[] { "Key1", "Key2" });
var expectedRuleSet = new RuleSet(ruleSet)
{
NonLocalizedDisplayName = string.Format(Strings.SonarQubeRuleSetNameFormat, SonarQubeProjectName, QualityProfileName),
NonLocalizedDescription = "\r\nhttp://connected/profiles/show?key="
};
var nugetPackages = new[] { new PackageName("myPackageId", new SemanticVersion("1.0.0")) };
var additionalFiles = new[] { new AdditionalFile {
FileName = "abc.xml", Content = new byte[] { 1, 2, 3 }
} };
RoslynExportProfile export = RoslynExportProfileHelper.CreateExport(ruleSet, nugetPackages, additionalFiles);
var language = Language.VBNET;
QualityProfile profile = this.ConfigureProfileExport(export, language);
profile.Name = QualityProfileName;
// Act
testSubject.DownloadQualityProfile(controller, CancellationToken.None, notifications, new[] { language });
// Verify
RuleSetAssert.AreEqual(expectedRuleSet, testSubject.Rulesets[language], "Unexpected rule set");
Assert.AreSame(profile, testSubject.QualityProfiles[language]);
VerifyNuGetPackgesDownloaded(nugetPackages, testSubject, language);
controller.AssertNumberOfAbortRequests(0);
notifications.AssertProgress(
0.0,
1.0);
notifications.AssertProgressMessages(Strings.DownloadingQualityProfileProgressMessage, string.Empty);
this.outputWindowPane.AssertOutputStrings(1);
var expectedOutput = string.Format(Strings.SubTextPaddingFormat,
string.Format(Strings.QualityProfileDownloadSuccessfulMessageFormat, QualityProfileName, string.Empty, language.Name));
this.outputWindowPane.AssertOutputStrings(expectedOutput);
}
public void RuleSetSerializer_LoadRuleSet()
{
// Setup
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSet(this.TestContext.TestRunDirectory, this.TestContext.TestName + ".ruleset");
this.temporaryFiles.AddFile(ruleSet.FilePath, false);
ruleSet.WriteToFile(ruleSet.FilePath);
this.fileSystem.RegisterFile(ruleSet.FilePath);
// Act
RuleSet loaded = this.testSubject.LoadRuleSet(ruleSet.FilePath);
// Verify
Assert.IsNotNull(loaded, "Expected to load a rule set file");
RuleSetAssert.AreEqual(ruleSet, loaded, "Loaded unexpected rule set");
}
public void RuleSetSerializer_LoadRuleSet()
{
// Arrange
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSet(this.TestContext.TestRunDirectory, this.TestContext.TestName + ".ruleset");
temporaryFiles.AddFile(ruleSet.FilePath, false);
ruleSet.WriteToFile(ruleSet.FilePath);
fileSystem.AddFile(ruleSet.FilePath, new MockFileData(""));
// Act
RuleSet loaded = this.testSubject.LoadRuleSet(ruleSet.FilePath);
// Assert
loaded.Should().NotBeNull("Expected to load a rule set file");
RuleSetAssert.AreEqual(ruleSet, loaded, "Loaded unexpected rule set");
}
public async Task GetConfig_Success()
{
// Arrange
const string QualityProfileName = "SQQualityProfileName";
const string ProjectName = "SQProjectName";
// Record all of the calls to NuGetBindingOperation.ProcessExport
var actualProfiles = new List <Tuple <Language, RoslynExportProfileResponse> >();
Mock <INuGetBindingOperation> nuGetOpMock = new Mock <INuGetBindingOperation>();
nuGetOpMock.Setup(x => x.ProcessExport(It.IsAny <Language>(), It.IsAny <RoslynExportProfileResponse>()))
.Callback <Language, RoslynExportProfileResponse>((l, r) => actualProfiles.Add(new Tuple <Language, RoslynExportProfileResponse>(l, r)))
.Returns(true);
var testSubject = this.CreateTestSubject(ProjectName, "http://connected/", nuGetOpMock.Object);
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(new[] { "Key1", "Key2" });
var expectedRuleSet = new RuleSet(ruleSet)
{
NonLocalizedDisplayName = string.Format(Strings.SonarQubeRuleSetNameFormat, ProjectName, QualityProfileName),
NonLocalizedDescription = "\r\nhttp://connected/profiles/show?key="
};
var nugetPackages = new[] { new PackageName("myPackageId", new SemanticVersion("1.0.0")) };
var additionalFiles = new[] { new AdditionalFileResponse {
FileName = "abc.xml", Content = new byte[] { 1, 2, 3 }
} };
RoslynExportProfileResponse export = RoslynExportProfileHelper.CreateExport(ruleSet, nugetPackages, additionalFiles);
var language = Language.VBNET;
SonarQubeQualityProfile profile = this.ConfigureProfileExport(export, language, QualityProfileName);
// Act
var result = await testSubject.GetConfigurationAsync(profile, "TODO", language, CancellationToken.None)
.ConfigureAwait(false);
// Assert
result.Should().NotBeNull();
var dotNetResult = result as DotNetBindingConfigFile;
dotNetResult.Should().NotBeNull();
RuleSetAssert.AreEqual(expectedRuleSet, dotNetResult.RuleSet, "Unexpected rule set");
VerifyNuGetPackgesDownloaded(nugetPackages, language, actualProfiles);
this.logger.AssertOutputStrings(0); // not expecting anything in the case of success
}
public async Task DownloadQualityProfile_Success()
{
// Arrange
const string QualityProfileName = "SQQualityProfileName";
const string ProjectName = "SQProjectName";
Mock <INuGetBindingOperation> nuGetOpMock = new Mock <INuGetBindingOperation>();
var notifications = new ConfigurableProgressStepExecutionEvents();
var progressAdapter = new FixedStepsProgressAdapter(notifications);
RuleSet expectedRuleSet = TestRuleSetHelper.CreateTestRuleSetWithRuleIds(new[] { "Key1", "Key2" });
var configFile = new Mock <IBindingConfigFile>().Object;
var language = Language.VBNET;
SonarQubeQualityProfile profile = this.ConfigureQualityProfile(language, QualityProfileName);
var configProviderMock = new Mock <IBindingConfigProvider>();
configProviderMock.Setup(x => x.GetConfigurationAsync(profile, null, language, CancellationToken.None))
.ReturnsAsync(configFile);
var testSubject = this.CreateTestSubject("key", ProjectName, nuGetOpMock.Object, configProviderMock.Object);
ConfigureSupportedBindingProject(testSubject.InternalState, language);
// Act
var result = await testSubject.DownloadQualityProfileAsync(progressAdapter, CancellationToken.None);
// Assert
result.Should().BeTrue();
testSubject.InternalState.BindingConfigFiles.Should().ContainKey(language);
testSubject.InternalState.BindingConfigFiles[language].Should().Be(configFile);
testSubject.InternalState.BindingConfigFiles.Count().Should().Be(1);
testSubject.InternalState.QualityProfiles[language].Should().Be(profile);
notifications.AssertProgress(0.0, 1.0);
notifications.AssertProgressMessages(Strings.DownloadingQualityProfileProgressMessage, string.Empty);
this.outputWindowPane.AssertOutputStrings(1);
var expectedOutput = string.Format(Strings.SubTextPaddingFormat,
string.Format(Strings.QualityProfileDownloadSuccessfulMessageFormat, QualityProfileName, string.Empty, language.Name));
this.outputWindowPane.AssertOutputStrings(expectedOutput);
}
public void RuleSetSerializer_WriteRuleSetFile()
{
// Setup
RuleSet ruleSet = TestRuleSetHelper.CreateTestRuleSet(this.TestContext.TestRunDirectory, this.TestContext.TestName + ".ruleset");
this.temporaryFiles.AddFile(ruleSet.FilePath, false);
string expectedPath = Path.Combine(this.TestContext.TestRunDirectory, this.TestContext.TestName + "Other.ruleset");
// Act
this.testSubject.WriteRuleSetFile(ruleSet, expectedPath);
// Verify
Assert.IsTrue(File.Exists(expectedPath), "File not exists where expected");
Assert.IsFalse(File.Exists(ruleSet.FilePath), "Expected to save only to the specified file path");
RuleSet loaded = RuleSet.LoadFromFile(expectedPath);
RuleSetAssert.AreEqual(ruleSet, loaded, "Written unexpected rule set");
}
public void HasInclude_RelativePaths_Complex()
{
// Regression test for https://github.com/SonarSource/sonarlint-visualstudio/issues/658
// "SonarLint for Visual Studio 2017 plugin does not respect shared imports "
// Arrange
var target = TestRuleSetHelper.CreateTestRuleSet(@"c:\Solution\SomeFolder\fullFilePath.ruleset");
var relativeInclude = @".\..\..\Solution\SomeFolder\fullFilePath.ruleset";
var sourceWithRelativeInclude = TestRuleSetHelper.CreateTestRuleSetWithIncludes(@"c:\aaa\bbb\fullFilePath.ruleset",
relativeInclude);
// Act
var hasInclude = RuleSetIncludeChecker.HasInclude(sourceWithRelativeInclude, target);
// Assert
hasInclude.Should().BeTrue();
}
public void RuleSetConflictsController_FixConflictsCommandExecution()
{
// Arrange
var testSubject = new RuleSetConflictsController(this.host, this.conflictsManager);
this.ConfigureServiceProviderForFixConflictsCommandExecution();
this.host.VisualStateManager.IsBusy = false;
this.host.VisualStateManager.SetBoundProject(new Uri("http://foo"), null, "project123");
var section = ConfigurableSectionController.CreateDefault();
this.host.SetActiveSection(section);
ConfigurableUserNotification notifications = (ConfigurableUserNotification)section.UserNotifications;
ProjectRuleSetConflict[] conflicts = new[] { ConfigurableConflictsManager.CreateConflict() };
RuleSet fixedRuleSet = TestRuleSetHelper.CreateTestRuleSet(3);
fixedRuleSet.FilePath = "MyFixedRules.ruleset";
RuleSetInspectorTestDataProvider inspectorData = new RuleSetInspectorTestDataProvider();
var weakenedRulesMap = new Dictionary <RuleReference, RuleAction>();
inspectorData.FindConflictsResult = new RuleConflictInfo(new RuleReference[0], weakenedRulesMap);
inspectorData.FixConflictsResult = new FixedRuleSetInfo(fixedRuleSet, new[] { "reset.ruleset" }, new[] { "deletedRuleId1" });
this.ruleSetInspector.FindConflictingRulesAction = inspectorData.FindConflictingRulesAction;
this.ruleSetInspector.FixConflictingRulesAction = inspectorData.FixConflictingRulesAction;
ICommand fixMeCommand = testSubject.CreateFixConflictsCommand(conflicts);
section.UserNotifications.ShowNotificationWarning("fix me", NotificationIds.RuleSetConflictsId, fixMeCommand);
// Act
fixMeCommand.Execute(null);
// Assert
this.sccFS.files.Should().ContainKey(fixedRuleSet.FilePath);
this.rsSerializer.AssertRuleSetsAreSame(fixedRuleSet.FilePath, fixedRuleSet);
this.outputWindowPane.AssertOutputStrings(1);
this.outputWindowPane.AssertMessageContainsAllWordsCaseSensitive(0,
words: new[] { fixedRuleSet.FilePath, "deletedRuleId1", "reset.ruleset" },
splitter: new[] { '\n', '\r', '\t', '\'', ':' });
notifications.AssertNoNotification(NotificationIds.RuleSetConflictsId);
}
public void ConflictsManager_GetCurrentConflicts_HasConflicts_WithAggregationApplied()
{
// Arrange
this.SetSolutionBinding(SonarLintMode.LegacyConnected);
this.SetValidProjects(3);
this.SetValidSolutionRuleSetPerProjectKind();
IEnumerable <RuleSetDeclaration> knownDeclarations = this.SetValidRuleSetDeclarationPerProjectAndConfiguration(
useUniqueProjectRuleSets: false,
configurationNames: new[] { "Debug", "Release" });
this.ConfigureInspectorWithConflicts(knownDeclarations, () =>
{
RuleSet temp = TestRuleSetHelper.CreateTestRuleSet(1);
return(new RuleConflictInfo(temp.Rules)); // Missing rules
});
// Act + Assert
testSubject.GetCurrentConflicts().Should().HaveCount(3, "Expecting 3 conflicts (1 per project) since the ruleset declaration for project configuration are the same");
this.outputWindowPane.AssertOutputStrings(0);
}
