Adding upstream version 0.15.0.upstream/0.15.0

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

6 files changed, 157 insertions, 157 deletions

diff --git a/gitlint/tests/rules/test_body_rules.py b/gitlint/tests/rules/test_body_rules.py
index f46760b..96ae998 100644
--- a/gitlint/tests/rules/test_body_rules.py
+++ b/gitlint/tests/rules/test_body_rules.py
@@ -8,65 +8,65 @@ class BodyRuleTests(BaseTestCase):
         rule = rules.BodyMaxLineLength()
 
         # assert no error
-        violation = rule.validate(u"å" * 80, None)
+        violation = rule.validate("å" * 80, None)
         self.assertIsNone(violation)
 
         # assert error on line length > 80
-        expected_violation = rules.RuleViolation("B1", "Line exceeds max length (81>80)", u"å" * 81)
-        violations = rule.validate(u"å" * 81, None)
+        expected_violation = rules.RuleViolation("B1", "Line exceeds max length (81>80)", "å" * 81)
+        violations = rule.validate("å" * 81, None)
         self.assertListEqual(violations, [expected_violation])
 
         # set line length to 120, and check no violation on length 73
         rule = rules.BodyMaxLineLength({'line-length': 120})
-        violations = rule.validate(u"å" * 73, None)
+        violations = rule.validate("å" * 73, None)
         self.assertIsNone(violations)
 
         # assert raise on 121
-        expected_violation = rules.RuleViolation("B1", "Line exceeds max length (121>120)", u"å" * 121)
-        violations = rule.validate(u"å" * 121, None)
+        expected_violation = rules.RuleViolation("B1", "Line exceeds max length (121>120)", "å" * 121)
+        violations = rule.validate("å" * 121, None)
         self.assertListEqual(violations, [expected_violation])
 
     def test_trailing_whitespace(self):
         rule = rules.BodyTrailingWhitespace()
 
         # assert no error
-        violations = rule.validate(u"å", None)
+        violations = rule.validate("å", None)
         self.assertIsNone(violations)
 
         # trailing space
-        expected_violation = rules.RuleViolation("B2", "Line has trailing whitespace", u"å ")
-        violations = rule.validate(u"å ", None)
+        expected_violation = rules.RuleViolation("B2", "Line has trailing whitespace", "å ")
+        violations = rule.validate("å ", None)
         self.assertListEqual(violations, [expected_violation])
 
         # trailing tab
-        expected_violation = rules.RuleViolation("B2", "Line has trailing whitespace", u"å\t")
-        violations = rule.validate(u"å\t", None)
+        expected_violation = rules.RuleViolation("B2", "Line has trailing whitespace", "å\t")
+        violations = rule.validate("å\t", None)
         self.assertListEqual(violations, [expected_violation])
 
     def test_hard_tabs(self):
         rule = rules.BodyHardTab()
 
         # assert no error
-        violations = rule.validate(u"This is ã test", None)
+        violations = rule.validate("This is ã test", None)
         self.assertIsNone(violations)
 
         # contains hard tab
-        expected_violation = rules.RuleViolation("B3", "Line contains hard tab characters (\\t)", u"This is å\ttest")
-        violations = rule.validate(u"This is å\ttest", None)
+        expected_violation = rules.RuleViolation("B3", "Line contains hard tab characters (\\t)", "This is å\ttest")
+        violations = rule.validate("This is å\ttest", None)
         self.assertListEqual(violations, [expected_violation])
 
     def test_body_first_line_empty(self):
         rule = rules.BodyFirstLineEmpty()
 
         # assert no error
-        commit = self.gitcommit(u"Tïtle\n\nThis is the secōnd body line")
+        commit = self.gitcommit("Tïtle\n\nThis is the secōnd body line")
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # second line not empty
-        expected_violation = rules.RuleViolation("B4", "Second line is not empty", u"nöt empty", 2)
+        expected_violation = rules.RuleViolation("B4", "Second line is not empty", "nöt empty", 2)
 
-        commit = self.gitcommit(u"Tïtle\nnöt empty\nThis is the secönd body line")
+        commit = self.gitcommit("Tïtle\nnöt empty\nThis is the secönd body line")
         violations = rule.validate(commit)
         self.assertListEqual(violations, [expected_violation])
 
@@ -80,34 +80,34 @@ class BodyRuleTests(BaseTestCase):
         self.assertIsNone(violations)
 
         # assert no error - no body
-        commit = self.gitcommit(u"Tïtle\n")
+        commit = self.gitcommit("Tïtle\n")
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # body is too short
-        expected_violation = rules.RuleViolation("B5", "Body message is too short (8<20)", u"töoshort", 3)
+        expected_violation = rules.RuleViolation("B5", "Body message is too short (8<20)", "töoshort", 3)
 
-        commit = self.gitcommit(u"Tïtle\n\ntöoshort\n")
+        commit = self.gitcommit("Tïtle\n\ntöoshort\n")
         violations = rule.validate(commit)
         self.assertListEqual(violations, [expected_violation])
 
         # assert error - short across multiple lines
-        expected_violation = rules.RuleViolation("B5", "Body message is too short (11<20)", u"secöndthïrd", 3)
-        commit = self.gitcommit(u"Tïtle\n\nsecönd\nthïrd\n")
+        expected_violation = rules.RuleViolation("B5", "Body message is too short (11<20)", "secöndthïrd", 3)
+        commit = self.gitcommit("Tïtle\n\nsecönd\nthïrd\n")
         violations = rule.validate(commit)
         self.assertListEqual(violations, [expected_violation])
 
         # set line length to 120, and check violation on length 21
