private IReadOnlyList <ProjectRuleSetConflict> FindConflicts(RuleSetInformation[] aggregatedRuleSet) { List <ProjectRuleSetConflict> conflicts = new List <ProjectRuleSetConflict>(); IRuleSetInspector inspector = this.serviceProvider.GetService <IRuleSetInspector>(); inspector.AssertLocalServiceIsNotNull(); // At the moment single threaded, if needed this could be done in parallel foreach (RuleSetInformation aggregate in aggregatedRuleSet) { try { RuleConflictInfo conflict = inspector.FindConflictingRules(aggregate.BaselineFilePath, aggregate.RuleSetFilePath, aggregate.RuleSetDirectories); Debug.Assert(conflict != null); if (conflict?.HasConflicts ?? false) { conflicts.Add(new ProjectRuleSetConflict(conflict, aggregate)); } } catch (Exception ex) { if (ErrorHandler.IsCriticalException(ex)) { throw; } this.WriteWarning(Strings.ConflictsManagerFailedInFindConflicts, aggregate.RuleSetFilePath, aggregate.BaselineFilePath, ex.Message); Debug.Fail("Failed to resolve conflict for " + aggregate.RuleSetFilePath, ex.ToString()); } } return(conflicts); }
/// <summary> /// <see cref="IRuleSetInspector.FindConflictingRules(string, string)"/> /// </summary> public FixedRuleSetInfo FixConflictingRules(string baselineRuleSetPath, string targetRuleSetPath, params string[] ruleSetDirectories) { if (string.IsNullOrWhiteSpace(baselineRuleSetPath)) { throw new ArgumentNullException(nameof(baselineRuleSetPath)); } if (string.IsNullOrWhiteSpace(targetRuleSetPath)) { throw new ArgumentNullException(nameof(targetRuleSetPath)); } RuleSet baseline = RuleSet.LoadFromFile(baselineRuleSetPath); RuleSet target = RuleSet.LoadFromFile(targetRuleSetPath); RuleConflictInfo conflicts = this.FindConflictsCore(baseline, target, ruleSetDirectories); List <RuleReference> deletedRules = null; string[] includeReset = null; if (conflicts.HasConflicts) { includeReset = new[] { baseline.FilePath }; if (!this.TryResolveIncludeConflicts(baseline, target)) { deletedRules = this.DeleteConflictingRules(baseline, target); } } return(new FixedRuleSetInfo(target, includeReset, deletedRules?.Select(r => r.FullId))); }
/// <summary> /// Attempts to fix the conflicts by ensuring that the server ruleset is included with the expected Include Action /// </summary> /// <returns>Whether all conflicts were resolved</returns> private bool TryResolveIncludeConflicts(RuleSet baselineRuleSet, RuleSet targetRuleSet) { Debug.Assert(baselineRuleSet != null); Debug.Assert(targetRuleSet != null); Debug.Assert(!string.IsNullOrWhiteSpace(baselineRuleSet.FilePath)); Debug.Assert(!string.IsNullOrWhiteSpace(targetRuleSet.FilePath)); RuleSetHelper.UpdateExistingProjectRuleSet(targetRuleSet, baselineRuleSet.FilePath); RuleConflictInfo conflicts1stAttempt = this.FindConflictsCore(baselineRuleSet, targetRuleSet); return(!conflicts1stAttempt.HasConflicts); }
public ProjectRuleSetConflict(RuleConflictInfo conflict, RuleSetInformation aggregate) { if (conflict == null) { throw new ArgumentNullException(nameof(conflict)); } if (aggregate == null) { throw new ArgumentNullException(nameof(aggregate)); } this.Conflict = conflict; this.RuleSetInfo = aggregate; }
private static void AssertNoWeakRules(RuleConflictInfo info) { Assert.AreEqual(0, info.WeakerActionRules.Count, "Actually weak: {0}", string.Join(", ", info.WeakerActionRules.Keys.Select(r => r.FullId))); }
private static void AssertNoMissingRules(RuleConflictInfo info) { Assert.AreEqual(0, info.MissingRules.Count, "Actually missing: {0}", string.Join(", ", info.MissingRules.Select(r => r.FullId))); }
private static void AssertNoConflicts(RuleConflictInfo info) { AssertNoMissingRules(info); AssertNoWeakRules(info); Assert.IsFalse(info.HasConflicts, "Not expecting conflicts"); }
private static void AssertMissingRulesByFullIds(RuleConflictInfo info, IEnumerable<RuleReference> expectedRules) { string[] expectedFullRuleIds = expectedRules.Select(r => r.FullId).ToArray(); var actualFullIds = info.MissingRules.Select(r => r.FullId).ToArray(); CollectionAssert.AreEquivalent(expectedFullRuleIds, actualFullIds, "Actually missing: {0}", string.Join(", ", actualFullIds)); Assert.IsTrue(info.HasConflicts, "Expected missing rules"); }
private static void AssertWeakRulesByFullIds(RuleConflictInfo info, IEnumerable<RuleReference> expectedRules, RuleSet baseline) { var expectedFullRuleIds = new HashSet<string>(expectedRules.Select(r => r.FullId)); List<string> found = new List<string>(); foreach(var keyValue in info.WeakerActionRules) { string ruleFullId = keyValue.Key.FullId; found.Add(ruleFullId); Assert.IsTrue(expectedFullRuleIds.Contains(ruleFullId), "Unexpected weakened rule"); RuleReference baselineRule; Assert.IsTrue(baseline.Rules.TryGetRule(ruleFullId, out baselineRule), "Test setup error: baseline doesn't contain the rule {0}", ruleFullId); Assert.AreEqual(baselineRule.Action, keyValue.Value, "Unexpected Action. Expecting the baseline rule action to be returned part of RuleConflictInfo"); } Assert.AreEqual(expectedFullRuleIds.Count, info.WeakerActionRules.Count, "Not all the expected weakened rule were found. Missing: {0}", string.Join(", ", expectedFullRuleIds.Except(found))); Assert.IsTrue(info.HasConflicts, "Expected weakened rules"); }