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);
}