-        expected_violation = rules.RuleViolation("B5", "Body message is too short (21<120)", u"å" * 21, 3)
+        expected_violation = rules.RuleViolation("B5", "Body message is too short (21<120)", "å" * 21, 3)
 
         rule = rules.BodyMinLength({'min-length': 120})
-        commit = self.gitcommit(u"Title\n\n%s\n" % (u"å" * 21))
+        commit = self.gitcommit("Title\n\n%s\n" % ("å" * 21))
         violations = rule.validate(commit)
         self.assertListEqual(violations, [expected_violation])
 
         # Make sure we don't get the error if the body-length is exactly the min-length
         rule = rules.BodyMinLength({'min-length': 8})
-        commit = self.gitcommit(u"Tïtle\n\n%s\n" % (u"å" * 8))
+        commit = self.gitcommit("Tïtle\n\n%s\n" % ("å" * 8))
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
@@ -115,14 +115,14 @@ class BodyRuleTests(BaseTestCase):
         rule = rules.BodyMissing()
 
         # assert no error - body is present
-        commit = self.gitcommit(u"Tïtle\n\nThis ïs the first body line\n")
+        commit = self.gitcommit("Tïtle\n\nThis ïs the first body line\n")
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # body is too short
         expected_violation = rules.RuleViolation("B6", "Body message is missing", None, 3)
 
-        commit = self.gitcommit(u"Tïtle\n")
+        commit = self.gitcommit("Tïtle\n")
         violations = rule.validate(commit)
         self.assertListEqual(violations, [expected_violation])
 
@@ -130,7 +130,7 @@ class BodyRuleTests(BaseTestCase):
         rule = rules.BodyMissing()
 
         # assert no error - merge commit
-        commit = self.gitcommit(u"Merge: Tïtle\n")
+        commit = self.gitcommit("Merge: Tïtle\n")
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
@@ -144,37 +144,37 @@ class BodyRuleTests(BaseTestCase):
         rule = rules.BodyChangedFileMention()
 
         # assert no error when no files have changed and no files need to be mentioned
-        commit = self.gitcommit(u"This is a test\n\nHere is a mention of föo/test.py")
+        commit = self.gitcommit("This is a test\n\nHere is a mention of föo/test.py")
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # assert no error when no files have changed but certain files need to be mentioned on change
-        rule = rules.BodyChangedFileMention({'files': u"bar.txt,föo/test.py"})
-        commit = self.gitcommit(u"This is a test\n\nHere is a mention of föo/test.py")
+        rule = rules.BodyChangedFileMention({'files': "bar.txt,föo/test.py"})
+        commit = self.gitcommit("This is a test\n\nHere is a mention of föo/test.py")
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # assert no error if a file has changed and is mentioned
-        commit = self.gitcommit(u"This is a test\n\nHere is a mention of föo/test.py", [u"föo/test.py"])
+        commit = self.gitcommit("This is a test\n\nHere is a mention of föo/test.py", ["föo/test.py"])
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # assert no error if multiple files have changed and are mentioned
-        commit_msg = u"This is a test\n\nHere is a mention of föo/test.py\nAnd here is a mention of bar.txt"
-        commit = self.gitcommit(commit_msg, [u"föo/test.py", "bar.txt"])
+        commit_msg = "This is a test\n\nHere is a mention of föo/test.py\nAnd here is a mention of bar.txt"
+        commit = self.gitcommit(commit_msg, ["föo/test.py", "bar.txt"])
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # assert error if file has changed and is not mentioned
-        commit_msg = u"This is a test\n\nHere is å mention of\nAnd here is a mention of bar.txt"
-        commit = self.gitcommit(commit_msg, [u"föo/test.py", "bar.txt"])
+        commit_msg = "This is a test\n\nHere is å mention of\nAnd here is a mention of bar.txt"
+        commit = self.gitcommit(commit_msg, ["föo/test.py", "bar.txt"])
         violations = rule.validate(commit)
-        expected_violation = rules.RuleViolation("B7", u"Body does not mention changed file 'föo/test.py'", None, 4)
+        expected_violation = rules.RuleViolation("B7", "Body does not mention changed file 'föo/test.py'", None, 4)
         self.assertEqual([expected_violation], violations)
 
         # assert multiple errors if  multiple files habe changed and are not mentioned
-        commit_msg = u"This is å test\n\nHere is a mention of\nAnd here is a mention of"
-        commit = self.gitcommit(commit_msg, [u"föo/test.py", "bar.txt"])
+        commit_msg = "This is å test\n\nHere is a mention of\nAnd here is a mention of"
+        commit = self.gitcommit(commit_msg, ["föo/test.py", "bar.txt"])
         violations = rule.validate(commit)
         expected_violation_2 = rules.RuleViolation("B7", "Body does not mention changed file 'bar.txt'", None, 4)
         self.assertEqual([expected_violation_2, expected_violation], violations)
@@ -182,7 +182,7 @@ class BodyRuleTests(BaseTestCase):
     def test_body_match_regex(self):
         # We intentionally add 2 newlines at the end of our commit message as that's how git will pass the
         # message. This way we also test that the rule strips off the last line.
-        commit = self.gitcommit(u"US1234: åbc\nIgnored\nBödy\nFöo\nMy-Commit-Tag: föo\n\n")
+        commit = self.gitcommit("US1234: åbc\nIgnored\nBödy\nFöo\nMy-Commit-Tag: föo\n\n")
 
         # assert no violation on default regex (=everything allowed)
         rule = rules.BodyRegexMatches()
