| public static AreEqual ( RuleSet expected, RuleSet actual, string message = null ) : void | ||
| expected | RuleSet | |
| actual | RuleSet | |
| message | string | |
| return | void | |
public void RuleSetInspector_FixConflictingRules_AllAtOnce()
{
// Arrange
RuleSet solutionRuleSet = this.CreateCommonRuleSet(defaultAction: RuleAction.Error);
RuleSet otherRuleSet = this.CreateUserSharedRuleSet($"User.ruleset", RuleAction.Info);
RuleSet projectRuleSet = this.CreateProjectRuleSetWithIncludes(1, solutionRuleSet.FilePath, IncludeType.AsRelativeToProject, RuleAction.Warning, otherRuleSet.FilePath);
string relativeInclude = PathHelper.CalculateRelativePath(projectRuleSet.FilePath, solutionRuleSet.FilePath);
FindInclude(projectRuleSet, relativeInclude).Action = RuleAction.Hidden;
projectRuleSet.WriteToFile(projectRuleSet.FilePath);
// Sanity
AssertConflictsExpected(solutionRuleSet.FilePath, projectRuleSet.FilePath, "Expected 3 weakened rules since solution include was set to Hidden (and also a rule override with a weaker action)");
// Act
FixedRuleSetInfo fixedInfo = this.testSubject.FixConflictingRules(solutionRuleSet.FilePath, projectRuleSet.FilePath);
// Assert
VerifyFix(fixedInfo, expectedIncludesReset: 1, expectedRulesDeleted: 1);
RuleSet fixedTarget = fixedInfo.FixedRuleSet;
RuleSet expectedRuleSet = this.CreateProjectRuleSetWithIncludes(0, solutionRuleSet.FilePath, IncludeType.AsRelativeToProject, otherIncludes: otherRuleSet.FilePath);
RuleSetAssert.AreEqual(expectedRuleSet, fixedTarget, "Expected the include action to change to default and the conflicting rules to be removed");
VerifyFixedRuleSetIsNotPersisted(solutionRuleSet, projectRuleSet, fixedTarget);
}
public void RuleSetInspector_FixConflictingRules_RuleOverrideConflict()
{
// Arrange
RuleSet solutionRuleSet = this.CreateCommonRuleSet(rules: 5);
// Create less rules than in the solution rule set and create conflicts not in all of them
RuleSet projectRuleSet = this.CreateProjectRuleSetWithIncludes(4, solutionRuleSet.FilePath, IncludeType.AsRelativeToProject);
projectRuleSet.Rules[1].Action = RuleAction.Hidden;
projectRuleSet.Rules[2].Action = RuleAction.Info;
projectRuleSet.Rules[3].Action = RuleAction.None;
projectRuleSet.WriteToFile(projectRuleSet.FilePath);
// Sanity
AssertConflictsExpected(solutionRuleSet.FilePath, projectRuleSet.FilePath, "Expected 2 weakened rules and 1 missing due to rule overrides at the project level");
// Act
FixedRuleSetInfo fixedInfo = this.testSubject.FixConflictingRules(solutionRuleSet.FilePath, projectRuleSet.FilePath);
// Assert
VerifyFix(fixedInfo, expectedIncludesReset: 1, expectedRulesDeleted: 3);
RuleSet fixedTarget = fixedInfo.FixedRuleSet;
RuleSet expectedRuleSet = this.CreateProjectRuleSetWithIncludes(1, solutionRuleSet.FilePath, IncludeType.AsRelativeToProject);
RuleSetAssert.AreEqual(expectedRuleSet, fixedTarget, "Expected the conflicting rules to be deleted");
VerifyFixedRuleSetIsNotPersisted(solutionRuleSet, projectRuleSet, fixedTarget);
}
public void RuleSetInspector_FixConflictingRules_IncludeConflict()
{
// Setup
RuleSet solutionRuleSet = this.CreateCommonRuleSet();
RuleSet otherRuleSet = this.CreateUserSharedRuleSet($"User.ruleset", RuleAction.Info);
RuleSet projectRuleSet = this.CreateProjectRuleSetWithIncludes(0, solutionRuleSet.FilePath, IncludeType.AsRelativeToProject, RuleAction.Default, otherRuleSet.FilePath);
string relativeInclude = PathHelper.CalculateRelativePath(projectRuleSet.FilePath, solutionRuleSet.FilePath);
FindInclude(projectRuleSet, relativeInclude).Action = RuleAction.Hidden;
projectRuleSet.WriteToFile(projectRuleSet.FilePath);
// Sanity
AssertConflictsExpected(solutionRuleSet.FilePath, projectRuleSet.FilePath, "Expected 3 weakened rules since solution include was set to Hidden");
// Act
FixedRuleSetInfo fixedInfo = this.testSubject.FixConflictingRules(solutionRuleSet.FilePath, projectRuleSet.FilePath);
// Verify
VerifyFix(fixedInfo, expectedIncludesReset: 1, expectedRulesDeleted: 0);
RuleSet fixedTarget = fixedInfo.FixedRuleSet;
RuleSet expectedRuleSet = this.CreateProjectRuleSetWithIncludes(0, solutionRuleSet.FilePath, IncludeType.AsRelativeToProject, RuleAction.Warning, otherRuleSet.FilePath);
RuleSetAssert.AreEqual(expectedRuleSet, fixedTarget, "Expected the include action to be fixed");
VerifyFixedRuleSetIsNotPersisted(solutionRuleSet, projectRuleSet, fixedTarget);
}
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 AssertRuleSetsAreEqual(string ruleSetPath, RuleSet expectedRuleSet)
{
this.AssertRuleSetExists(ruleSetPath);
RuleSet actualRuleSet = this.savedRuleSets[ruleSetPath];
actualRuleSet.Should().NotBeNull("Expected rule set to be written");
RuleSetAssert.AreEqual(expectedRuleSet, actualRuleSet);
}
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 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 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 RuleSetInspector_FixConflictingRules_NoConflicts()
{
// Arrange
RuleSet solutionRuleSet = this.CreateCommonRuleSet();
RuleSet projectRuleSet = this.CreateProjectRuleSetWithIncludes(0, solutionRuleSet.FilePath, IncludeType.AsRelativeToProject, RuleAction.Default);
// Sanity
AssertNoConflictsExpected(solutionRuleSet.FilePath, projectRuleSet.FilePath);
// Act
FixedRuleSetInfo fixedInfo = this.testSubject.FixConflictingRules(solutionRuleSet.FilePath, projectRuleSet.FilePath);
// Assert
RuleSet target = fixedInfo.FixedRuleSet;
RuleSetAssert.AreEqual(projectRuleSet, target);
VerifyFix(fixedInfo, expectedIncludesReset: 0, expectedRulesDeleted: 0);
}
public void RuleSetUpdater_RemoveAllIncludesUnderRoot()
{
// 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);
AddRuleSetInclusion(inputRuleSet, sonarRs1, useRelativePath: true);
AddRuleSetInclusion(inputRuleSet, sonarRs2, useRelativePath: false);
var expectedRuleSet = TestRuleSetHelper.CreateTestRuleSet(projectRoot, "test.ruleset");
AddRuleSetInclusion(expectedRuleSet, projectBaseRs, useRelativePath: true);
AddRuleSetInclusion(expectedRuleSet, commonRs1, useRelativePath: true);
AddRuleSetInclusion(expectedRuleSet, commonRs2, useRelativePath: false);
// Act
RuleSetUpdater.RemoveAllIncludesUnderRoot(inputRuleSet, sonarRoot);
// Assert
RuleSetAssert.AreEqual(expectedRuleSet, inputRuleSet);
}
public void RuleSetUpdater_UpdateExistingProjectRuleSet()
{
// Arrange
const string existingProjectRuleSetPath = @"X:\MySolution\ProjectOne\proj1.ruleset";
const string existingInclude = @"..\SolutionRuleSets\sonarqube1.ruleset";
const string newSolutionRuleSetPath = @"X:\MySolution\SolutionRuleSets\sonarqube2.ruleset";
const string expectedInclude = @"..\SolutionRuleSets\sonarqube2.ruleset";
var existingProjectRuleSet = TestRuleSetHelper.CreateTestRuleSet(existingProjectRuleSetPath);
existingProjectRuleSet.RuleSetIncludes.Add(new RuleSetInclude(existingInclude, RuleAction.Default));
var expectedRuleSet = TestRuleSetHelper.CreateTestRuleSet(existingProjectRuleSetPath);
expectedRuleSet.RuleSetIncludes.Add(new RuleSetInclude(expectedInclude, RuleAction.Default));
// Act
RuleSetUpdater.UpdateExistingProjectRuleSet(existingProjectRuleSet, newSolutionRuleSetPath);
// Assert
RuleSetAssert.AreEqual(expectedRuleSet, existingProjectRuleSet, "Update should delete previous solution rulesets, and replace them with a new one provide");
}
