private IEnumerable <RuleSetDeclaration> SetSingleValidRuleSetDeclarationPerProject(string configurationName = "Configuration", bool useUniqueProjectRuleSets = false)
{
List <RuleSetDeclaration> declarations = new List <RuleSetDeclaration>();
foreach (ProjectMock project in this.projectHelper.FilteredProjects.OfType <ProjectMock>())
{
var configuration = new ConfigurationMock(configurationName);
project.ConfigurationManager.Configurations.Add(configuration);
PropertyMock ruleSetProperty = configuration.Properties.RegisterKnownProperty(Constants.CodeAnalysisRuleSetPropertyKey);
ruleSetProperty.Value = project.FilePath.ToUpperInvariant(); // Catch cases where file paths are compared without OrdinalIgnoreCase
if (useUniqueProjectRuleSets)
{
ruleSetProperty.Value = Path.ChangeExtension(project.FilePath, configurationName + ".ruleSet");
}
PropertyMock ruleSetDirectories = configuration.Properties.RegisterKnownProperty(Constants.CodeAnalysisRuleSetDirectoriesPropertyKey);
ruleSetDirectories.Value = ConflictsManager.CombineDirectories(new[] { this.TestContext.TestRunDirectory, "." });
RuleSetDeclaration declaration = new RuleSetDeclaration(
project,
ruleSetProperty,
ruleSetProperty.Value.ToString().ToLowerInvariant(), // Catch cases where file paths are compared without OrdinalIgnoreCase
configuration.ConfigurationName,
ruleSetDirectories.Value.ToString().Split(';'));
declarations.Add(declaration);
this.ruleSetInfoProvider.RegisterProjectInfo(project, declaration);
}
return(declarations);
}
private void VerifyRuleSetInformation(RuleSetDeclaration info, PropertyMock property)
{
info.DeclaringProperty.Should().Be(property);
info.RuleSetPath.Should().Be((string)property.Value);
Configuration configuration = (Configuration)property.Collection.Parent;
if (configuration == null)
{
FluentAssertions.Execution.Execute.Assertion.FailWith("Test setup error, expected to have configuration as parent");
}
info.ConfigurationContext.Should().Be(configuration.ConfigurationName);
((IVsBuildPropertyStorage)projectMock).GetPropertyValue(Constants.CodeAnalysisRuleSetDirectoriesPropertyKey, configuration.ConfigurationName, 0, out string ruleSetDirectoryValue);
if (string.IsNullOrWhiteSpace(ruleSetDirectoryValue))
{
info.RuleSetDirectories.Should().BeEmpty();
}
else
{
string[] expected = ruleSetDirectoryValue.Split(new[] { SolutionRuleSetsInformationProvider.RuleSetDirectoriesValueSpliter }, StringSplitOptions.RemoveEmptyEntries);
CollectionAssert.AreEquivalent(expected, info.RuleSetDirectories.ToArray(), "Actual: {0}", string.Join(", ", info.RuleSetDirectories));
}
}
private void VerifyRuleSetInformation(RuleSetDeclaration info, PropertyMock property)
{
Assert.AreSame(property, info.DeclaringProperty);
Assert.AreEqual(property.Value, info.RuleSetPath);
Configuration configuration = (Configuration)property.Collection.Parent;
if (configuration == null)
{
Assert.Inconclusive("Test setup error, expected to have configuration as parent");
}
Assert.AreEqual(configuration.ConfigurationName, info.ConfigurationContext);
Property ruleSetDirectory = configuration.Properties.OfType <Property>().SingleOrDefault(p => p.Name == Constants.CodeAnalysisRuleSetDirectoriesPropertyKey);
string ruleSetDirectoryValue = ruleSetDirectory?.Value as string;
if (string.IsNullOrWhiteSpace(ruleSetDirectoryValue))
{
Assert.AreEqual(0, info.RuleSetDirectories.Count());
}
else
{
string[] expected = ruleSetDirectoryValue.Split(new[] { SolutionRuleSetsInformationProvider.RuleSetDirectoriesValueSpliter }, StringSplitOptions.RemoveEmptyEntries);
CollectionAssert.AreEquivalent(expected, info.RuleSetDirectories.ToArray(), "Actual: {0}", string.Join(", ", info.RuleSetDirectories));
}
}
private RuleSet FindDeclarationRuleSet(RuleSetDeclaration declaration)
{
// Check if project rule set is found (we treat missing/erroneous rule set settings as not found)
if (!ruleSetInfoProvider.TryGetProjectRuleSetFilePath(declaration, out var ruleSetFilePath))
{
return(null);
}
return(ruleSetSerializer.LoadRuleSet(ruleSetFilePath));
}
private void SetupProjectRuleSet(RuleSetDeclaration declaration, RuleSet projectRuleSet)
{
var projectRuleSetPath = Guid.NewGuid().ToString();
solutionRuleSetsInformationProviderMock
.Setup(x => x.TryGetProjectRuleSetFilePath(declaration, out projectRuleSetPath))
.Returns(true);
ruleSetSerializerMock
.Setup(x => x.LoadRuleSet(projectRuleSetPath))
.Returns(projectRuleSet);
}
bool ISolutionRuleSetsInformationProvider.TryGetProjectRuleSetFilePath(Project project, RuleSetDeclaration declaration, out string fullFilePath)
{
fullFilePath = declaration.RuleSetPath;
return(true);
}
private static string CalculateProjectRuleSetFullPath(ISolutionRuleSetsInformationProvider ruleSetInfoProvider, Project project, RuleSetDeclaration declaration)
{
string projectRuleSet;
if (!ruleSetInfoProvider.TryGetProjectRuleSetFilePath(project, declaration, out projectRuleSet))
{
// Use the original property value to attempt to load the rule set with the directories information, during FindConflicts
projectRuleSet = declaration.RuleSetPath;
// We do want to continue and add this rule set rather than skip over it since it maybe the case that
// the user moved it to some other location which is relative to the rule set directories property
// and we will be able to find it during rule set conflicts analysis.
}
return(projectRuleSet);
}
private void AddOrUpdateAggregatedRuleSetInformation(Dictionary <string, RuleSetInformation> projectRuleSetAggregation, string baselineRuleSet, RuleSetDeclaration declaration, string projectRuleSet)
{
RuleSetInformation aggregate;
if (projectRuleSetAggregation.TryGetValue(projectRuleSet, out aggregate))
{
aggregate.ConfigurationContexts.Add(declaration.ConfigurationContext);
if (!aggregate.RuleSetDirectories.SequenceEqual(declaration.RuleSetDirectories))
{
this.WriteWarning(Strings.InconsistentRuleSetDirectoriesWarning,
CombineDirectories(declaration.RuleSetDirectories),
projectRuleSet,
CombineDirectories(aggregate.RuleSetDirectories));
}
}
else
{
aggregate = new RuleSetInformation(declaration.RuleSetProjectFullName, baselineRuleSet, projectRuleSet, declaration.RuleSetDirectories);
aggregate.ConfigurationContexts.Add(declaration.ConfigurationContext);
projectRuleSetAggregation[projectRuleSet] = aggregate;
}
}
public bool IsReferenced(RuleSetDeclaration declaration, string targetRuleSetFilePath)
{
var projectRuleSet = FindDeclarationRuleSet(declaration);
return(projectRuleSet != null && HasInclude(projectRuleSet, targetRuleSetFilePath));
}
bool ISolutionRuleSetsInformationProvider.TryGetProjectRuleSetFilePath(Project project, RuleSetDeclaration declaration, out string fullFilePath)
{
fullFilePath = declaration.RuleSetPath;
return true;
}
private void VerifyRuleSetInformation(RuleSetDeclaration info, PropertyMock property)
{
Assert.AreSame(property, info.DeclaringProperty);
Assert.AreEqual(property.Value, info.RuleSetPath);
Configuration configuration = (Configuration)property.Collection.Parent;
if (configuration == null)
{
Assert.Inconclusive("Test setup error, expected to have configuration as parent");
}
Assert.AreEqual(configuration.ConfigurationName, info.ConfigurationContext);
Property ruleSetDirectory = configuration.Properties.OfType<Property>().SingleOrDefault(p => p.Name == Constants.CodeAnalysisRuleSetDirectoriesPropertyKey);
string ruleSetDirectoryValue = ruleSetDirectory?.Value as string;
if (string.IsNullOrWhiteSpace(ruleSetDirectoryValue))
{
Assert.AreEqual(0, info.RuleSetDirectories.Count());
}
else
{
string[] expected = ruleSetDirectoryValue.Split(new[] { SolutionRuleSetsInformationProvider.RuleSetDirectoriesValueSpliter }, StringSplitOptions.RemoveEmptyEntries);
CollectionAssert.AreEquivalent(expected, info.RuleSetDirectories.ToArray(), "Actual: {0}", string.Join(", ", info.RuleSetDirectories));
}
}
private IEnumerable<RuleSetDeclaration> SetSingleValidRuleSetDeclarationPerProject(string configurationName = "Configuration", bool useUniqueProjectRuleSets = false)
{
List<RuleSetDeclaration> declarations = new List<RuleSetDeclaration>();
foreach (ProjectMock project in this.projectHelper.FilteredProjects.OfType<ProjectMock>())
{
var configuration = new ConfigurationMock(configurationName);
project.ConfigurationManager.Configurations.Add(configuration);
PropertyMock ruleSetProperty = configuration.Properties.RegisterKnownProperty(Constants.CodeAnalysisRuleSetPropertyKey);
ruleSetProperty.Value = project.FilePath.ToUpperInvariant(); // Catch cases where file paths are compared without OrdinalIgnoreCase
if (useUniqueProjectRuleSets)
{
ruleSetProperty.Value = Path.ChangeExtension(project.FilePath, configurationName + ".ruleSet");
}
PropertyMock ruleSetDirectories = configuration.Properties.RegisterKnownProperty(Constants.CodeAnalysisRuleSetDirectoriesPropertyKey);
ruleSetDirectories.Value = ConflictsManager.CombineDirectories(new[] { this.TestContext.TestRunDirectory, "." });
RuleSetDeclaration declaration = new RuleSetDeclaration(
project,
ruleSetProperty,
ruleSetProperty.Value.ToString().ToLowerInvariant(), // Catch cases where file paths are compared without OrdinalIgnoreCase
configuration.ConfigurationName,
ruleSetDirectories.Value.ToString().Split(';'));
declarations.Add(declaration);
this.ruleSetInfoProvider.RegisterProjectInfo(project, declaration);
}
return declarations;
}
private static string CalculateProjectRuleSetFullPath(ISolutionRuleSetsInformationProvider ruleSetInfoProvider, Project project, RuleSetDeclaration declaration)
{
string projectRuleSet;
if (!ruleSetInfoProvider.TryGetProjectRuleSetFilePath(project, declaration, out projectRuleSet))
{
// Use the original property value to attempt to load the rule set with the directories information, during FindConflicts
projectRuleSet = declaration.RuleSetPath;
// We do want to continue and add this rule set rather than skip over it since it maybe the case that
// the user moved it to some other location which is relative to the rule set directories property
// and we will be able to find it during rule set conflicts analysis.
}
return projectRuleSet;
}
private void AddOrUpdateAggregatedRuleSetInformation(Dictionary<string, RuleSetInformation> projectRuleSetAggregation, string baselineRuleSet, RuleSetDeclaration declaration, string projectRuleSet)
{
RuleSetInformation aggregate;
if (projectRuleSetAggregation.TryGetValue(projectRuleSet, out aggregate))
{
aggregate.ConfigurationContexts.Add(declaration.ConfigurationContext);
if (!aggregate.RuleSetDirectories.SequenceEqual(declaration.RuleSetDirectories))
{
this.WriteWarning(Strings.InconsistentRuleSetDirectoriesWarning,
CombineDirectories(declaration.RuleSetDirectories),
projectRuleSet,
CombineDirectories(aggregate.RuleSetDirectories));
}
}
else
{
aggregate = new RuleSetInformation(declaration.RuleSetProjectFullName, baselineRuleSet, projectRuleSet, declaration.RuleSetDirectories);
aggregate.ConfigurationContexts.Add(declaration.ConfigurationContext);
projectRuleSetAggregation[projectRuleSet] = aggregate;
}
}