@@ -191,25 +191,25 @@ class BodyRuleTests(BaseTestCase):
 
         # assert no violation on matching regex
         # (also note that first body line - in between title and rest of body - is ignored)
-        rule = rules.BodyRegexMatches({'regex': u"^Bödy(.*)"})
+        rule = rules.BodyRegexMatches({'regex': "^Bödy(.*)"})
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # assert we can do end matching (and last empty line is ignored)
         # (also note that first body line - in between title and rest of body - is ignored)
-        rule = rules.BodyRegexMatches({'regex': u"My-Commit-Tag: föo$"})
+        rule = rules.BodyRegexMatches({'regex': "My-Commit-Tag: föo$"})
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # common use-case: matching that a given line is present
-        rule = rules.BodyRegexMatches({'regex': u"(.*)Föo(.*)"})
+        rule = rules.BodyRegexMatches({'regex': "(.*)Föo(.*)"})
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # assert violation on non-matching body
-        rule = rules.BodyRegexMatches({'regex': u"^Tëst(.*)Foo"})
+        rule = rules.BodyRegexMatches({'regex': "^Tëst(.*)Foo"})
         violations = rule.validate(commit)
-        expected_violation = rules.RuleViolation("B8", u"Body does not match regex (^Tëst(.*)Foo)", None, 6)
+        expected_violation = rules.RuleViolation("B8", "Body does not match regex (^Tëst(.*)Foo)", None, 6)
         self.assertListEqual(violations, [expected_violation])
 
         # assert no violation on None regex
@@ -218,7 +218,7 @@ class BodyRuleTests(BaseTestCase):
         self.assertIsNone(violations)
 
         # Assert no issues when there's no body or a weird body variation
-        bodies = [u"åbc", u"åbc\n", u"åbc\nföo\n", u"åbc\n\n", u"åbc\nföo\nblå", u"åbc\nföo\nblå\n"]
+        bodies = ["åbc", "åbc\n", "åbc\nföo\n", "åbc\n\n", "åbc\nföo\nblå", "åbc\nföo\nblå\n"]
         for body in bodies:
             commit = self.gitcommit(body)
             rule = rules.BodyRegexMatches({'regex': ".*"})
diff --git a/gitlint/tests/rules/test_configuration_rules.py b/gitlint/tests/rules/test_configuration_rules.py
index 121cb3a..479d9c2 100644
--- a/gitlint/tests/rules/test_configuration_rules.py
+++ b/gitlint/tests/rules/test_configuration_rules.py
@@ -6,7 +6,7 @@ from gitlint.config import LintConfig
 
 class ConfigurationRuleTests(BaseTestCase):
     def test_ignore_by_title(self):
-        commit = self.gitcommit(u"Releäse\n\nThis is the secōnd body line")
+        commit = self.gitcommit("Releäse\n\nThis is the secōnd body line")
 
         # No regex specified -> Config shouldn't be changed
         rule = rules.IgnoreByTitle()
@@ -16,29 +16,29 @@ class ConfigurationRuleTests(BaseTestCase):
         self.assert_logged([])  # nothing logged -> nothing ignored
 
         # Matching regex -> expect config to ignore all rules
-        rule = rules.IgnoreByTitle({"regex": u"^Releäse(.*)"})
+        rule = rules.IgnoreByTitle({"regex": "^Releäse(.*)"})
         expected_config = LintConfig()
         expected_config.ignore = "all"
         rule.apply(config, commit)
         self.assertEqual(config, expected_config)
 
-        expected_log_message = u"DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + \
-            u"Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: all"
+        expected_log_message = "DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + \
+            "Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: all"
         self.assert_log_contains(expected_log_message)
 
         # Matching regex with specific ignore
