diff options
Diffstat (limited to 'gitlint-core/gitlint/tests/config')
4 files changed, 755 insertions, 0 deletions
diff --git a/gitlint-core/gitlint/tests/config/test_config.py b/gitlint-core/gitlint/tests/config/test_config.py new file mode 100644 index 0000000..439fd93 --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_config.py @@ -0,0 +1,320 @@ +from unittest.mock import patch + +from gitlint import options, rules +from gitlint.config import ( + GITLINT_CONFIG_TEMPLATE_SRC_PATH, + LintConfig, + LintConfigError, + LintConfigGenerator, +) +from gitlint.tests.base import BaseTestCase + + +class LintConfigTests(BaseTestCase): + def test_set_rule_option(self): + config = LintConfig() + + # assert default title line-length + self.assertEqual(config.get_rule_option("title-max-length", "line-length"), 72) + + # change line length and assert it is set + config.set_rule_option("title-max-length", "line-length", 60) + self.assertEqual(config.get_rule_option("title-max-length", "line-length"), 60) + + def test_set_rule_option_negative(self): + config = LintConfig() + + # non-existing rule + expected_error_msg = "No such rule 'föobar'" + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config.set_rule_option("föobar", "lïne-length", 60) + + # non-existing option + expected_error_msg = "Rule 'title-max-length' has no option 'föobar'" + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config.set_rule_option("title-max-length", "föobar", 60) + + # invalid option value + expected_error_msg = ( + "'föo' is not a valid value for option 'title-max-length.line-length'. " + "Option 'line-length' must be a positive integer (current value: 'föo')." + ) + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config.set_rule_option("title-max-length", "line-length", "föo") + + def test_set_general_option(self): + config = LintConfig() + + # Check that default general options are correct + self.assertTrue(config.ignore_merge_commits) + self.assertTrue(config.ignore_fixup_commits) + self.assertTrue(config.ignore_fixup_amend_commits) + self.assertTrue(config.ignore_squash_commits) + self.assertTrue(config.ignore_revert_commits) + + self.assertFalse(config.ignore_stdin) + self.assertFalse(config.staged) + self.assertFalse(config.fail_without_commits) + self.assertFalse(config.regex_style_search) + self.assertFalse(config.debug) + self.assertEqual(config.verbosity, 3) + active_rule_classes = tuple(type(rule) for rule in config.rules) + self.assertTupleEqual(active_rule_classes, config.default_rule_classes) + + # ignore - set by string + config.set_general_option("ignore", "title-trailing-whitespace, B2") + self.assertEqual(config.ignore, ["title-trailing-whitespace", "B2"]) + + # ignore - set by list + config.set_general_option("ignore", ["T1", "B3"]) + self.assertEqual(config.ignore, ["T1", "B3"]) + + # verbosity + config.set_general_option("verbosity", 1) + self.assertEqual(config.verbosity, 1) + + # ignore_merge_commit + config.set_general_option("ignore-merge-commits", "false") + self.assertFalse(config.ignore_merge_commits) + + # ignore_fixup_commit + config.set_general_option("ignore-fixup-commits", "false") + self.assertFalse(config.ignore_fixup_commits) + + # ignore_fixup_amend_commit + config.set_general_option("ignore-fixup-amend-commits", "false") + self.assertFalse(config.ignore_fixup_amend_commits) + + # ignore_squash_commit + config.set_general_option("ignore-squash-commits", "false") + self.assertFalse(config.ignore_squash_commits) + + # ignore_revert_commit + config.set_general_option("ignore-revert-commits", "false") + self.assertFalse(config.ignore_revert_commits) + + # debug + config.set_general_option("debug", "true") + self.assertTrue(config.debug) + + # ignore-stdin + config.set_general_option("ignore-stdin", "true") + self.assertTrue(config.debug) + + # staged + config.set_general_option("staged", "true") + self.assertTrue(config.staged) + + # fail-without-commits + config.set_general_option("fail-without-commits", "true") + self.assertTrue(config.fail_without_commits) + + # regex-style-search + config.set_general_option("regex-style-search", "true") + self.assertTrue(config.regex_style_search) + + # target + config.set_general_option("target", self.SAMPLES_DIR) + self.assertEqual(config.target, self.SAMPLES_DIR) + + # extra_path has its own test: test_extra_path and test_extra_path_negative + # contrib has its own tests: test_contrib and test_contrib_negative + + def test_contrib(self): + config = LintConfig() + contrib_rules = ["contrib-title-conventional-commits", "CC1"] + config.set_general_option("contrib", ",".join(contrib_rules)) + self.assertEqual(config.contrib, contrib_rules) + + # Check contrib-title-conventional-commits contrib rule + actual_rule = config.rules.find_rule("contrib-title-conventional-commits") + self.assertTrue(actual_rule.is_contrib) + + self.assertEqual(str(type(actual_rule)), "<class 'conventional_commit.ConventionalCommit'>") + self.assertEqual(actual_rule.id, "CT1") + self.assertEqual(actual_rule.name, "contrib-title-conventional-commits") + self.assertEqual(actual_rule.target, rules.CommitMessageTitle) + + expected_rule_option = options.ListOption( + "types", + ["fix", "feat", "chore", "docs", "style", "refactor", "perf", "test", "revert", "ci", "build"], + "Comma separated list of allowed commit types.", + ) + + self.assertListEqual(actual_rule.options_spec, [expected_rule_option]) + self.assertDictEqual(actual_rule.options, {"types": expected_rule_option}) + + # Check contrib-body-requires-signed-off-by contrib rule + actual_rule = config.rules.find_rule("contrib-body-requires-signed-off-by") + self.assertTrue(actual_rule.is_contrib) + + self.assertEqual(str(type(actual_rule)), "<class 'signedoff_by.SignedOffBy'>") + self.assertEqual(actual_rule.id, "CC1") + self.assertEqual(actual_rule.name, "contrib-body-requires-signed-off-by") + + # reset value (this is a different code path) + config.set_general_option("contrib", "contrib-body-requires-signed-off-by") + self.assertEqual(actual_rule, config.rules.find_rule("contrib-body-requires-signed-off-by")) + self.assertIsNone(config.rules.find_rule("contrib-title-conventional-commits")) + + # empty value + config.set_general_option("contrib", "") + self.assertListEqual(config.contrib, []) + + def test_contrib_negative(self): + config = LintConfig() + # non-existent contrib rule + with self.assertRaisesMessage(LintConfigError, "No contrib rule with id or name 'föo' found."): + config.contrib = "contrib-title-conventional-commits,föo" + + # UserRuleError, RuleOptionError should be re-raised as LintConfigErrors + side_effects = [rules.UserRuleError("üser-rule"), options.RuleOptionError("rüle-option")] + for side_effect in side_effects: + with patch("gitlint.config.rule_finder.find_rule_classes", side_effect=side_effect): # noqa: SIM117 + with self.assertRaisesMessage(LintConfigError, str(side_effect)): + config.contrib = "contrib-title-conventional-commits" + + def test_extra_path(self): + config = LintConfig() + + config.set_general_option("extra-path", self.get_user_rules_path()) + self.assertEqual(config.extra_path, self.get_user_rules_path()) + actual_rule = config.rules.find_rule("UC1") + self.assertTrue(actual_rule.is_user_defined) + self.assertEqual(str(type(actual_rule)), "<class 'my_commit_rules.MyUserCommitRule'>") + self.assertEqual(actual_rule.id, "UC1") + self.assertEqual(actual_rule.name, "my-üser-commit-rule") + self.assertEqual(actual_rule.target, None) + expected_rule_option = options.IntOption("violation-count", 1, "Number of violåtions to return") + self.assertListEqual(actual_rule.options_spec, [expected_rule_option]) + self.assertDictEqual(actual_rule.options, {"violation-count": expected_rule_option}) + + # reset value (this is a different code path) + config.set_general_option("extra-path", self.SAMPLES_DIR) + self.assertEqual(config.extra_path, self.SAMPLES_DIR) + self.assertIsNone(config.rules.find_rule("UC1")) + + def test_extra_path_negative(self): + config = LintConfig() + regex = "Option extra-path must be either an existing directory or file (current value: 'föo/bar')" + # incorrect extra_path + with self.assertRaisesMessage(LintConfigError, regex): + config.extra_path = "föo/bar" + + # extra path contains classes with errors + with self.assertRaisesMessage( + LintConfigError, "User-defined rule class 'MyUserLineRule' must have a 'validate' method" + ): + config.extra_path = self.get_sample_path("user_rules/incorrect_linerule") + + def test_set_general_option_negative(self): + config = LintConfig() + + # Note that we shouldn't test whether we can set unicode because python just doesn't allow unicode attributes + with self.assertRaisesMessage(LintConfigError, "'foo' is not a valid gitlint option"): + config.set_general_option("foo", "bår") + + # try setting _config_path, this is a real attribute of LintConfig, but the code should prevent it from + # being set + with self.assertRaisesMessage(LintConfigError, "'_config_path' is not a valid gitlint option"): + config.set_general_option("_config_path", "bår") + + # invalid verbosity + incorrect_values = [-1, "föo"] + for value in incorrect_values: + expected_msg = f"Option 'verbosity' must be a positive integer (current value: '{value}')" + with self.assertRaisesMessage(LintConfigError, expected_msg): + config.verbosity = value + + incorrect_values = [4] + for value in incorrect_values: + with self.assertRaisesMessage(LintConfigError, "Option 'verbosity' must be set between 0 and 3"): + config.verbosity = value + + # invalid ignore_xxx_commits + ignore_attributes = [ + "ignore_merge_commits", + "ignore_fixup_commits", + "ignore_fixup_amend_commits", + "ignore_squash_commits", + "ignore_revert_commits", + ] + incorrect_values = [-1, 4, "föo"] + for attribute in ignore_attributes: + for value in incorrect_values: + option_name = attribute.replace("_", "-") + with self.assertRaisesMessage( + LintConfigError, f"Option '{option_name}' must be either 'true' or 'false'" + ): + setattr(config, attribute, value) + + # invalid ignore -> not here because ignore is a ListOption which converts everything to a string before + # splitting which means it it will accept just about everything + + # invalid boolean options + for attribute in ["debug", "staged", "ignore_stdin", "fail_without_commits", "regex_style_search"]: + option_name = attribute.replace("_", "-") + with self.assertRaisesMessage(LintConfigError, f"Option '{option_name}' must be either 'true' or 'false'"): + setattr(config, attribute, "föobar") + + # extra-path has its own negative test + + # invalid target + with self.assertRaisesMessage( + LintConfigError, "Option target must be an existing directory (current value: 'föo/bar')" + ): + config.target = "föo/bar" + + def test_ignore_independent_from_rules(self): + # Test that the lintconfig rules are not modified when setting config.ignore + # This was different in the past, this test is mostly here to catch regressions + config = LintConfig() + original_rules = config.rules + config.ignore = ["T1", "T2"] + self.assertEqual(config.ignore, ["T1", "T2"]) + self.assertSequenceEqual(config.rules, original_rules) + + def test_config_equality(self): + self.assertEqual(LintConfig(), LintConfig()) + self.assertNotEqual(LintConfig(), LintConfigGenerator()) + + # Ensure LintConfig are not equal if they differ on their attributes + attrs = [ + ("verbosity", 1), + ("rules", []), + ("ignore_stdin", True), + ("fail_without_commits", True), + ("regex_style_search", True), + ("debug", True), + ("ignore", ["T1"]), + ("staged", True), + ("_config_path", self.get_sample_path()), + ("ignore_merge_commits", False), + ("ignore_fixup_commits", False), + ("ignore_fixup_amend_commits", False), + ("ignore_squash_commits", False), + ("ignore_revert_commits", False), + ("extra_path", self.get_sample_path("user_rules")), + ("target", self.get_sample_path()), + ("contrib", ["CC1"]), + ] + for attr, val in attrs: + config = LintConfig() + setattr(config, attr, val) + self.assertNotEqual(LintConfig(), config) + + # Other attributes don't matter + config1 = LintConfig() + config2 = LintConfig() + config1.foo = "bår" + self.assertEqual(config1, config2) + config2.foo = "dūr" + self.assertEqual(config1, config2) + + +class LintConfigGeneratorTests(BaseTestCase): + @staticmethod + @patch("gitlint.config.shutil.copyfile") + def test_install_commit_msg_hook_negative(copy): + LintConfigGenerator.generate_config("föo/bar/test") + copy.assert_called_with(GITLINT_CONFIG_TEMPLATE_SRC_PATH, "föo/bar/test") diff --git a/gitlint-core/gitlint/tests/config/test_config_builder.py b/gitlint-core/gitlint/tests/config/test_config_builder.py new file mode 100644 index 0000000..ac2a896 --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_config_builder.py @@ -0,0 +1,275 @@ +import copy + +from gitlint import rules +from gitlint.config import LintConfig, LintConfigBuilder, LintConfigError +from gitlint.tests.base import BaseTestCase + + +class LintConfigBuilderTests(BaseTestCase): + def test_set_option(self): + config_builder = LintConfigBuilder() + config = config_builder.build() + + # assert some defaults + self.assertEqual(config.get_rule_option("title-max-length", "line-length"), 72) + self.assertEqual(config.get_rule_option("body-max-line-length", "line-length"), 80) + self.assertListEqual(config.get_rule_option("title-must-not-contain-word", "words"), ["WIP"]) + self.assertEqual(config.verbosity, 3) + + # Make some changes and check blueprint + config_builder.set_option("title-max-length", "line-length", 100) + config_builder.set_option("general", "verbosity", 2) + config_builder.set_option("title-must-not-contain-word", "words", ["foo", "bar"]) + expected_blueprint = { + "title-must-not-contain-word": {"words": ["foo", "bar"]}, + "title-max-length": {"line-length": 100}, + "general": {"verbosity": 2}, + } + self.assertDictEqual(config_builder._config_blueprint, expected_blueprint) + + # Build config and verify that the changes have occurred and no other changes + config = config_builder.build() + self.assertEqual(config.get_rule_option("title-max-length", "line-length"), 100) + self.assertEqual(config.get_rule_option("body-max-line-length", "line-length"), 80) # should be unchanged + self.assertListEqual(config.get_rule_option("title-must-not-contain-word", "words"), ["foo", "bar"]) + self.assertEqual(config.verbosity, 2) + + def test_set_from_commit_ignore_all(self): + config = LintConfig() + original_rules = config.rules + original_rule_ids = [rule.id for rule in original_rules] + + config_builder = LintConfigBuilder() + + # nothing gitlint + config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint\nfoo")) + config = config_builder.build() + self.assertSequenceEqual(config.rules, original_rules) + self.assertListEqual(config.ignore, []) + + # ignore all rules + config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore: all\nfoo")) + config = config_builder.build() + self.assertEqual(config.ignore, original_rule_ids) + + # ignore all rules, no space + config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore:all\nfoo")) + config = config_builder.build() + self.assertEqual(config.ignore, original_rule_ids) + + # ignore all rules, more spacing + config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore: \t all\nfoo")) + config = config_builder.build() + self.assertEqual(config.ignore, original_rule_ids) + + def test_set_from_commit_ignore_specific(self): + # ignore specific rules + config_builder = LintConfigBuilder() + config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore: T1, body-hard-tab")) + config = config_builder.build() + self.assertEqual(config.ignore, ["T1", "body-hard-tab"]) + + def test_set_from_config_file(self): + # regular config file load, no problems + config_builder = LintConfigBuilder() + config_builder.set_from_config_file(self.get_sample_path("config/gitlintconfig")) + config = config_builder.build() + + # Do some assertions on the config + self.assertEqual(config.verbosity, 1) + self.assertFalse(config.debug) + self.assertFalse(config.ignore_merge_commits) + self.assertIsNone(config.extra_path) + self.assertEqual(config.ignore, ["title-trailing-whitespace", "B2"]) + + self.assertEqual(config.get_rule_option("title-max-length", "line-length"), 20) + self.assertEqual(config.get_rule_option("body-max-line-length", "line-length"), 30) + + def test_set_from_config_file_negative(self): + config_builder = LintConfigBuilder() + + # bad config file load + foo_path = self.get_sample_path("föo") + expected_error_msg = f"Invalid file path: {foo_path}" + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config_builder.set_from_config_file(foo_path) + + # error during file parsing + path = self.get_sample_path("config/no-sections") + expected_error_msg = "File contains no section headers." + # We only match the start of the message here, since the exact message can vary depending on platform + with self.assertRaisesRegex(LintConfigError, expected_error_msg): + config_builder.set_from_config_file(path) + + # non-existing rule + path = self.get_sample_path("config/nonexisting-rule") + config_builder = LintConfigBuilder() + config_builder.set_from_config_file(path) + expected_error_msg = "No such rule 'föobar'" + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config_builder.build() + + # non-existing general option + path = self.get_sample_path("config/nonexisting-general-option") + config_builder = LintConfigBuilder() + config_builder.set_from_config_file(path) + expected_error_msg = "'foo' is not a valid gitlint option" + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config_builder.build() + + # non-existing option + path = self.get_sample_path("config/nonexisting-option") + config_builder = LintConfigBuilder() + config_builder.set_from_config_file(path) + expected_error_msg = "Rule 'title-max-length' has no option 'föobar'" + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config_builder.build() + + # invalid option value + path = self.get_sample_path("config/invalid-option-value") + config_builder = LintConfigBuilder() + config_builder.set_from_config_file(path) + expected_error_msg = ( + "'föo' is not a valid value for option 'title-max-length.line-length'. " + "Option 'line-length' must be a positive integer (current value: 'föo')." + ) + with self.assertRaisesMessage(LintConfigError, expected_error_msg): + config_builder.build() + + def test_set_config_from_string_list(self): + config = LintConfig() + + # change and assert changes + config_builder = LintConfigBuilder() + config_builder.set_config_from_string_list( + [ + "general.verbosity=1", + "title-max-length.line-length=60", + "body-max-line-length.line-length=120", + "title-must-not-contain-word.words=håha", + ] + ) + + config = config_builder.build() + self.assertEqual(config.get_rule_option("title-max-length", "line-length"), 60) + self.assertEqual(config.get_rule_option("body-max-line-length", "line-length"), 120) + self.assertListEqual(config.get_rule_option("title-must-not-contain-word", "words"), ["håha"]) + self.assertEqual(config.verbosity, 1) + + def test_set_config_from_string_list_negative(self): + config_builder = LintConfigBuilder() + + # assert error on incorrect rule - this happens at build time + config_builder.set_config_from_string_list(["föo.bar=1"]) + with self.assertRaisesMessage(LintConfigError, "No such rule 'föo'"): + config_builder.build() + + # no equal sign + expected_msg = "'föo.bar' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesMessage(LintConfigError, expected_msg): + config_builder.set_config_from_string_list(["föo.bar"]) + + # missing value + expected_msg = "'föo.bar=' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesMessage(LintConfigError, expected_msg): + config_builder.set_config_from_string_list(["föo.bar="]) + + # space instead of equal sign + expected_msg = "'föo.bar 1' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesMessage(LintConfigError, expected_msg): + config_builder.set_config_from_string_list(["föo.bar 1"]) + + # no period between rule and option names + expected_msg = "'föobar=1' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesMessage(LintConfigError, expected_msg): + config_builder.set_config_from_string_list(["föobar=1"]) + + def test_rebuild_config(self): + # normal config build + config_builder = LintConfigBuilder() + config_builder.set_option("general", "verbosity", 3) + lint_config = config_builder.build() + self.assertEqual(lint_config.verbosity, 3) + + # check that existing config gets overwritten when we pass it to a configbuilder with different options + existing_lintconfig = LintConfig() + existing_lintconfig.verbosity = 2 + lint_config = config_builder.build(existing_lintconfig) + self.assertEqual(lint_config.verbosity, 3) + self.assertEqual(existing_lintconfig.verbosity, 3) + + def test_clone(self): + config_builder = LintConfigBuilder() + config_builder.set_option("general", "verbosity", 2) + config_builder.set_option("title-max-length", "line-length", 100) + expected = {"title-max-length": {"line-length": 100}, "general": {"verbosity": 2}} + self.assertDictEqual(config_builder._config_blueprint, expected) + + # Clone and verify that the blueprint is the same as the original + cloned_builder = config_builder.clone() + self.assertDictEqual(cloned_builder._config_blueprint, expected) + + # Modify the original and make sure we're not modifying the clone (i.e. check that the copy is a deep copy) + config_builder.set_option("title-max-length", "line-length", 120) + self.assertDictEqual(cloned_builder._config_blueprint, expected) + + def test_named_rules(self): + # Store a copy of the default rules from the config, so we can reference it later + config_builder = LintConfigBuilder() + config = config_builder.build() + default_rules = copy.deepcopy(config.rules) + self.assertEqual(default_rules, config.rules) # deepcopy should be equal + + # Add a named rule by setting an option in the config builder that follows the named rule pattern + # Assert that whitespace in the rule name is stripped + rule_qualifiers = [ + "T7:my-extra-rüle", + " T7 : my-extra-rüle ", + "\tT7:\tmy-extra-rüle\t", + "T7:\t\n \tmy-extra-rüle\t\n\n", + "title-match-regex:my-extra-rüle", + ] + for rule_qualifier in rule_qualifiers: + config_builder = LintConfigBuilder() + config_builder.set_option(rule_qualifier, "regex", "föo") + + expected_rules = copy.deepcopy(default_rules) + my_rule = rules.TitleRegexMatches({"regex": "föo"}) + my_rule.id = rules.TitleRegexMatches.id + ":my-extra-rüle" + my_rule.name = rules.TitleRegexMatches.name + ":my-extra-rüle" + expected_rules._rules["T7:my-extra-rüle"] = my_rule + self.assertEqual(config_builder.build().rules, expected_rules) + + # assert that changing an option on the newly added rule is passed correctly to the RuleCollection + # we try this with all different rule qualifiers to ensure they all are normalized and map + # to the same rule + for other_rule_qualifier in rule_qualifiers: + cb = config_builder.clone() + cb.set_option(other_rule_qualifier, "regex", other_rule_qualifier + "bōr") + # before setting the expected rule option value correctly, the RuleCollection should be different + self.assertNotEqual(cb.build().rules, expected_rules) + # after setting the option on the expected rule, it should be equal + my_rule.options["regex"].set(other_rule_qualifier + "bōr") + self.assertEqual(cb.build().rules, expected_rules) + my_rule.options["regex"].set("wrong") + + def test_named_rules_negative(self): + # Invalid rule name (T7 = title-match-regex) + for invalid_name in ["", " ", " ", "\t", "\n", "å b", "å:b", "åb:", ":åb"]: + config_builder = LintConfigBuilder() + config_builder.set_option(f"T7:{invalid_name}", "regex", "tëst") + expected_msg = f"The rule-name part in 'T7:{invalid_name}' cannot contain whitespace, colons or be empty" + with self.assertRaisesMessage(LintConfigError, expected_msg): + config_builder.build() + + # Invalid parent rule name + config_builder = LintConfigBuilder() + config_builder.set_option("Ž123:foöbar", "fåke-option", "fåke-value") + with self.assertRaisesMessage(LintConfigError, "No such rule 'Ž123' (named rule: 'Ž123:foöbar')"): + config_builder.build() + + # Invalid option name (this is the same as with regular rules) + config_builder = LintConfigBuilder() + config_builder.set_option("T7:foöbar", "blå", "my-rëgex") + with self.assertRaisesMessage(LintConfigError, "Rule 'T7:foöbar' has no option 'blå'"): + config_builder.build() diff --git a/gitlint-core/gitlint/tests/config/test_config_precedence.py b/gitlint-core/gitlint/tests/config/test_config_precedence.py new file mode 100644 index 0000000..a7f94cf --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_config_precedence.py @@ -0,0 +1,98 @@ +from io import StringIO +from unittest.mock import patch + +from click.testing import CliRunner +from gitlint import cli +from gitlint.config import LintConfigBuilder +from gitlint.tests.base import BaseTestCase + + +class LintConfigPrecedenceTests(BaseTestCase): + def setUp(self): + super().setUp() + self.cli = CliRunner() + + @patch("gitlint.cli.get_stdin_data", return_value="WIP:fö\n\nThis is å test message\n") + def test_config_precedence(self, _): + # TODO(jroovers): this test really only test verbosity, we need to do some refactoring to gitlint.cli + # to more easily test everything + # Test that the config precedence is followed: + # 1. commandline convenience flags + # 2. environment variables + # 3. commandline -c flags + # 4. config file + # 5. default config + config_path = self.get_sample_path("config/gitlintconfig") + + # 1. commandline convenience flags + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["-vvv", "-c", "general.verbosity=2", "--config", config_path]) + self.assertEqual(result.output, "") + self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP:fö\"\n") + + # 2. environment variables + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke( + cli.cli, ["-c", "general.verbosity=2", "--config", config_path], env={"GITLINT_VERBOSITY": "3"} + ) + self.assertEqual(result.output, "") + self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP:fö\"\n") + + # 3. commandline -c flags + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["-c", "general.verbosity=2", "--config", config_path]) + self.assertEqual(result.output, "") + self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive)\n") + + # 4. config file + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--config", config_path]) + self.assertEqual(result.output, "") + self.assertEqual(stderr.getvalue(), "1: T5\n") + + # 5. default config + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli) + self.assertEqual(result.output, "") + self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP:fö\"\n") + + @patch("gitlint.cli.get_stdin_data", return_value="WIP: This is å test") + def test_ignore_precedence(self, get_stdin_data): + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + # --ignore takes precedence over -c general.ignore + result = self.cli.invoke(cli.cli, ["-c", "general.ignore=T5", "--ignore", "B6"]) + self.assertEqual(result.output, "") + self.assertEqual(result.exit_code, 1) + # We still expect the T5 violation, but no B6 violation as --ignore overwrites -c general.ignore + self.assertEqual( + stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP: This is å test\"\n" + ) + + # test that we can also still configure a rule that is first ignored but then not + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + get_stdin_data.return_value = "This is å test" + # --ignore takes precedence over -c general.ignore + result = self.cli.invoke( + cli.cli, + ["-c", "general.ignore=title-max-length", "-c", "title-max-length.line-length=5", "--ignore", "B6"], + ) + self.assertEqual(result.output, "") + self.assertEqual(result.exit_code, 1) + + # We still expect the T1 violation with custom config, + # but no B6 violation as --ignore overwrites -c general.ignore + self.assertEqual(stderr.getvalue(), '1: T1 Title exceeds max length (14>5): "This is å test"\n') + + def test_general_option_after_rule_option(self): + # We used to have a bug where we didn't process general options before setting specific options, this would + # lead to errors when e.g.: trying to configure a user rule before the rule class was loaded by extra-path + # This test is here to test for regressions against this. + + config_builder = LintConfigBuilder() + config_builder.set_option("my-üser-commit-rule", "violation-count", 3) + user_rules_path = self.get_sample_path("user_rules") + config_builder.set_option("general", "extra-path", user_rules_path) + config = config_builder.build() + + self.assertEqual(config.extra_path, user_rules_path) + self.assertEqual(config.get_rule_option("my-üser-commit-rule", "violation-count"), 3) diff --git a/gitlint-core/gitlint/tests/config/test_rule_collection.py b/gitlint-core/gitlint/tests/config/test_rule_collection.py new file mode 100644 index 0000000..2cb0e5c --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_rule_collection.py @@ -0,0 +1,62 @@ +from collections import OrderedDict + +from gitlint import rules +from gitlint.config import RuleCollection +from gitlint.tests.base import BaseTestCase + + +class RuleCollectionTests(BaseTestCase): + def test_add_rule(self): + collection = RuleCollection() + collection.add_rule(rules.TitleMaxLength, "my-rüle", {"my_attr": "föo", "my_attr2": 123}) + + expected = rules.TitleMaxLength() + expected.id = "my-rüle" + expected.my_attr = "föo" + expected.my_attr2 = 123 + + self.assertEqual(len(collection), 1) + self.assertDictEqual(collection._rules, OrderedDict({"my-rüle": expected})) + # Need to explicitly compare expected attributes as the rule.__eq__ method does not compare these attributes + self.assertEqual(collection._rules[expected.id].my_attr, expected.my_attr) + self.assertEqual(collection._rules[expected.id].my_attr2, expected.my_attr2) + + def test_add_find_rule(self): + collection = RuleCollection() + collection.add_rules([rules.TitleMaxLength, rules.TitleTrailingWhitespace], {"my_attr": "föo"}) + + # find by id + expected = rules.TitleMaxLength() + rule = collection.find_rule("T1") + self.assertEqual(rule, expected) + self.assertEqual(rule.my_attr, "föo") + + # find by name + expected2 = rules.TitleTrailingWhitespace() + rule = collection.find_rule("title-trailing-whitespace") + self.assertEqual(rule, expected2) + self.assertEqual(rule.my_attr, "föo") + + # find non-existing + rule = collection.find_rule("föo") + self.assertIsNone(rule) + + def test_delete_rules_by_attr(self): + collection = RuleCollection() + collection.add_rules([rules.TitleMaxLength, rules.TitleTrailingWhitespace], {"foo": "bår"}) + collection.add_rules([rules.BodyHardTab], {"hur": "dûr"}) + + # Assert all rules are there as expected + self.assertEqual(len(collection), 3) + for expected_rule in [rules.TitleMaxLength(), rules.TitleTrailingWhitespace(), rules.BodyHardTab()]: + self.assertEqual(collection.find_rule(expected_rule.id), expected_rule) + + # Delete rules by attr, assert that we still have the right rules in the collection + collection.delete_rules_by_attr("foo", "bår") + self.assertEqual(len(collection), 1) + self.assertIsNone(collection.find_rule(rules.TitleMaxLength.id), None) + self.assertIsNone(collection.find_rule(rules.TitleTrailingWhitespace.id), None) + + found = collection.find_rule(rules.BodyHardTab.id) + self.assertEqual(found, rules.BodyHardTab()) + self.assertEqual(found.hur, "dûr") |