public void DisableExcludedRules_CustomRulesAndExcludedRulesExist_CustomRulesAreUnchangedExcludedRulesAreDisabled() { // Arrange var testLogger = new TestLogger(); var excluded = new string[] { "excluded1", "excluded2", "excluded3", "excluded4" }; var custom = new RulesSettings() .AddRule("xxx", RuleLevel.On) .AddRule("excluded1", RuleLevel.On) .AddRule("yyy", RuleLevel.Off) .AddRule("excluded2", RuleLevel.Off) .AddRule("excluded4", RuleLevel.On); // Act var result = DynamicCFamilyRulesConfig.DisableExcludedRules(custom, excluded, testLogger); // Assert result.Should().NotBeSameAs(custom); custom.Rules.Count.Should().BeLessThan(result.Rules.Count); result.Rules.Keys.Should().BeEquivalentTo("xxx", "excluded1", "yyy", "excluded2", "excluded3", "excluded4"); result.Rules["xxx"].Level.Should().Be(RuleLevel.On); result.Rules["excluded1"].Level.Should().Be(RuleLevel.Off); // changed from On to Off result.Rules["yyy"].Level.Should().Be(RuleLevel.Off); result.Rules["excluded2"].Level.Should().Be(RuleLevel.Off); // unchanged - still Off result.Rules["excluded4"].Level.Should().Be(RuleLevel.Off); // changed from On to Off testLogger.AssertPartialOutputStringExists("excluded1", "excluded2", "excluded3", "excluded4"); }
public void NullOrEmptyRulesSettings_DefaultsUsed() { // Arrange var defaultConfig = new DummyCFamilyRulesConfig("123") .AddRule("rule1", IssueSeverity.Blocker, isActive: true, parameters: new Dictionary <string, string> { { "p1", "v1" } }) .AddRule("rule2", IssueSeverity.Major, isActive: true, parameters: new Dictionary <string, string> { { "p2", "v2" } }) .AddRule("rule3", IssueSeverity.Minor, isActive: false, parameters: new Dictionary <string, string> { { "p3", "v3" } }); var settings = new RulesSettings(); // Act var testSubject = new DynamicCFamilyRulesConfig(defaultConfig, settings, new TestLogger(), NoExcludedRules); // Assert testSubject.AllPartialRuleKeys.Should().BeEquivalentTo("rule1", "rule2", "rule3"); testSubject.ActivePartialRuleKeys.Should().BeEquivalentTo("rule1", "rule2"); testSubject.LanguageKey.Should().Be("123"); // Other properties should be pass-throughs testSubject.AllPartialRuleKeys.Should().BeEquivalentTo(defaultConfig.AllPartialRuleKeys); testSubject.RulesParameters.Should().BeEquivalentTo(defaultConfig.RulesParameters); testSubject.RulesMetadata.Should().BeEquivalentTo(defaultConfig.RulesMetadata); }
public void EffectiveParameters_CustomSettingsOverrideDefaults() { // Arrange var defaultParams = new Dictionary <string, string> { { "param1", "param 1 default" }, { "param2", "param 2 default" }, { "param3", "param 3 default" }, // expected { "param3a", "param 3a default" }, { "param4", "param 4 default" }, // expected }; var userParams = new Dictionary <string, string> { { "param1", "param 1 user" }, // expected { "PARAM2", "param 2 user" }, // expected { "param3a", "param 3a user" }, // expected - not an exact match for param3, should override param3a // NOTE: params not in the set of default parameters will be included i.e. any arbitrary params set by the user will be included { "NonDefaultParam", "non-default param value" }, // expected }; // Act var effectiveParams = DynamicCFamilyRulesConfig.GetEffectiveParameters(defaultParams, userParams); // Assert effectiveParams.Keys.Should().BeEquivalentTo("param1", "param2", "param3", "param3a", "param4", "NonDefaultParam"); effectiveParams["param1"].Should().Be("param 1 user"); effectiveParams["param2"].Should().Be("param 2 user"); effectiveParams["param3"].Should().Be("param 3 default"); effectiveParams["param3a"].Should().Be("param 3a user"); effectiveParams["param4"].Should().Be("param 4 default"); effectiveParams["NonDefaultParam"].Should().Be("non-default param value"); }
public void Ctor_NullArguments() { var userSettings = new UserSettings(); Action act = () => new DynamicCFamilyRulesConfig(null, userSettings); act.Should().ThrowExactly <ArgumentNullException>().And.ParamName.Should().Be("defaultRulesConfig"); // Null settings should be ok var testSubject = new DynamicCFamilyRulesConfig(new DummyCFamilyRulesConfig("anyLanguage"), null); testSubject.AllPartialRuleKeys.Should().NotBeNull(); testSubject.ActivePartialRuleKeys.Should().NotBeNull(); testSubject.RulesMetadata.Should().NotBeNull(); testSubject.RulesParameters.Should().NotBeNull(); testSubject.LanguageKey.Should().Be("anyLanguage"); }
public void ActiveRules_CustomSettingsOverrideDefaults() { // Arrange var defaultConfig = new DummyCFamilyRulesConfig("c") .AddRule("rule1", isActive: false) .AddRule("rule2", isActive: true) .AddRule("rule3", isActive: true); var settings = new RulesSettings { Rules = new Dictionary <string, RuleConfig> { // Unknown rules should be ignored { "x:unknown1", new RuleConfig { Level = RuleLevel.On } }, // Turn on a rule that was off (case-insensitive comparison on keys) { "c:rule1", new RuleConfig { Level = RuleLevel.On } }, // Turn off a rule that was on { "c:rule2", new RuleConfig { Level = RuleLevel.Off } }, // Rule key comparison is case-sensitive { "c:RULE3", new RuleConfig { Level = RuleLevel.Off } }, // Settings for other languages should be ignored { "cpp:rule3", new RuleConfig { Level = RuleLevel.Off } } } }; // Act var testSubject = new DynamicCFamilyRulesConfig(defaultConfig, settings, new TestLogger(), NoExcludedRules); // Assert testSubject.ActivePartialRuleKeys.Should().BeEquivalentTo("rule1", "rule3"); }
public void EffectiveParameters_NullHandling() { var nonEmptyParams = new Dictionary <string, string> { { "p1", "v1" } }; // 1. Both null -> null returned var actual = DynamicCFamilyRulesConfig.GetEffectiveParameters(null, null); actual.Should().BeNull(); // 2. Null default params -> user params returned (not expected in practice, but we don't want to fail if it does) actual = DynamicCFamilyRulesConfig.GetEffectiveParameters(nonEmptyParams, null); actual.Should().BeEquivalentTo(nonEmptyParams); // 3. Null user params -> default params returned actual = DynamicCFamilyRulesConfig.GetEffectiveParameters(null, nonEmptyParams); actual.Should().BeEquivalentTo(nonEmptyParams); }
public void DisableExcludedRules_NoCustomRules_ExcludedRulesAreDisabled() { // Arrange var testLogger = new TestLogger(); var excluded = new string[] { "excluded" }; var custom = new RulesSettings(); // Act var result = DynamicCFamilyRulesConfig.DisableExcludedRules(custom, excluded, testLogger); // Assert result.Should().NotBeSameAs(custom); custom.Rules.Count.Should().Be(0); result.Rules.Keys.Should().BeEquivalentTo("excluded"); result.Rules["excluded"].Level.Should().Be(RuleLevel.Off); testLogger.AssertPartialOutputStringExists("excluded"); }
public void DisableExcludedRules_NoExcludedRules_CustomRulesReturned() { // Arrange var testLogger = new TestLogger(); var excluded = Array.Empty <string>(); var custom = new RulesSettings() .AddRule("custom1", RuleLevel.On) .AddRule("custom2", RuleLevel.On); // Act var result = DynamicCFamilyRulesConfig.DisableExcludedRules(custom, excluded, testLogger); // Assert result.Should().NotBeSameAs(custom); result.Rules.Keys.Should().BeEquivalentTo("custom1", "custom2"); result.Rules["custom1"].Level.Should().Be(RuleLevel.On); result.Rules["custom2"].Level.Should().Be(RuleLevel.On); }
public void ActiveRules_ExcludedRulesOverrideCustomAndDefaults() { // Arrange const string ExcludedRuleKey = "S9876"; // Enabled the disabled rule in the default confing... var defaultConfig = new DummyCFamilyRulesConfig("c") .AddRule(ExcludedRuleKey, isActive: true) .AddRule("rule2", isActive: true); // ... and in the custom settings var settings = new RulesSettings() .AddRule("c:" + ExcludedRuleKey, RuleLevel.On); // Act var testSubject = new DynamicCFamilyRulesConfig(defaultConfig, settings, new TestLogger(), new string[] { "c:" + ExcludedRuleKey, "WRONGLANGUAGE:rule2" }); // Assert testSubject.AllPartialRuleKeys.Should().BeEquivalentTo(ExcludedRuleKey, "rule2"); // excluded rule is included testSubject.ActivePartialRuleKeys.Should().BeEquivalentTo("rule2"); // ... but not active }
public void EffectiveSeverity_CustomSettingsOverrideDefaults() { // Arrange var defaultConfig = new DummyCFamilyRulesConfig("c") .AddRule("rule1", IssueSeverity.Major, isActive: false) .AddRule("rule2", IssueSeverity.Minor, isActive: true) .AddRule("rule3", IssueSeverity.Info, isActive: true); var settings = new RulesSettings(); // Rule 1 - severity not specified -> should use default settings.Rules["c:rule1"] = new RuleConfig(); // Rule 2 - should override default severity // Rule key comparison should be case-insensitive settings.Rules["c:RULE2"] = new RuleConfig { Severity = IssueSeverity.Blocker }; // Rule 3 for a different language -> should be ignored and the default config used settings.Rules["cpp:rule3"] = new RuleConfig { Severity = IssueSeverity.Critical }; // rule in user settings that isn't in the default config should be ignored settings.Rules["c:missingRule"] = new RuleConfig { Severity = IssueSeverity.Critical }; // Act var dynamicConfig = new DynamicCFamilyRulesConfig(defaultConfig, settings, new TestLogger(), NoExcludedRules); // Assert dynamicConfig.RulesMetadata.Count.Should().Be(3); dynamicConfig.RulesMetadata["rule1"].DefaultSeverity.Should().Be(IssueSeverity.Major); dynamicConfig.RulesMetadata["rule2"].DefaultSeverity.Should().Be(IssueSeverity.Blocker); dynamicConfig.RulesMetadata["rule3"].DefaultSeverity.Should().Be(IssueSeverity.Info); }
public void Parameters_CustomSettingsOverrideDefaults() { // Arrange var defaultConfig = new DummyCFamilyRulesConfig("c") .AddRule("rule1", isActive: false, parameters: new Dictionary <string, string> { { "r1 param1", "r1p1 default" }, { "r1 param2", "r1p2 default" } }) .AddRule("rule2", isActive: true, parameters: new Dictionary <string, string> { { "r2 param1", "r2p1 default" }, { "r2 param2", "r2p2 default" } }) .AddRule("rule3", isActive: true, parameters: new Dictionary <string, string> { { "r3 param1", "r3p1 default" }, { "r3 param2", "r3p2 default" } } ); var settings = new RulesSettings { Rules = new Dictionary <string, RuleConfig> { // Rule 1 - no user params -> same as default // Rule 2 - all default params overridden { "c:rule2", new RuleConfig { Parameters = new Dictionary <string, string> { { "r2 param1", "r2p1 user" }, { "r2 param2", "r2p2 user" } } } }, // Rule 3 - params merged, with user taking priority { "c:rule3", new RuleConfig { Parameters = new Dictionary <string, string> { { "r3 param1", "r3p1 user" }, { "r3 param3", "r3p3 user" } } } } } }; // Act var dynamicConfig = new DynamicCFamilyRulesConfig(defaultConfig, settings, new TestLogger(), NoExcludedRules); // Assert dynamicConfig.RulesParameters.Count.Should().Be(3); dynamicConfig.RulesParameters["rule1"]["r1 param1"].Should().Be("r1p1 default"); dynamicConfig.RulesParameters["rule1"]["r1 param2"].Should().Be("r1p2 default"); dynamicConfig.RulesParameters["rule1"].Count.Should().Be(2); dynamicConfig.RulesParameters["rule2"]["r2 param1"].Should().Be("r2p1 user"); dynamicConfig.RulesParameters["rule2"]["r2 param2"].Should().Be("r2p2 user"); dynamicConfig.RulesParameters["rule2"].Count.Should().Be(2); dynamicConfig.RulesParameters["rule3"]["r3 param1"].Should().Be("r3p1 user"); dynamicConfig.RulesParameters["rule3"]["r3 param2"].Should().Be("r3p2 default"); dynamicConfig.RulesParameters["rule3"]["r3 param3"].Should().Be("r3p3 user"); dynamicConfig.RulesParameters["rule3"].Count.Should().Be(3); }