-        rule = rules.IgnoreByTitle({"regex": u"^Releäse(.*)",
+        rule = rules.IgnoreByTitle({"regex": "^Releäse(.*)",
                                     "ignore": "T1,B2"})
         expected_config = LintConfig()
         expected_config.ignore = "T1,B2"
         rule.apply(config, commit)
         self.assertEqual(config, expected_config)
 
-        expected_log_message = u"DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + \
-            u"Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: T1,B2"
+        expected_log_message = "DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + \
+            "Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: T1,B2"
 
     def test_ignore_by_body(self):
-        commit = self.gitcommit(u"Tïtle\n\nThis is\n a relëase body\n line")
+        commit = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line")
 
         # No regex specified -> Config shouldn't be changed
         rule = rules.IgnoreByBody()
@@ -48,32 +48,32 @@ class ConfigurationRuleTests(BaseTestCase):
         self.assert_logged([])  # nothing logged -> nothing ignored
 
         # Matching regex -> expect config to ignore all rules
-        rule = rules.IgnoreByBody({"regex": u"(.*)relëase(.*)"})
+        rule = rules.IgnoreByBody({"regex": "(.*)relëase(.*)"})
         expected_config = LintConfig()
         expected_config.ignore = "all"
         rule.apply(config, commit)
         self.assertEqual(config, expected_config)
 
-        expected_log_message = u"DEBUG: gitlint.rules Ignoring commit because of rule 'I2': " + \
-                               u"Commit message line ' a relëase body' matches the regex '(.*)relëase(.*)'," + \
-                               u" ignoring rules: all"
+        expected_log_message = "DEBUG: gitlint.rules Ignoring commit because of rule 'I2': " + \
+                               "Commit message line ' a relëase body' matches the regex '(.*)relëase(.*)'," + \
+                               " ignoring rules: all"
         self.assert_log_contains(expected_log_message)
 
         # Matching regex with specific ignore
-        rule = rules.IgnoreByBody({"regex": u"(.*)relëase(.*)",
+        rule = rules.IgnoreByBody({"regex": "(.*)relëase(.*)",
                                    "ignore": "T1,B2"})
         expected_config = LintConfig()
         expected_config.ignore = "T1,B2"
         rule.apply(config, commit)
         self.assertEqual(config, expected_config)
 
-        expected_log_message = u"DEBUG: gitlint.rules Ignoring commit because of rule 'I2': " + \
-            u"Commit message line ' a relëase body' matches the regex '(.*)relëase(.*)', ignoring rules: T1,B2"
+        expected_log_message = "DEBUG: gitlint.rules Ignoring commit because of rule 'I2': " + \
+            "Commit message line ' a relëase body' matches the regex '(.*)relëase(.*)', ignoring rules: T1,B2"
         self.assert_log_contains(expected_log_message)
 
     def test_ignore_body_lines(self):
-        commit1 = self.gitcommit(u"Tïtle\n\nThis is\n a relëase body\n line")
-        commit2 = self.gitcommit(u"Tïtle\n\nThis is\n a relëase body\n line")
+        commit1 = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line")
+        commit2 = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line")
 
         # no regex specified, nothing should have happened:
         # commit and config should remain identical, log should be empty
@@ -85,22 +85,22 @@ class ConfigurationRuleTests(BaseTestCase):
         self.assert_logged([])
 
         # Matching regex
-        rule = rules.IgnoreBodyLines({"regex": u"(.*)relëase(.*)"})
+        rule = rules.IgnoreBodyLines({"regex": "(.*)relëase(.*)"})
         config = LintConfig()
         rule.apply(config, commit1)
         # Our modified commit should be identical to a commit that doesn't contain the specific line
-        expected_commit = self.gitcommit(u"Tïtle\n\nThis is\n line")
+        expected_commit = self.gitcommit("Tïtle\n\nThis is\n line")
         # The original message isn't touched by this rule, this way we always have a way to reference back to it,
         # so assert it's not modified by setting it to the same as commit1
         expected_commit.message.original = commit1.message.original
         self.assertEqual(commit1, expected_commit)
         self.assertEqual(config, LintConfig())  # config shouldn't have been modified
-        self.assert_log_contains(u"DEBUG: gitlint.rules Ignoring line ' a relëase body' because it " +
-                                 u"matches '(.*)relëase(.*)'")
+        self.assert_log_contains("DEBUG: gitlint.rules Ignoring line ' a relëase body' because it " +
+                                 "matches '(.*)relëase(.*)'")
 
         # Non-Matching regex: no changes expected
-        commit1 = self.gitcommit(u"Tïtle\n\nThis is\n a relëase body\n line")
-        rule = rules.IgnoreBodyLines({"regex": u"(.*)föobar(.*)"})
+        commit1 = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line")
+        rule = rules.IgnoreBodyLines({"regex": "(.*)föobar(.*)"})
         config = LintConfig()
         rule.apply(config, commit1)
         self.assertEqual(commit1, commit2)
diff --git a/gitlint/tests/rules/test_meta_rules.py b/gitlint/tests/rules/test_meta_rules.py
index 987aa88..568ca3f 100644
--- a/gitlint/tests/rules/test_meta_rules.py
+++ b/gitlint/tests/rules/test_meta_rules.py
@@ -8,25 +8,25 @@ class MetaRuleTests(BaseTestCase):
         rule = AuthorValidEmail()
 
         # valid email addresses
-        valid_email_addresses = [u"föo@bar.com", u"Jöhn.Doe@bar.com", u"jöhn+doe@bar.com", u"jöhn/doe@bar.com",
-                                 u"jöhn.doe@subdomain.bar.com"]
+        valid_email_addresses = ["föo@bar.com", "Jöhn.Doe@bar.com", "jöhn+doe@bar.com", "jöhn/doe@bar.com",
+                                 "jöhn.doe@subdomain.bar.com"]
         for email in valid_email_addresses:
-            commit = self.gitcommit(u"", author_email=email)
+            commit = self.gitcommit("", author_email=email)
             violations = rule.validate(commit)
             self.assertIsNone(violations)
 
         # No email address (=allowed for now, as gitlint also lints messages passed via stdin that don't have an
         # email address)
-        commit = self.gitcommit(u"")
+        commit = self.gitcommit("")
         violations = rule.validate(commit)
         self.assertIsNone(violations)
 
         # Invalid email addresses: no TLD, no domain, no @, space anywhere (=valid but not allowed by gitlint)
-        invalid_email_addresses = [u"föo@bar", u"JöhnDoe", u"Jöhn Doe", u"Jöhn Doe@foo.com", u" JöhnDoe@foo.com",
-                                   u"JöhnDoe@ foo.com", u"JöhnDoe@foo. com", u"JöhnDoe@foo. com", u"@bår.com",
-                                   u"föo@.com"]
+        invalid_email_addresses = ["föo@bar", "JöhnDoe", "Jöhn Doe", "Jöhn Doe@foo.com", " JöhnDoe@foo.com",
+                                   "JöhnDoe@ foo.com", "JöhnDoe@foo. com", "JöhnDoe@foo. com", "@bår.com",
+                                   "föo@.com"]
         for email in invalid_email_addresses:
-            commit = self.gitcommit(u"", author_email=email)
+            commit = self.gitcommit("", author_email=email)
             violations = rule.validate(commit)
             self.assertListEqual(violations,
                                  [RuleViolation("M1", "Author email for commit is invalid", email)])
@@ -35,25 +35,25 @@ class MetaRuleTests(BaseTestCase):
         # regex=None -> the rule isn't applied
         rule = AuthorValidEmail()
         rule.options['regex'].set(None)
-        emailadresses = [u"föo", None, u"hür dür"]
+        emailadresses = ["föo", None, "hür dür"]
         for email in emailadresses:
-            commit = self.gitcommit(u"", author_email=email)
+            commit = self.gitcommit("", author_email=email)
             violations = rule.validate(commit)
             self.assertIsNone(violations)
 
         # Custom domain
-        rule = AuthorValidEmail({'regex': u"[^@]+@bår.com"})
+        rule = AuthorValidEmail({'regex': "[^@]+@bår.com"})
         valid_email_addresses = [
-            u"föo@bår.com", u"Jöhn.Doe@bår.com", u"jöhn+doe@bår.com", u"jöhn/doe@bår.com"]
+            "föo@bår.com", "Jöhn.Doe@bår.com", "jöhn+doe@bår.com", "jöhn/doe@bår.com"]
         for email in valid_email_addresses:
-            commit = self.gitcommit(u"", author_email=email)
+            commit = self.gitcommit("", author_email=email)
             violations = rule.validate(commit)
             self.assertIsNone(violations)
 
         # Invalid email addresses
-        invalid_email_addresses = [u"föo@hur.com"]
+        invalid_email_addresses = ["föo@hur.com"]
         for email in invalid_email_addresses:
-            commit = self.gitcommit(u"", author_email=email)
+            commit = self.gitcommit("", author_email=email)
             violations = rule.validate(commit)
             self.assertListEqual(violations,
                                  [RuleViolation("M1", "Author email for commit is invalid", email)])
diff --git a/gitlint/tests/rules/test_rules.py b/gitlint/tests/rules/test_rules.py
index 58ee1c3..6fcf9bc 100644
--- a/gitlint/tests/rules/test_rules.py
+++ b/gitlint/tests/rules/test_rules.py
@@ -10,14 +10,14 @@ class RuleTests(BaseTestCase):
         # Ensure rules are not equal if they differ on their attributes
         for attr in ["id", "name", "target", "options"]:
             rule = Rule()
-            setattr(rule, attr, u"åbc")
+            setattr(rule, attr, "åbc")
             self.assertNotEqual(Rule(), rule)
 
     def test_rule_log(self):
         rule = Rule()
-        rule.log.debug(u"Tēst message")
-        self.assert_log_contains(u"DEBUG: gitlint.rules Tēst message")
+        rule.log.debug("Tēst message")
+        self.assert_log_contains("DEBUG: gitlint.rules Tēst message")
 
     def test_rule_violation_equality(self):
-        violation1 = RuleViolation(u"ïd1", u"My messåge", u"My cöntent", 1)
+        violation1 = RuleViolation("ïd1", "My messåge", "My cöntent", 1)
         self.object_equality_test(violation1, ["rule_id", "message", "content", "line_nr"])
diff --git a/gitlint/tests/rules/test_title_rules.py b/gitlint/tests/rules/test_title_rules.py
index 049735e..e1be857 100644
--- a/gitlint/tests/rules/test_title_rules.py
+++ b/gitlint/tests/rules/test_title_rules.py
@@ -9,66 +9,66 @@ class TitleRuleTests(BaseTestCase):
         rule = TitleMaxLength()
 
         # assert no error
-        violation = rule.validate(u"å" * 72, None)
+        violation = rule.validate("å" * 72, None)
         self.assertIsNone(violation)
 
         # assert error on line length > 72
-        expected_violation = RuleViolation("T1", "Title exceeds max length (73>72)", u"å" * 73)
-        violations = rule.validate(u"å" * 73, None)
+        expected_violation = RuleViolation("T1", "Title exceeds max length (73>72)", "å" * 73)
+        violations = rule.validate("å" * 73, None)
         self.assertListEqual(violations, [expected_violation])
 
         # set line length to 120, and check no violation on length 73
         rule = TitleMaxLength({'line-length': 120})
-        violations = rule.validate(u"å" * 73, None)
+        violations = rule.validate("å" * 73, None)
         self.assertIsNone(violations)
 
         # assert raise on 121
-        expected_violation = RuleViolation("T1", "Title exceeds max length (121>120)", u"å" * 121)
-        violations = rule.validate(u"å" * 121, None)
+        expected_violation = RuleViolation("T1", "Title exceeds max length (121>120)", "å" * 121)
+        violations = rule.validate("å" * 121, None)
         self.assertListEqual(violations, [expected_violation])
 
     def test_trailing_whitespace(self):
         rule = TitleTrailingWhitespace()
 
         # assert no error
-        violations = rule.validate(u"å", None)
+        violations = rule.validate("å", None)
         self.assertIsNone(violations)
 
         # trailing space
-        expected_violation = RuleViolation("T2", "Title has trailing whitespace", u"å ")
-        violations = rule.validate(u"å ", None)
+        expected_violation = RuleViolation("T2", "Title has trailing whitespace", "å ")
+        violations = rule.validate("å ", None)
         self.assertListEqual(violations, [expected_violation])
 
         # trailing tab
-        expected_violation = RuleViolation("T2", "Title has trailing whitespace", u"å\t")
-        violations = rule.validate(u"å\t", None)
+        expected_violation = RuleViolation("T2", "Title has trailing whitespace", "å\t")
+        violations = rule.validate("å\t", None)
         self.assertListEqual(violations, [expected_violation])
 
     def test_hard_tabs(self):
         rule = TitleHardTab()
 
         # assert no error
-        violations = rule.validate(u"This is å test", None)
+        violations = rule.validate("This is å test", None)
         self.assertIsNone(violations)
 
         # contains hard tab
-        expected_violation = RuleViolation("T4", "Title contains hard tab characters (\\t)", u"This is å\ttest")
-        violations = rule.validate(u"This is å\ttest", None)
+        expected_violation = RuleViolation("T4", "Title contains hard tab characters (\\t)", "This is å\ttest")
+        violations = rule.validate("This is å\ttest", None)
         self.assertListEqual(violations, [expected_violation])
 
     def test_trailing_punctuation(self):
         rule = TitleTrailingPunctuation()
 
         # assert no error
-        violations = rule.validate(u"This is å test", None)
+        violations = rule.validate("This is å test", None)
         self.assertIsNone(violations)
 
         # assert errors for different punctuations
-        punctuation = u"?:!.,;"
+        punctuation = "?:!.,;"
         for char in punctuation:
-            line = u"This is å test" + char  # note that make sure to include some unicode!
+            line = "This is å test" + char  # note that make sure to include some unicode!
             gitcontext = self.gitcontext(line)
-            expected_violation = RuleViolation("T3", u"Title has trailing punctuation ({0})".format(char), line)
+            expected_violation = RuleViolation("T3", f"Title has trailing punctuation ({char})", line)
             violations = rule.validate(line, gitcontext)
             self.assertListEqual(violations, [expected_violation])
 
@@ -76,40 +76,40 @@ class TitleRuleTests(BaseTestCase):
         rule = TitleMustNotContainWord()
 
         # no violations
-        violations = rule.validate(u"This is å test", None)
+        violations = rule.validate("This is å test", None)
         self.assertIsNone(violations)
 
         # no violation if WIP occurs inside a wor
-        violations = rule.validate(u"This is å wiping test", None)
+        violations = rule.validate("This is å wiping test", None)
         self.assertIsNone(violations)
 
         # match literally
-        violations = rule.validate(u"WIP This is å test", None)
+        violations = rule.validate("WIP This is å test", None)
         expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)",
-                                           u"WIP This is å test")
+                                           "WIP This is å test")
         self.assertListEqual(violations, [expected_violation])
 
         # match case insensitive
