Adding upstream version 0.17.0.upstream/0.17.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 0 insertions, 713 deletions

diff --git a/gitlint/tests/config/test_config.py b/gitlint/tests/config/test_config.py
deleted file mode 100644
index c3fd78a..0000000
--- a/gitlint/tests/config/test_config.py
+++ /dev/null
@@ -1,287 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from unittest.mock import patch
-
-from gitlint import rules
-from gitlint.config import LintConfig, LintConfigError, LintConfigGenerator, GITLINT_CONFIG_TEMPLATE_SRC_PATH
-from gitlint import options
-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(u'föobar', u'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', u'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_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.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_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)
-
-        # 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, u'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, u'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):
-                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, u'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_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']:
-            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), ("debug", True),
-                 ("ignore", ["T1"]), ("staged", True), ("_config_path", self.get_sample_path()),
-                 ("ignore_merge_commits", False), ("ignore_fixup_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/tests/config/test_config_builder.py b/gitlint/tests/config/test_config_builder.py
deleted file mode 100644
index e0d7f9b..0000000
--- a/gitlint/tests/config/test_config_builder.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# -*- coding: utf-8 -*-
-import copy
-
-from gitlint.tests.base import BaseTestCase
-
-from gitlint.config import LintConfig, LintConfigBuilder, LintConfigError
-
-from gitlint import rules
-
-
-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([u'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 = [u'T7:my-extra-rüle', u' T7 :   my-extra-rüle  ', u'\tT7:\tmy-extra-rüle\t',
-                           u'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[u'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):
-        # T7 = title-match-regex
-        # Invalid rule name
-        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/tests/config/test_config_precedence.py b/gitlint/tests/config/test_config_precedence.py
deleted file mode 100644
index aa4de88..0000000
--- a/gitlint/tests/config/test_config_precedence.py
+++ /dev/null
@@ -1,98 +0,0 @@
-# -*- coding: utf-8 -*-
-
-from io import StringIO
-
-from click.testing import CliRunner
-
-from unittest.mock import patch
-
-from gitlint.tests.base import BaseTestCase
-from gitlint import cli
-from gitlint.config import LintConfigBuilder
-
-
-class LintConfigPrecedenceTests(BaseTestCase):
-    def setUp(self):
-        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(u'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(u'my-üser-commit-rule', 'violation-count'), 3)
diff --git a/gitlint/tests/config/test_rule_collection.py b/gitlint/tests/config/test_rule_collection.py
deleted file mode 100644
index 5a50be0..0000000
--- a/gitlint/tests/config/test_rule_collection.py
+++ /dev/null
@@ -1,64 +0,0 @@
-# -*- coding: utf-8 -*-
-
-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 explicitely 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(u'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")