-        violations = rule.validate(u"wip This is å test", None)
+        violations = rule.validate("wip This is å test", None)
         expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)",
-                                           u"wip This is å test")
+                                           "wip This is å test")
         self.assertListEqual(violations, [expected_violation])
 
         # match if there is a colon after the word
-        violations = rule.validate(u"WIP:This is å test", None)
+        violations = rule.validate("WIP:This is å test", None)
         expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)",
-                                           u"WIP:This is å test")
+                                           "WIP:This is å test")
         self.assertListEqual(violations, [expected_violation])
 
         # match multiple words
-        rule = TitleMustNotContainWord({'words': u"wip,test,å"})
-        violations = rule.validate(u"WIP:This is å test", None)
+        rule = TitleMustNotContainWord({'words': "wip,test,å"})
+        violations = rule.validate("WIP:This is å test", None)
         expected_violation = RuleViolation("T5", "Title contains the word 'wip' (case-insensitive)",
-                                           u"WIP:This is å test")
+                                           "WIP:This is å test")
         expected_violation2 = RuleViolation("T5", "Title contains the word 'test' (case-insensitive)",
-                                            u"WIP:This is å test")
-        expected_violation3 = RuleViolation("T5", u"Title contains the word 'å' (case-insensitive)",
-                                            u"WIP:This is å test")
+                                            "WIP:This is å test")
+        expected_violation3 = RuleViolation("T5", "Title contains the word 'å' (case-insensitive)",
+                                            "WIP:This is å test")
         self.assertListEqual(violations, [expected_violation, expected_violation2, expected_violation3])
 
     def test_leading_whitespace(self):
@@ -130,12 +130,12 @@ class TitleRuleTests(BaseTestCase):
         self.assertListEqual(violations, [expected_violation])
 
         # unicode test
-        expected_violation = RuleViolation("T6", "Title has leading whitespace", u" ☺")
-        violations = rule.validate(u" ☺", None)
+        expected_violation = RuleViolation("T6", "Title has leading whitespace", " ☺")
+        violations = rule.validate(" ☺", None)
         self.assertListEqual(violations, [expected_violation])
 
     def test_regex_matches(self):
-        commit = self.gitcommit(u"US1234: åbc\n")
+        commit = self.gitcommit("US1234: åbc\n")
 
         # assert no violation on default regex (=everything allowed)
         rule = TitleRegexMatches()
@@ -143,41 +143,41 @@ class TitleRuleTests(BaseTestCase):
         self.assertIsNone(violations)
 
         # assert no violation on matching regex
-        rule = TitleRegexMatches({'regex': u"^US[0-9]*: å"})
+        rule = TitleRegexMatches({'regex': "^US[0-9]*: å"})
         violations = rule.validate(commit.message.title, commit)
         self.assertIsNone(violations)
 
         # assert violation when no matching regex
-        rule = TitleRegexMatches({'regex': u"^UÅ[0-9]*"})
+        rule = TitleRegexMatches({'regex': "^UÅ[0-9]*"})
         violations = rule.validate(commit.message.title, commit)
-        expected_violation = RuleViolation("T7", u"Title does not match regex (^UÅ[0-9]*)", u"US1234: åbc")
+        expected_violation = RuleViolation("T7", "Title does not match regex (^UÅ[0-9]*)", "US1234: åbc")
         self.assertListEqual(violations, [expected_violation])
 
     def test_min_line_length(self):
         rule = TitleMinLength()
 
         # assert no error
-        violation = rule.validate(u"å" * 72, None)
+        violation = rule.validate("å" * 72, None)
         self.assertIsNone(violation)
 
         # assert error on line length < 5
-        expected_violation = RuleViolation("T8", "Title is too short (4<5)", u"å" * 4, 1)
-        violations = rule.validate(u"å" * 4, None)
+        expected_violation = RuleViolation("T8", "Title is too short (4<5)", "å" * 4, 1)
+        violations = rule.validate("å" * 4, None)
         self.assertListEqual(violations, [expected_violation])
 
         # set line length to 3, and check no violation on length 4
         rule = TitleMinLength({'min-length': 3})
-        violations = rule.validate(u"å" * 4, None)
+        violations = rule.validate("å" * 4, None)
         self.assertIsNone(violations)
 
         # assert no violations on length 3 (this asserts we've implemented a *strict* less than)
         rule = TitleMinLength({'min-length': 3})
-        violations = rule.validate(u"å" * 3, None)
+        violations = rule.validate("å" * 3, None)
         self.assertIsNone(violations)
 
         # assert raise on 2
-        expected_violation = RuleViolation("T8", "Title is too short (2<3)", u"å" * 2, 1)
-        violations = rule.validate(u"å" * 2, None)
+        expected_violation = RuleViolation("T8", "Title is too short (2<3)", "å" * 2, 1)
+        violations = rule.validate("å" * 2, None)
         self.assertListEqual(violations, [expected_violation])
 
         # assert raise on empty title
diff --git a/gitlint/tests/rules/test_user_rules.py b/gitlint/tests/rules/test_user_rules.py
index 52d0283..510a829 100644
--- a/gitlint/tests/rules/test_user_rules.py
+++ b/gitlint/tests/rules/test_user_rules.py
@@ -6,7 +6,6 @@ import sys
 from gitlint.tests.base import BaseTestCase
 from gitlint.rule_finder import find_rule_classes, assert_valid_rule_class
 from gitlint.rules import UserRuleError
-from gitlint.utils import ustr
 
 from gitlint import options, rules
 
@@ -25,7 +24,7 @@ class UserRuleTests(BaseTestCase):
         # - Other members of the my_commit_rules module are ignored
         #  (such as func_should_be_ignored, global_variable_should_be_ignored)
         # - Rules are loaded non-recursively (user_rules/import_exception directory is ignored)
-        self.assertEqual("[<class 'my_commit_rules.MyUserCommitRule'>]", ustr(classes))
+        self.assertEqual("[<class 'my_commit_rules.MyUserCommitRule'>]", str(classes))
 
         # Assert that we added the new user_rules directory to the system path and modules
         self.assertIn(user_rule_path, sys.path)
@@ -33,8 +32,8 @@ class UserRuleTests(BaseTestCase):
 
         # Do some basic asserts on our user rule
         self.assertEqual(classes[0].id, "UC1")
-        self.assertEqual(classes[0].name, u"my-üser-commit-rule")
-        expected_option = options.IntOption('violation-count', 1, u"Number of violåtions to return")
+        self.assertEqual(classes[0].name, "my-üser-commit-rule")
+        expected_option = options.IntOption('violation-count', 1, "Number of violåtions to return")
         self.assertListEqual(classes[0].options_spec, [expected_option])
         self.assertTrue(hasattr(classes[0], "validate"))
 
@@ -42,13 +41,13 @@ class UserRuleTests(BaseTestCase):
         # expected result
         rule_class = classes[0]()
         violations = rule_class.validate("false-commit-object (ignored)")
-        self.assertListEqual(violations, [rules.RuleViolation("UC1", u"Commit violåtion 1", u"Contënt 1", 1)])
+        self.assertListEqual(violations, [rules.RuleViolation("UC1", "Commit violåtion 1", "Contënt 1", 1)])
 
         # Have it return more violations
         rule_class.options['violation-count'].value = 2
         violations = rule_class.validate("false-commit-object (ignored)")
-        self.assertListEqual(violations, [rules.RuleViolation("UC1", u"Commit violåtion 1", u"Contënt 1", 1),
-                                          rules.RuleViolation("UC1", u"Commit violåtion 2", u"Contënt 2", 2)])
+        self.assertListEqual(violations, [rules.RuleViolation("UC1", "Commit violåtion 1", "Contënt 1", 1),
+                                          rules.RuleViolation("UC1", "Commit violåtion 2", "Contënt 2", 2)])
 
     def test_extra_path_specified_by_file(self):
         # Test that find_rule_classes can handle an extra path given as a file name instead of a directory
@@ -58,7 +57,7 @@ class UserRuleTests(BaseTestCase):
 
         rule_class = classes[0]()
         violations = rule_class.validate("false-commit-object (ignored)")
-        self.assertListEqual(violations, [rules.RuleViolation("UC1", u"Commit violåtion 1", u"Contënt 1", 1)])
+        self.assertListEqual(violations, [rules.RuleViolation("UC1", "Commit violåtion 1", "Contënt 1", 1)])
 
     def test_rules_from_init_file(self):
         # Test that we can import rules that are defined in __init__.py files
@@ -68,8 +67,8 @@ class UserRuleTests(BaseTestCase):
         classes = find_rule_classes(user_rule_path)
 
         # convert classes to strings and sort them so we can compare them
-        class_strings = sorted([ustr(clazz) for clazz in classes])
-        expected = [u"<class 'my_commit_rules.MyUserCommitRule'>", u"<class 'parent_package.InitFileRule'>"]
+        class_strings = sorted([str(clazz) for clazz in classes])
+        expected = ["<class 'my_commit_rules.MyUserCommitRule'>", "<class 'parent_package.InitFileRule'>"]
         self.assertListEqual(class_strings, expected)
 
     def test_empty_user_classes(self):
@@ -92,8 +91,8 @@ class UserRuleTests(BaseTestCase):
             find_rule_classes(user_rule_path)
 
     def test_find_rule_classes_nonexisting_path(self):
-        with self.assertRaisesMessage(UserRuleError, u"Invalid extra-path: föo/bar"):
-            find_rule_classes(u"föo/bar")
+        with self.assertRaisesMessage(UserRuleError, "Invalid extra-path: föo/bar"):
+            find_rule_classes("föo/bar")
 
     def test_assert_valid_rule_class(self):
         class MyLineRuleClass(rules.LineRule):
@@ -132,7 +131,7 @@ class UserRuleTests(BaseTestCase):
 
     def test_assert_valid_rule_class_negative_parent(self):
         # rule class must extend from LineRule or CommitRule
-        class MyRuleClass(object):
+        class MyRuleClass:
             pass
 
         expected_msg = "User-defined rule class 'MyRuleClass' must extend from gitlint.rules.LineRule, " + \
@@ -160,8 +159,9 @@ class UserRuleTests(BaseTestCase):
             # Rule ids must not start with one of the reserved id letters
             for letter in ["T", "R", "B", "M", "I"]:
                 MyRuleClass.id = letter + "1"
-                expected_msg = "The id '{0}' of 'MyRuleClass' is invalid. Gitlint reserves ids starting with R,T,B,M,I"
-                with self.assertRaisesMessage(UserRuleError, expected_msg.format(letter)):
+                expected_msg = f"The id '{letter}' of 'MyRuleClass' is invalid. " + \
+                               "Gitlint reserves ids starting with R,T,B,M,I"
+                with self.assertRaisesMessage(UserRuleError, expected_msg):
                     assert_valid_rule_class(MyRuleClass)
 
     def test_assert_valid_rule_class_negative_name(self):
@@ -186,17 +186,17 @@ class UserRuleTests(BaseTestCase):
 
             class MyRuleClass(parent_class):
                 id = "UC1"
-                name = u"my-rüle-class"
+                name = "my-rüle-class"
 
             # if set, option_spec must be a list of gitlint options
-            MyRuleClass.options_spec = u"föo"
+            MyRuleClass.options_spec = "föo"
             expected_msg = "The options_spec attribute of user-defined rule class 'MyRuleClass' must be a list " + \
                 "of gitlint.options.RuleOption"
             with self.assertRaisesMessage(UserRuleError, expected_msg):
                 assert_valid_rule_class(MyRuleClass)
 
             # option_spec is a list, but not of gitlint options
-            MyRuleClass.options_spec = [u"föo", 123]  # pylint: disable=bad-option-value,redefined-variable-type
+            MyRuleClass.options_spec = ["föo", 123]  # pylint: disable=bad-option-value,redefined-variable-type
             with self.assertRaisesMessage(UserRuleError, expected_msg):
                 assert_valid_rule_class(MyRuleClass)
 
@@ -206,14 +206,14 @@ class UserRuleTests(BaseTestCase):
         for clazz in baseclasses:
             class MyRuleClass(clazz):
                 id = "UC1"
-                name = u"my-rüle-class"
+                name = "my-rüle-class"
 
             with self.assertRaisesMessage(UserRuleError,
                                           "User-defined rule class 'MyRuleClass' must have a 'validate' method"):
                 assert_valid_rule_class(MyRuleClass)
 
             # validate attribute - not a method
-            MyRuleClass.validate = u"föo"
+            MyRuleClass.validate = "föo"
             with self.assertRaisesMessage(UserRuleError,
                                           "User-defined rule class 'MyRuleClass' must have a 'validate' method"):
                 assert_valid_rule_class(MyRuleClass)
@@ -221,21 +221,21 @@ class UserRuleTests(BaseTestCase):
     def test_assert_valid_rule_class_negative_apply(self):
         class MyRuleClass(rules.ConfigurationRule):
             id = "UCR1"
-            name = u"my-rüle-class"
+            name = "my-rüle-class"
 
         expected_msg = "User-defined Configuration rule class 'MyRuleClass' must have an 'apply' method"
         with self.assertRaisesMessage(UserRuleError, expected_msg):
             assert_valid_rule_class(MyRuleClass)
 
         # validate attribute - not a method
-        MyRuleClass.validate = u"föo"
+        MyRuleClass.validate = "föo"
         with self.assertRaisesMessage(UserRuleError, expected_msg):
             assert_valid_rule_class(MyRuleClass)
 
     def test_assert_valid_rule_class_negative_target(self):
         class MyRuleClass(rules.LineRule):
             id = "UC1"
-            name = u"my-rüle-class"
+            name = "my-rüle-class"
 
             def validate(self):
                 pass
@@ -247,7 +247,7 @@ class UserRuleTests(BaseTestCase):
             assert_valid_rule_class(MyRuleClass)
 
         # invalid target
-        MyRuleClass.target = u"föo"
+        MyRuleClass.target = "föo"
         with self.assertRaisesMessage(UserRuleError, expected_msg):
             assert_valid_rule_class(MyRuleClass)