diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2020-03-19 14:00:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2020-03-19 14:00:14 +0000 |
commit | df9615bac55ac6f1c3f516b66279ac0007175030 (patch) | |
tree | 84dd81d1c97835271cea7fbdd67c074742365e07 /gitlint/tests | |
parent | Initial commit. (diff) | |
download | gitlint-df9615bac55ac6f1c3f516b66279ac0007175030.tar.xz gitlint-df9615bac55ac6f1c3f516b66279ac0007175030.zip |
Adding upstream version 0.13.1.upstream/0.13.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
61 files changed, 4275 insertions, 0 deletions
diff --git a/gitlint/tests/__init__.py b/gitlint/tests/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint/tests/__init__.py diff --git a/gitlint/tests/base.py b/gitlint/tests/base.py new file mode 100644 index 0000000..add4d71 --- /dev/null +++ b/gitlint/tests/base.py @@ -0,0 +1,169 @@ +# -*- coding: utf-8 -*- + +import copy +import io +import logging +import os +import re + +try: + # python 2.x + import unittest2 as unittest +except ImportError: + # python 3.x + import unittest + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +from gitlint.git import GitContext +from gitlint.utils import ustr, LOG_FORMAT, DEFAULT_ENCODING + + +# unittest2's assertRaisesRegex doesn't do unicode comparison. +# Let's monkeypatch the str() function to point to unicode() so that it does :) +# For reference, this is where this patch is required: +# https://hg.python.org/unittest2/file/tip/unittest2/case.py#l227 +try: + # python 2.x + unittest.case.str = unicode +except (AttributeError, NameError): + pass # python 3.x + + +class BaseTestCase(unittest.TestCase): + """ Base class of which all gitlint unit test classes are derived. Provides a number of convenience methods. """ + + # In case of assert failures, print the full error message + maxDiff = None + + SAMPLES_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "samples") + EXPECTED_DIR = os.path.join(os.path.dirname(os.path.realpath(__file__)), "expected") + GITLINT_USE_SH_LIB = os.environ.get("GITLINT_USE_SH_LIB", "[NOT SET]") + + def setUp(self): + self.logcapture = LogCapture() + self.logcapture.setFormatter(logging.Formatter(LOG_FORMAT)) + logging.getLogger('gitlint').setLevel(logging.DEBUG) + logging.getLogger('gitlint').handlers = [self.logcapture] + + # Make sure we don't propagate anything to child loggers, we need to do this explicitely here + # because if you run a specific test file like test_lint.py, we won't be calling the setupLogging() method + # in gitlint.cli that normally takes care of this + logging.getLogger('gitlint').propagate = False + + @staticmethod + def get_sample_path(filename=""): + # Don't join up empty files names because this will add a trailing slash + if filename == "": + return ustr(BaseTestCase.SAMPLES_DIR) + + return ustr(os.path.join(BaseTestCase.SAMPLES_DIR, filename)) + + @staticmethod + def get_sample(filename=""): + """ Read and return the contents of a file in gitlint/tests/samples """ + sample_path = BaseTestCase.get_sample_path(filename) + with io.open(sample_path, encoding=DEFAULT_ENCODING) as content: + sample = ustr(content.read()) + return sample + + @staticmethod + def get_expected(filename="", variable_dict=None): + """ Utility method to read an expected file from gitlint/tests/expected and return it as a string. + Optionally replace template variables specified by variable_dict. """ + expected_path = os.path.join(BaseTestCase.EXPECTED_DIR, filename) + with io.open(expected_path, encoding=DEFAULT_ENCODING) as content: + expected = ustr(content.read()) + + if variable_dict: + expected = expected.format(**variable_dict) + return expected + + @staticmethod + def get_user_rules_path(): + return os.path.join(BaseTestCase.SAMPLES_DIR, "user_rules") + + @staticmethod + def gitcontext(commit_msg_str, changed_files=None, ): + """ Utility method to easily create gitcontext objects based on a given commit msg string and an optional set of + changed files""" + with patch("gitlint.git.git_commentchar") as comment_char: + comment_char.return_value = u"#" + gitcontext = GitContext.from_commit_msg(commit_msg_str) + commit = gitcontext.commits[-1] + if changed_files: + commit.changed_files = changed_files + return gitcontext + + @staticmethod + def gitcommit(commit_msg_str, changed_files=None, **kwargs): + """ Utility method to easily create git commit given a commit msg string and an optional set of changed files""" + gitcontext = BaseTestCase.gitcontext(commit_msg_str, changed_files) + commit = gitcontext.commits[-1] + for attr, value in kwargs.items(): + setattr(commit, attr, value) + return commit + + def assert_logged(self, expected): + """ Asserts that the logs match an expected string or list. + This method knows how to compare a passed list of log lines as well as a newline concatenated string + of all loglines. """ + if isinstance(expected, list): + self.assertListEqual(self.logcapture.messages, expected) + else: + self.assertEqual("\n".join(self.logcapture.messages), expected) + + def assert_log_contains(self, line): + """ Asserts that a certain line is in the logs """ + self.assertIn(line, self.logcapture.messages) + + def assertRaisesRegex(self, expected_exception, expected_regex, *args, **kwargs): + """ Pass-through method to unittest.TestCase.assertRaisesRegex that applies re.escape() to the passed + `expected_regex`. This is useful to automatically escape all file paths that might be present in the regex. + """ + return super(BaseTestCase, self).assertRaisesRegex(expected_exception, re.escape(expected_regex), + *args, **kwargs) + + def object_equality_test(self, obj, attr_list, ctor_kwargs=None): + """ Helper function to easily implement object equality tests. + Creates an object clone for every passed attribute and checks for (in)equality + of the original object with the clone based on those attributes' values. + This function assumes all attributes in `attr_list` can be passed to the ctor of `obj.__class__`. + """ + if not ctor_kwargs: + ctor_kwargs = {} + + attr_kwargs = {} + for attr in attr_list: + attr_kwargs[attr] = getattr(obj, attr) + + # For every attr, clone the object and assert the clone and the original object are equal + # Then, change the current attr and assert objects are unequal + for attr in attr_list: + attr_kwargs_copy = copy.deepcopy(attr_kwargs) + attr_kwargs_copy.update(ctor_kwargs) + clone = obj.__class__(**attr_kwargs_copy) + self.assertEqual(obj, clone) + + # Change attribute and assert objects are different (via both attribute set and ctor) + setattr(clone, attr, u"föo") + self.assertNotEqual(obj, clone) + attr_kwargs_copy[attr] = u"föo" + + self.assertNotEqual(obj, obj.__class__(**attr_kwargs_copy)) + + +class LogCapture(logging.Handler): + """ Mock logging handler used to capture any log messages during tests.""" + + def __init__(self, *args, **kwargs): + logging.Handler.__init__(self, *args, **kwargs) + self.messages = [] + + def emit(self, record): + self.messages.append(ustr(self.format(record))) diff --git a/gitlint/tests/cli/test_cli.py b/gitlint/tests/cli/test_cli.py new file mode 100644 index 0000000..4d47f35 --- /dev/null +++ b/gitlint/tests/cli/test_cli.py @@ -0,0 +1,541 @@ +# -*- coding: utf-8 -*- + +import contextlib +import io +import os +import sys +import platform +import shutil +import tempfile + +import arrow + +try: + # python 2.x + from StringIO import StringIO +except ImportError: + # python 3.x + from io import StringIO # pylint: disable=ungrouped-imports + +from click.testing import CliRunner + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +from gitlint.shell import CommandNotFound + +from gitlint.tests.base import BaseTestCase +from gitlint import cli +from gitlint import __version__ +from gitlint.utils import DEFAULT_ENCODING + + +@contextlib.contextmanager +def tempdir(): + tmpdir = tempfile.mkdtemp() + try: + yield tmpdir + finally: + shutil.rmtree(tmpdir) + + +class CLITests(BaseTestCase): + USAGE_ERROR_CODE = 253 + GIT_CONTEXT_ERROR_CODE = 254 + CONFIG_ERROR_CODE = 255 + + def setUp(self): + super(CLITests, self).setUp() + self.cli = CliRunner() + + # Patch gitlint.cli.git_version() so that we don't have to patch it separately in every test + self.git_version_path = patch('gitlint.cli.git_version') + cli.git_version = self.git_version_path.start() + cli.git_version.return_value = "git version 1.2.3" + + def tearDown(self): + self.git_version_path.stop() + + @staticmethod + def get_system_info_dict(): + """ Returns a dict with items related to system values logged by `gitlint --debug` """ + return {'platform': platform.platform(), "python_version": sys.version, 'gitlint_version': __version__, + 'GITLINT_USE_SH_LIB': BaseTestCase.GITLINT_USE_SH_LIB, 'target': os.path.realpath(os.getcwd())} + + def test_version(self): + """ Test for --version option """ + result = self.cli.invoke(cli.cli, ["--version"]) + self.assertEqual(result.output.split("\n")[0], "cli, version {0}".format(__version__)) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + @patch('gitlint.git.sh') + def test_lint(self, sh, _): + """ Test for basic simple linting functionality """ + sh.git.side_effect = [ + "6f29bf81a8322a04071bb794666e48c443a90360", + u"test åuthor\x00test-email@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"commït-title\n\ncommït-body", + u"#", # git config --get core.commentchar + u"commit-1-branch-1\ncommit-1-branch-2\n", + u"file1.txt\npåth/to/file2.txt\n" + ] + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli) + self.assertEqual(stderr.getvalue(), u'3: B5 Body message is too short (11<20): "commït-body"\n') + self.assertEqual(result.exit_code, 1) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + @patch('gitlint.git.sh') + def test_lint_multiple_commits(self, sh, _): + """ Test for --commits option """ + + sh.git.side_effect = [ + "6f29bf81a8322a04071bb794666e48c443a90360\n" + # git rev-list <SHA> + "25053ccec5e28e1bb8f7551fdbb5ab213ada2401\n" + + "4da2656b0dadc76c7ee3fd0243a96cb64007f125\n", + # git log --pretty <FORMAT> <SHA> + u"test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"commït-title1\n\ncommït-body1", + u"#", # git config --get core.commentchar + u"commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + u"commit-1/file-1\ncommit-1/file-2\n", # git diff-tree + # git log --pretty <FORMAT> <SHA> + u"test åuthor2\x00test-email3@föo.com\x002016-12-04 15:28:15 +0100\x00åbc\n" + u"commït-title2\n\ncommït-body2", + u"commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + u"commit-2/file-1\ncommit-2/file-2\n", # git diff-tree + # git log --pretty <FORMAT> <SHA> + u"test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00åbc\n" + u"commït-title3\n\ncommït-body3", + u"commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + u"commit-3/file-1\ncommit-3/file-2\n", # git diff-tree + ] + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--commits", "foo...bar"]) + self.assertEqual(stderr.getvalue(), self.get_expected("test_cli/test_lint_multiple_commits_1")) + self.assertEqual(result.exit_code, 3) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + @patch('gitlint.git.sh') + def test_lint_multiple_commits_config(self, sh, _): + """ Test for --commits option where some of the commits have gitlint config in the commit message """ + + # Note that the second commit title has a trailing period that is being ignored by gitlint-ignore: T3 + sh.git.side_effect = [ + "6f29bf81a8322a04071bb794666e48c443a90360\n" + # git rev-list <SHA> + "25053ccec5e28e1bb8f7551fdbb5ab213ada2401\n" + + "4da2656b0dadc76c7ee3fd0243a96cb64007f125\n", + # git log --pretty <FORMAT> <SHA> + u"test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"commït-title1\n\ncommït-body1", + u"#", # git config --get core.commentchar + u"commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + u"commit-1/file-1\ncommit-1/file-2\n", # git diff-tree + # git log --pretty <FORMAT> <SHA> + u"test åuthor2\x00test-email2@föo.com\x002016-12-04 15:28:15 +0100\x00åbc\n" + u"commït-title2.\n\ncommït-body2\ngitlint-ignore: T3\n", + u"commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + u"commit-2/file-1\ncommit-2/file-2\n", # git diff-tree + # git log --pretty <FORMAT> <SHA> + u"test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00åbc\n" + u"commït-title3.\n\ncommït-body3", + u"commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + u"commit-3/file-1\ncommit-3/file-2\n", # git diff-tree + ] + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--commits", "foo...bar"]) + # We expect that the second commit has no failures because of 'gitlint-ignore: T3' in its commit msg body + self.assertEqual(stderr.getvalue(), self.get_expected("test_cli/test_lint_multiple_commits_config_1")) + self.assertEqual(result.exit_code, 3) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + @patch('gitlint.git.sh') + def test_lint_multiple_commits_configuration_rules(self, sh, _): + """ Test for --commits option where where we have configured gitlint to ignore certain rules for certain commits + """ + + # Note that the second commit + sh.git.side_effect = [ + "6f29bf81a8322a04071bb794666e48c443a90360\n" + # git rev-list <SHA> + "25053ccec5e28e1bb8f7551fdbb5ab213ada2401\n" + + "4da2656b0dadc76c7ee3fd0243a96cb64007f125\n", + # git log --pretty <FORMAT> <SHA> + u"test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"commït-title1\n\ncommït-body1", + u"#", # git config --get core.commentchar + u"commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + u"commit-1/file-1\ncommit-1/file-2\n", # git diff-tree + # git log --pretty <FORMAT> <SHA> + u"test åuthor2\x00test-email3@föo.com\x002016-12-04 15:28:15 +0100\x00åbc\n" + # Normally T3 violation (trailing punctuation), but this commit is ignored because of + # config below + u"commït-title2.\n\ncommït-body2\n", + u"commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + u"commit-2/file-1\ncommit-2/file-2\n", # git diff-tree + # git log --pretty <FORMAT> <SHA> + u"test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00åbc\n" + # Normally T1 and B5 violations, now only T1 because we're ignoring B5 in config below + u"commït-title3.\n\ncommït-body3 foo", + u"commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + u"commit-3/file-1\ncommit-3/file-2\n", # git diff-tree + ] + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--commits", "foo...bar", "-c", "I1.regex=^commït-title2(.*)", + "-c", "I2.regex=^commït-body3(.*)", "-c", "I2.ignore=B5"]) + # We expect that the second commit has no failures because of it matching against I1.regex + # Because we do test for the 3th commit to return violations, this test also ensures that a unique + # config object is passed to each commit lint call + expected = (u"Commit 6f29bf81a8:\n" + u'3: B5 Body message is too short (12<20): "commït-body1"\n\n' + u"Commit 4da2656b0d:\n" + u'1: T3 Title has trailing punctuation (.): "commït-title3."\n') + self.assertEqual(stderr.getvalue(), expected) + self.assertEqual(result.exit_code, 2) + + @patch('gitlint.cli.get_stdin_data', return_value=u'WIP: tïtle \n') + def test_input_stream(self, _): + """ Test for linting when a message is passed via stdin """ + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli) + self.assertEqual(stderr.getvalue(), self.get_expected("test_cli/test_input_stream_1")) + self.assertEqual(result.exit_code, 3) + self.assertEqual(result.output, "") + + @patch('gitlint.cli.get_stdin_data', return_value=u'WIP: tïtle \n') + def test_input_stream_debug(self, _): + """ Test for linting when a message is passed via stdin, and debug is enabled. + This tests specifically that git commit meta is not fetched when not passing --staged """ + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--debug"]) + self.assertEqual(stderr.getvalue(), self.get_expected("test_cli/test_input_stream_debug_1")) + self.assertEqual(result.exit_code, 3) + self.assertEqual(result.output, "") + expected_kwargs = self.get_system_info_dict() + expected_logs = self.get_expected('test_cli/test_input_stream_debug_2', expected_kwargs) + self.assert_logged(expected_logs) + + @patch('gitlint.cli.get_stdin_data', return_value="Should be ignored\n") + @patch('gitlint.git.sh') + def test_lint_ignore_stdin(self, sh, stdin_data): + """ Test for ignoring stdin when --ignore-stdin flag is enabled""" + sh.git.side_effect = [ + "6f29bf81a8322a04071bb794666e48c443a90360", + u"test åuthor\x00test-email@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"commït-title\n\ncommït-body", + u"#", # git config --get core.commentchar + u"commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + u"file1.txt\npåth/to/file2.txt\n" # git diff-tree + ] + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--ignore-stdin"]) + self.assertEqual(stderr.getvalue(), u'3: B5 Body message is too short (11<20): "commït-body"\n') + self.assertEqual(result.exit_code, 1) + + # Assert that we didn't even try to get the stdin data + self.assertEqual(stdin_data.call_count, 0) + + @patch('gitlint.cli.get_stdin_data', return_value=u'WIP: tïtle \n') + @patch('arrow.now', return_value=arrow.get("2020-02-19T12:18:46.675182+01:00")) + @patch('gitlint.git.sh') + def test_lint_staged_stdin(self, sh, _, __): + """ Test for ignoring stdin when --ignore-stdin flag is enabled""" + + sh.git.side_effect = [ + u"#", # git config --get core.commentchar + u"föo user\n", # git config --get user.name + u"föo@bar.com\n", # git config --get user.email + u"my-branch\n", # git rev-parse --abbrev-ref HEAD (=current branch) + u"commit-1/file-1\ncommit-1/file-2\n", # git diff-tree + ] + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--debug", "--staged"]) + self.assertEqual(stderr.getvalue(), self.get_expected("test_cli/test_lint_staged_stdin_1")) + self.assertEqual(result.exit_code, 3) + self.assertEqual(result.output, "") + + expected_kwargs = self.get_system_info_dict() + expected_logs = self.get_expected('test_cli/test_lint_staged_stdin_2', expected_kwargs) + self.assert_logged(expected_logs) + + @patch('arrow.now', return_value=arrow.get("2020-02-19T12:18:46.675182+01:00")) + @patch('gitlint.git.sh') + def test_lint_staged_msg_filename(self, sh, _): + """ Test for ignoring stdin when --ignore-stdin flag is enabled""" + + sh.git.side_effect = [ + u"#", # git config --get core.commentchar + u"föo user\n", # git config --get user.name + u"föo@bar.com\n", # git config --get user.email + u"my-branch\n", # git rev-parse --abbrev-ref HEAD (=current branch) + u"commit-1/file-1\ncommit-1/file-2\n", # git diff-tree + ] + + with tempdir() as tmpdir: + msg_filename = os.path.join(tmpdir, "msg") + with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: + f.write(u"WIP: msg-filename tïtle\n") + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--debug", "--staged", "--msg-filename", msg_filename]) + self.assertEqual(stderr.getvalue(), self.get_expected("test_cli/test_lint_staged_msg_filename_1")) + self.assertEqual(result.exit_code, 2) + self.assertEqual(result.output, "") + + expected_kwargs = self.get_system_info_dict() + expected_logs = self.get_expected('test_cli/test_lint_staged_msg_filename_2', expected_kwargs) + self.assert_logged(expected_logs) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + def test_lint_staged_negative(self, _): + result = self.cli.invoke(cli.cli, ["--staged"]) + self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) + self.assertEqual(result.output, (u"Error: The 'staged' option (--staged) can only be used when using " + u"'--msg-filename' or when piping data to gitlint via stdin.\n")) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + def test_msg_filename(self, _): + expected_output = u"3: B6 Body message is missing\n" + + with tempdir() as tmpdir: + msg_filename = os.path.join(tmpdir, "msg") + with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: + f.write(u"Commït title\n") + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--msg-filename", msg_filename]) + self.assertEqual(stderr.getvalue(), expected_output) + self.assertEqual(result.exit_code, 1) + self.assertEqual(result.output, "") + + @patch('gitlint.cli.get_stdin_data', return_value=u"WIP: tïtle \n") + def test_silent_mode(self, _): + """ Test for --silent option """ + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--silent"]) + self.assertEqual(stderr.getvalue(), "") + self.assertEqual(result.exit_code, 3) + self.assertEqual(result.output, "") + + @patch('gitlint.cli.get_stdin_data', return_value=u"WIP: tïtle \n") + def test_verbosity(self, _): + """ Test for --verbosity option """ + # We only test -v and -vv, more testing is really not required here + # -v + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["-v"]) + self.assertEqual(stderr.getvalue(), "1: T2\n1: T5\n3: B6\n") + self.assertEqual(result.exit_code, 3) + self.assertEqual(result.output, "") + + # -vv + expected_output = "1: T2 Title has trailing whitespace\n" + \ + "1: T5 Title contains the word 'WIP' (case-insensitive)\n" + \ + "3: B6 Body message is missing\n" + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["-vv"], input=u"WIP: tïtle \n") + self.assertEqual(stderr.getvalue(), expected_output) + self.assertEqual(result.exit_code, 3) + self.assertEqual(result.output, "") + + # -vvvv: not supported -> should print a config error + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["-vvvv"], input=u'WIP: tïtle \n') + self.assertEqual(stderr.getvalue(), "") + self.assertEqual(result.exit_code, CLITests.CONFIG_ERROR_CODE) + self.assertEqual(result.output, "Config Error: Option 'verbosity' must be set between 0 and 3\n") + + @patch('gitlint.cli.get_stdin_data', return_value=False) + @patch('gitlint.git.sh') + def test_debug(self, sh, _): + """ Test for --debug option """ + + sh.git.side_effect = [ + "6f29bf81a8322a04071bb794666e48c443a90360\n" # git rev-list <SHA> + "25053ccec5e28e1bb8f7551fdbb5ab213ada2401\n" + "4da2656b0dadc76c7ee3fd0243a96cb64007f125\n", + # git log --pretty <FORMAT> <SHA> + u"test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00abc\n" + u"commït-title1\n\ncommït-body1", + u"#", # git config --get core.commentchar + u"commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + u"commit-1/file-1\ncommit-1/file-2\n", # git diff-tree + u"test åuthor2\x00test-email2@föo.com\x002016-12-04 15:28:15 +0100\x00abc\n" + u"commït-title2.\n\ncommït-body2", + u"commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + u"commit-2/file-1\ncommit-2/file-2\n", # git diff-tree + u"test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00abc\n" + u"föo\nbar", + u"commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + u"commit-3/file-1\ncommit-3/file-2\n", # git diff-tree + ] + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + config_path = self.get_sample_path(os.path.join("config", "gitlintconfig")) + result = self.cli.invoke(cli.cli, ["--config", config_path, "--debug", "--commits", + "foo...bar"]) + + expected = "Commit 6f29bf81a8:\n3: B5\n\n" + \ + "Commit 25053ccec5:\n1: T3\n3: B5\n\n" + \ + "Commit 4da2656b0d:\n2: B4\n3: B5\n3: B6\n" + + self.assertEqual(stderr.getvalue(), expected) + self.assertEqual(result.exit_code, 6) + + expected_kwargs = self.get_system_info_dict() + expected_kwargs.update({'config_path': config_path}) + expected_logs = self.get_expected('test_cli/test_debug_1', expected_kwargs) + self.assert_logged(expected_logs) + + @patch('gitlint.cli.get_stdin_data', return_value=u"Test tïtle\n") + def test_extra_path(self, _): + """ Test for --extra-path flag """ + # Test extra-path pointing to a directory + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + extra_path = self.get_sample_path("user_rules") + result = self.cli.invoke(cli.cli, ["--extra-path", extra_path, "--debug"]) + expected_output = u"1: UC1 Commit violåtion 1: \"Contënt 1\"\n" + \ + "3: B6 Body message is missing\n" + self.assertEqual(stderr.getvalue(), expected_output) + self.assertEqual(result.exit_code, 2) + + # Test extra-path pointing to a file + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + extra_path = self.get_sample_path(os.path.join("user_rules", "my_commit_rules.py")) + result = self.cli.invoke(cli.cli, ["--extra-path", extra_path, "--debug"]) + expected_output = u"1: UC1 Commit violåtion 1: \"Contënt 1\"\n" + \ + "3: B6 Body message is missing\n" + self.assertEqual(stderr.getvalue(), expected_output) + self.assertEqual(result.exit_code, 2) + + @patch('gitlint.cli.get_stdin_data', return_value=u"Test tïtle\n\nMy body that is long enough") + def test_contrib(self, _): + # Test enabled contrib rules + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--contrib", "contrib-title-conventional-commits,CC1"]) + expected_output = self.get_expected('test_cli/test_contrib_1') + self.assertEqual(stderr.getvalue(), expected_output) + self.assertEqual(result.exit_code, 3) + + @patch('gitlint.cli.get_stdin_data', return_value=u"Test tïtle\n") + def test_contrib_negative(self, _): + result = self.cli.invoke(cli.cli, ["--contrib", u"föobar,CC1"]) + self.assertEqual(result.output, u"Config Error: No contrib rule with id or name 'föobar' found.\n") + self.assertEqual(result.exit_code, self.CONFIG_ERROR_CODE) + + @patch('gitlint.cli.get_stdin_data', return_value=u"WIP: tëst") + def test_config_file(self, _): + """ Test for --config option """ + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + config_path = self.get_sample_path(os.path.join("config", "gitlintconfig")) + result = self.cli.invoke(cli.cli, ["--config", config_path]) + self.assertEqual(result.output, "") + self.assertEqual(stderr.getvalue(), "1: T5\n3: B6\n") + self.assertEqual(result.exit_code, 2) + + def test_config_file_negative(self): + """ Negative test for --config option """ + # Directory as config file + config_path = self.get_sample_path("config") + result = self.cli.invoke(cli.cli, ["--config", config_path]) + expected_string = u"Error: Invalid value for \"-C\" / \"--config\": File \"{0}\" is a directory.".format( + config_path) + self.assertEqual(result.output.split("\n")[3], expected_string) + self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) + + # Non existing file + config_path = self.get_sample_path(u"föo") + result = self.cli.invoke(cli.cli, ["--config", config_path]) + expected_string = u"Error: Invalid value for \"-C\" / \"--config\": File \"{0}\" does not exist.".format( + config_path) + self.assertEqual(result.output.split("\n")[3], expected_string) + self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) + + # Invalid config file + config_path = self.get_sample_path(os.path.join("config", "invalid-option-value")) + result = self.cli.invoke(cli.cli, ["--config", config_path]) + self.assertEqual(result.exit_code, self.CONFIG_ERROR_CODE) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + def test_target(self, _): + """ Test for the --target option """ + os.environ["LANGUAGE"] = "C" # Force language to english so we can check for error message + result = self.cli.invoke(cli.cli, ["--target", "/tmp"]) + # We expect gitlint to tell us that /tmp is not a git repo (this proves that it takes the target parameter + # into account). + expected_path = os.path.realpath("/tmp") + self.assertEqual(result.output, "%s is not a git repository.\n" % expected_path) + self.assertEqual(result.exit_code, self.GIT_CONTEXT_ERROR_CODE) + + def test_target_negative(self): + """ Negative test for the --target option """ + # try setting a non-existing target + result = self.cli.invoke(cli.cli, ["--target", u"/föo/bar"]) + self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) + expected_msg = u"Error: Invalid value for \"--target\": Directory \"/föo/bar\" does not exist." + self.assertEqual(result.output.split("\n")[3], expected_msg) + + # try setting a file as target + target_path = self.get_sample_path(os.path.join("config", "gitlintconfig")) + result = self.cli.invoke(cli.cli, ["--target", target_path]) + self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) + expected_msg = u"Error: Invalid value for \"--target\": Directory \"{0}\" is a file.".format(target_path) + self.assertEqual(result.output.split("\n")[3], expected_msg) + + @patch('gitlint.config.LintConfigGenerator.generate_config') + def test_generate_config(self, generate_config): + """ Test for the generate-config subcommand """ + result = self.cli.invoke(cli.cli, ["generate-config"], input=u"tëstfile\n") + self.assertEqual(result.exit_code, 0) + expected_msg = u"Please specify a location for the sample gitlint config file [.gitlint]: tëstfile\n" + \ + u"Successfully generated {0}\n".format(os.path.realpath(u"tëstfile")) + self.assertEqual(result.output, expected_msg) + generate_config.assert_called_once_with(os.path.realpath(u"tëstfile")) + + def test_generate_config_negative(self): + """ Negative test for the generate-config subcommand """ + # Non-existing directory + fake_dir = os.path.abspath(u"/föo") + fake_path = os.path.join(fake_dir, u"bar") + result = self.cli.invoke(cli.cli, ["generate-config"], input=fake_path) + self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) + expected_msg = (u"Please specify a location for the sample gitlint config file [.gitlint]: {0}\n" + + u"Error: Directory '{1}' does not exist.\n").format(fake_path, fake_dir) + self.assertEqual(result.output, expected_msg) + + # Existing file + sample_path = self.get_sample_path(os.path.join("config", "gitlintconfig")) + result = self.cli.invoke(cli.cli, ["generate-config"], input=sample_path) + self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) + expected_msg = "Please specify a location for the sample gitlint " + \ + "config file [.gitlint]: {0}\n".format(sample_path) + \ + "Error: File \"{0}\" already exists.\n".format(sample_path) + self.assertEqual(result.output, expected_msg) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + @patch('gitlint.git.sh') + def test_git_error(self, sh, _): + """ Tests that the cli handles git errors properly """ + sh.git.side_effect = CommandNotFound("git") + result = self.cli.invoke(cli.cli) + self.assertEqual(result.exit_code, self.GIT_CONTEXT_ERROR_CODE) + + @patch('gitlint.cli.get_stdin_data', return_value=False) + @patch('gitlint.git.sh') + def test_no_commits_in_range(self, sh, _): + """ Test for --commits with the specified range being empty. """ + sh.git.side_effect = lambda *_args, **_kwargs: "" + result = self.cli.invoke(cli.cli, ["--commits", "master...HEAD"]) + + self.assert_log_contains(u"DEBUG: gitlint.cli No commits in range \"master...HEAD\"") + self.assertEqual(result.exit_code, 0) diff --git a/gitlint/tests/cli/test_cli_hooks.py b/gitlint/tests/cli/test_cli_hooks.py new file mode 100644 index 0000000..0564808 --- /dev/null +++ b/gitlint/tests/cli/test_cli_hooks.py @@ -0,0 +1,96 @@ +# -*- coding: utf-8 -*- + +import os + +from click.testing import CliRunner + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +from gitlint.tests.base import BaseTestCase +from gitlint import cli +from gitlint import hooks +from gitlint import config + + +class CLIHookTests(BaseTestCase): + USAGE_ERROR_CODE = 253 + GIT_CONTEXT_ERROR_CODE = 254 + CONFIG_ERROR_CODE = 255 + + def setUp(self): + super(CLIHookTests, self).setUp() + self.cli = CliRunner() + + # Patch gitlint.cli.git_version() so that we don't have to patch it separately in every test + self.git_version_path = patch('gitlint.cli.git_version') + cli.git_version = self.git_version_path.start() + cli.git_version.return_value = "git version 1.2.3" + + def tearDown(self): + self.git_version_path.stop() + + @patch('gitlint.hooks.GitHookInstaller.install_commit_msg_hook') + @patch('gitlint.hooks.git_hooks_dir', return_value=os.path.join(u"/hür", u"dur")) + def test_install_hook(self, _, install_hook): + """ Test for install-hook subcommand """ + result = self.cli.invoke(cli.cli, ["install-hook"]) + expected_path = os.path.join(u"/hür", u"dur", hooks.COMMIT_MSG_HOOK_DST_PATH) + expected = u"Successfully installed gitlint commit-msg hook in {0}\n".format(expected_path) + self.assertEqual(result.output, expected) + self.assertEqual(result.exit_code, 0) + expected_config = config.LintConfig() + expected_config.target = os.path.realpath(os.getcwd()) + install_hook.assert_called_once_with(expected_config) + + @patch('gitlint.hooks.GitHookInstaller.install_commit_msg_hook') + @patch('gitlint.hooks.git_hooks_dir', return_value=os.path.join(u"/hür", u"dur")) + def test_install_hook_target(self, _, install_hook): + """ Test for install-hook subcommand with a specific --target option specified """ + # Specified target + result = self.cli.invoke(cli.cli, ["--target", self.SAMPLES_DIR, "install-hook"]) + expected_path = os.path.join(u"/hür", u"dur", hooks.COMMIT_MSG_HOOK_DST_PATH) + expected = "Successfully installed gitlint commit-msg hook in %s\n" % expected_path + self.assertEqual(result.exit_code, 0) + self.assertEqual(result.output, expected) + + expected_config = config.LintConfig() + expected_config.target = self.SAMPLES_DIR + install_hook.assert_called_once_with(expected_config) + + @patch('gitlint.hooks.GitHookInstaller.install_commit_msg_hook', side_effect=hooks.GitHookInstallerError(u"tëst")) + def test_install_hook_negative(self, install_hook): + """ Negative test for install-hook subcommand """ + result = self.cli.invoke(cli.cli, ["install-hook"]) + self.assertEqual(result.exit_code, self.GIT_CONTEXT_ERROR_CODE) + self.assertEqual(result.output, u"tëst\n") + expected_config = config.LintConfig() + expected_config.target = os.path.realpath(os.getcwd()) + install_hook.assert_called_once_with(expected_config) + + @patch('gitlint.hooks.GitHookInstaller.uninstall_commit_msg_hook') + @patch('gitlint.hooks.git_hooks_dir', return_value=os.path.join(u"/hür", u"dur")) + def test_uninstall_hook(self, _, uninstall_hook): + """ Test for uninstall-hook subcommand """ + result = self.cli.invoke(cli.cli, ["uninstall-hook"]) + expected_path = os.path.join(u"/hür", u"dur", hooks.COMMIT_MSG_HOOK_DST_PATH) + expected = u"Successfully uninstalled gitlint commit-msg hook from {0}\n".format(expected_path) + self.assertEqual(result.exit_code, 0) + self.assertEqual(result.output, expected) + expected_config = config.LintConfig() + expected_config.target = os.path.realpath(os.getcwd()) + uninstall_hook.assert_called_once_with(expected_config) + + @patch('gitlint.hooks.GitHookInstaller.uninstall_commit_msg_hook', side_effect=hooks.GitHookInstallerError(u"tëst")) + def test_uninstall_hook_negative(self, uninstall_hook): + """ Negative test for uninstall-hook subcommand """ + result = self.cli.invoke(cli.cli, ["uninstall-hook"]) + self.assertEqual(result.exit_code, self.GIT_CONTEXT_ERROR_CODE) + self.assertEqual(result.output, u"tëst\n") + expected_config = config.LintConfig() + expected_config.target = os.path.realpath(os.getcwd()) + uninstall_hook.assert_called_once_with(expected_config) diff --git a/gitlint/tests/config/test_config.py b/gitlint/tests/config/test_config.py new file mode 100644 index 0000000..d3fdc2c --- /dev/null +++ b/gitlint/tests/config/test_config.py @@ -0,0 +1,263 @@ +# -*- coding: utf-8 -*- + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +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, ustr + + +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 = u"No such rule 'föobar'" + with self.assertRaisesRegex(LintConfigError, expected_error_msg): + config.set_rule_option(u'föobar', u'lïne-length', 60) + + # non-existing option + expected_error_msg = u"Rule 'title-max-length' has no option 'föobar'" + with self.assertRaisesRegex(LintConfigError, expected_error_msg): + config.set_rule_option('title-max-length', u'föobar', 60) + + # invalid option value + expected_error_msg = u"'föo' is not a valid value for option 'title-max-length.line-length'. " + \ + u"Option 'line-length' must be a positive integer (current value: 'föo')." + with self.assertRaisesRegex(LintConfigError, expected_error_msg): + config.set_rule_option('title-max-length', 'line-length', u"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.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) + + # 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(ustr(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"], + "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(ustr(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.assertRaisesRegex(LintConfigError, u"No contrib rule with id or name 'föo' found."): + config.contrib = u"contrib-title-conventional-commits,föo" + + # UserRuleError, RuleOptionError should be re-raised as LintConfigErrors + side_effects = [rules.UserRuleError(u"üser-rule"), options.RuleOptionError(u"rüle-option")] + for side_effect in side_effects: + with patch('gitlint.config.rule_finder.find_rule_classes', side_effect=side_effect): + with self.assertRaisesRegex(LintConfigError, ustr(side_effect)): + config.contrib = u"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(ustr(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, u"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 = u"Option extra-path must be either an existing directory or file (current value: 'föo/bar')" + # incorrect extra_path + with self.assertRaisesRegex(LintConfigError, regex): + config.extra_path = u"föo/bar" + + # extra path contains classes with errors + with self.assertRaisesRegex(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.assertRaisesRegex(LintConfigError, "'foo' is not a valid gitlint option"): + config.set_general_option("foo", u"bår") + + # try setting _config_path, this is a real attribute of LintConfig, but the code should prevent it from + # being set + with self.assertRaisesRegex(LintConfigError, "'_config_path' is not a valid gitlint option"): + config.set_general_option("_config_path", u"bår") + + # invalid verbosity + incorrect_values = [-1, u"föo"] + for value in incorrect_values: + expected_msg = u"Option 'verbosity' must be a positive integer (current value: '{0}')".format(value) + with self.assertRaisesRegex(LintConfigError, expected_msg): + config.verbosity = value + + incorrect_values = [4] + for value in incorrect_values: + with self.assertRaisesRegex(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, u"föo"] + for attribute in ignore_attributes: + for value in incorrect_values: + option_name = attribute.replace("_", "-") + with self.assertRaisesRegex(LintConfigError, + "Option '{0}' must be either 'true' or 'false'".format(option_name)): + 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']: + option_name = attribute.replace("_", "-") + with self.assertRaisesRegex(LintConfigError, + "Option '{0}' must be either 'true' or 'false'".format(option_name)): + setattr(config, attribute, u"föobar") + + # extra-path has its own negative test + + # invalid target + with self.assertRaisesRegex(LintConfigError, + u"Option target must be an existing directory (current value: 'föo/bar')"): + config.target = u"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) + + +class LintConfigGeneratorTests(BaseTestCase): + @staticmethod + @patch('gitlint.config.shutil.copyfile') + def test_install_commit_msg_hook_negative(copy): + LintConfigGenerator.generate_config(u"föo/bar/test") + copy.assert_called_with(GITLINT_CONFIG_TEMPLATE_SRC_PATH, u"föo/bar/test") diff --git a/gitlint/tests/config/test_config_builder.py b/gitlint/tests/config/test_config_builder.py new file mode 100644 index 0000000..051a52f --- /dev/null +++ b/gitlint/tests/config/test_config_builder.py @@ -0,0 +1,203 @@ +# -*- coding: utf-8 -*- + +from gitlint.tests.base import BaseTestCase + +from gitlint.config import LintConfig, LintConfigBuilder, LintConfigError + + +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(u"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(u"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(u"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(u"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(u"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(u"föo") + expected_error_msg = u"Invalid file path: {0}".format(foo_path) + with self.assertRaisesRegex(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 = u"File contains no section headers." + 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 = u"No such rule 'föobar'" + with self.assertRaisesRegex(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 = u"'foo' is not a valid gitlint option" + with self.assertRaisesRegex(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 = u"Rule 'title-max-length' has no option 'föobar'" + with self.assertRaisesRegex(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 = u"'föo' is not a valid value for option 'title-max-length.line-length'. " + \ + u"Option 'line-length' must be a positive integer (current value: 'föo')." + with self.assertRaisesRegex(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', + u"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'), [u"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([u"föo.bar=1"]) + with self.assertRaisesRegex(LintConfigError, u"No such rule 'föo'"): + config_builder.build() + + # no equal sign + expected_msg = u"'föo.bar' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesRegex(LintConfigError, expected_msg): + config_builder.set_config_from_string_list([u"föo.bar"]) + + # missing value + expected_msg = u"'föo.bar=' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesRegex(LintConfigError, expected_msg): + config_builder.set_config_from_string_list([u"föo.bar="]) + + # space instead of equal sign + expected_msg = u"'föo.bar 1' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesRegex(LintConfigError, expected_msg): + config_builder.set_config_from_string_list([u"föo.bar 1"]) + + # no period between rule and option names + expected_msg = u"'föobar=1' is an invalid configuration option. Use '<rule>.<option>=<value>'" + with self.assertRaisesRegex(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) diff --git a/gitlint/tests/config/test_config_precedence.py b/gitlint/tests/config/test_config_precedence.py new file mode 100644 index 0000000..9689e55 --- /dev/null +++ b/gitlint/tests/config/test_config_precedence.py @@ -0,0 +1,100 @@ +# -*- coding: utf-8 -*- + +try: + # python 2.x + from StringIO import StringIO +except ImportError: + # python 3.x + from io import StringIO + +from click.testing import CliRunner + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +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=u"WIP\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. commandline -c flags + # 3. config file + # 4. 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\"\n") + + # 2. 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") + + # 3. 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") + + # 4. 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\"\n") + + @patch('gitlint.cli.get_stdin_data', return_value=u"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(), + u"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 = u"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(), u"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 new file mode 100644 index 0000000..089992c --- /dev/null +++ b/gitlint/tests/config/test_rule_collection.py @@ -0,0 +1,64 @@ +# -*- 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, u"my-rüle", {"my_attr": u"föo", "my_attr2": 123}) + + expected = rules.TitleMaxLength() + expected.id = u"my-rüle" + expected.my_attr = u"föo" + expected.my_attr2 = 123 + + self.assertEqual(len(collection), 1) + self.assertDictEqual(collection._rules, OrderedDict({u"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": u"föo"}) + + # find by id + expected = rules.TitleMaxLength() + rule = collection.find_rule('T1') + self.assertEqual(rule, expected) + self.assertEqual(rule.my_attr, u"föo") + + # find by name + expected2 = rules.TitleTrailingWhitespace() + rule = collection.find_rule('title-trailing-whitespace') + self.assertEqual(rule, expected2) + self.assertEqual(rule.my_attr, u"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": u"bår"}) + collection.add_rules([rules.BodyHardTab], {"hur": u"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", u"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, u"dûr") diff --git a/gitlint/tests/contrib/__init__.py b/gitlint/tests/contrib/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint/tests/contrib/__init__.py diff --git a/gitlint/tests/contrib/test_contrib_rules.py b/gitlint/tests/contrib/test_contrib_rules.py new file mode 100644 index 0000000..3fa4048 --- /dev/null +++ b/gitlint/tests/contrib/test_contrib_rules.py @@ -0,0 +1,72 @@ +# -*- coding: utf-8 -*- +import os + +from gitlint.tests.base import BaseTestCase +from gitlint.contrib import rules as contrib_rules +from gitlint.tests import contrib as contrib_tests +from gitlint import rule_finder, rules + +from gitlint.utils import ustr + + +class ContribRuleTests(BaseTestCase): + + CONTRIB_DIR = os.path.dirname(os.path.realpath(contrib_rules.__file__)) + + def test_contrib_tests_exist(self): + """ Tests that every contrib rule file has an associated test file. + While this doesn't guarantee that every contrib rule has associated tests (as we don't check the content + of the tests file), it's a good leading indicator. """ + + contrib_tests_dir = os.path.dirname(os.path.realpath(contrib_tests.__file__)) + contrib_test_files = os.listdir(contrib_tests_dir) + + # Find all python files in the contrib dir and assert there's a corresponding test file + for filename in os.listdir(self.CONTRIB_DIR): + if filename.endswith(".py") and filename not in ["__init__.py"]: + expected_test_file = ustr(u"test_" + filename) + error_msg = u"Every Contrib Rule must have associated tests. " + \ + "Expected test file {0} not found.".format(os.path.join(contrib_tests_dir, + expected_test_file)) + self.assertIn(expected_test_file, contrib_test_files, error_msg) + + def test_contrib_rule_naming_conventions(self): + """ Tests that contrib rules follow certain naming conventions. + We can test for this at test time (and not during runtime like rule_finder.assert_valid_rule_class does) + because these are contrib rules: once they're part of gitlint they can't change unless they pass this test + again. + """ + rule_classes = rule_finder.find_rule_classes(self.CONTRIB_DIR) + + for clazz in rule_classes: + # Contrib rule names start with "contrib-" + self.assertTrue(clazz.name.startswith("contrib-")) + + # Contrib line rules id's start with "CL" + if issubclass(clazz, rules.LineRule): + if clazz.target == rules.CommitMessageTitle: + self.assertTrue(clazz.id.startswith("CT")) + elif clazz.target == rules.CommitMessageBody: + self.assertTrue(clazz.id.startswith("CB")) + + def test_contrib_rule_uniqueness(self): + """ Tests that all contrib rules have unique identifiers. + We can test for this at test time (and not during runtime like rule_finder.assert_valid_rule_class does) + because these are contrib rules: once they're part of gitlint they can't change unless they pass this test + again. + """ + rule_classes = rule_finder.find_rule_classes(self.CONTRIB_DIR) + + # Not very efficient way of checking uniqueness, but it works :-) + class_names = [rule_class.name for rule_class in rule_classes] + class_ids = [rule_class.id for rule_class in rule_classes] + self.assertEqual(len(set(class_names)), len(class_names)) + self.assertEqual(len(set(class_ids)), len(class_ids)) + + def test_contrib_rule_instantiated(self): + """ Tests that all contrib rules can be instantiated without errors. """ + rule_classes = rule_finder.find_rule_classes(self.CONTRIB_DIR) + + # No exceptions = what we want :-) + for rule_class in rule_classes: + rule_class() diff --git a/gitlint/tests/contrib/test_conventional_commit.py b/gitlint/tests/contrib/test_conventional_commit.py new file mode 100644 index 0000000..ea808fd --- /dev/null +++ b/gitlint/tests/contrib/test_conventional_commit.py @@ -0,0 +1,47 @@ + +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint.rules import RuleViolation +from gitlint.contrib.rules.conventional_commit import ConventionalCommit +from gitlint.config import LintConfig + + +class ContribConventionalCommitTests(BaseTestCase): + + def test_enable(self): + # Test that rule can be enabled in config + for rule_ref in ['CT1', 'contrib-title-conventional-commits']: + config = LintConfig() + config.contrib = [rule_ref] + self.assertIn(ConventionalCommit(), config.rules) + + def test_conventional_commits(self): + rule = ConventionalCommit() + + # No violations when using a correct type and format + for type in ["fix", "feat", "chore", "docs", "style", "refactor", "perf", "test", "revert"]: + violations = rule.validate(type + u": föo", None) + self.assertListEqual([], violations) + + # assert violation on wrong type + expected_violation = RuleViolation("CT1", "Title does not start with one of fix, feat, chore, docs," + " style, refactor, perf, test, revert", u"bår: foo") + violations = rule.validate(u"bår: foo", None) + self.assertListEqual([expected_violation], violations) + + # assert violation on wrong format + expected_violation = RuleViolation("CT1", "Title does not follow ConventionalCommits.org format " + "'type(optional-scope): description'", u"fix föo") + violations = rule.validate(u"fix föo", None) + self.assertListEqual([expected_violation], violations) + + # assert no violation when adding new type + rule = ConventionalCommit({'types': [u"föo", u"bär"]}) + for typ in [u"föo", u"bär"]: + violations = rule.validate(typ + u": hür dur", None) + self.assertListEqual([], violations) + + # assert violation when using incorrect type when types have been reconfigured + violations = rule.validate(u"fix: hür dur", None) + expected_violation = RuleViolation("CT1", u"Title does not start with one of föo, bär", u"fix: hür dur") + self.assertListEqual([expected_violation], violations) diff --git a/gitlint/tests/contrib/test_signedoff_by.py b/gitlint/tests/contrib/test_signedoff_by.py new file mode 100644 index 0000000..934aec5 --- /dev/null +++ b/gitlint/tests/contrib/test_signedoff_by.py @@ -0,0 +1,32 @@ + +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint.rules import RuleViolation +from gitlint.contrib.rules.signedoff_by import SignedOffBy + +from gitlint.config import LintConfig + + +class ContribSignedOffByTests(BaseTestCase): + + def test_enable(self): + # Test that rule can be enabled in config + for rule_ref in ['CC1', 'contrib-body-requires-signed-off-by']: + config = LintConfig() + config.contrib = [rule_ref] + self.assertIn(SignedOffBy(), config.rules) + + def test_signedoff_by(self): + # No violations when 'Signed-Off-By' line is present + rule = SignedOffBy() + violations = rule.validate(self.gitcommit(u"Föobar\n\nMy Body\nSigned-Off-By: John Smith")) + self.assertListEqual([], violations) + + # Assert violation when no 'Signed-Off-By' line is present + violations = rule.validate(self.gitcommit(u"Föobar\n\nMy Body")) + expected_violation = RuleViolation("CC1", "Body does not contain a 'Signed-Off-By' line", line_nr=1) + self.assertListEqual(violations, [expected_violation]) + + # Assert violation when no 'Signed-Off-By' in title but not in body + violations = rule.validate(self.gitcommit(u"Signed-Off-By\n\nFöobar")) + self.assertListEqual(violations, [expected_violation]) diff --git a/gitlint/tests/expected/test_cli/test_contrib_1 b/gitlint/tests/expected/test_cli/test_contrib_1 new file mode 100644 index 0000000..ea5d353 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_contrib_1 @@ -0,0 +1,3 @@ +1: CC1 Body does not contain a 'Signed-Off-By' line +1: CT1 Title does not start with one of fix, feat, chore, docs, style, refactor, perf, test, revert: "Test tïtle" +1: CT1 Title does not follow ConventionalCommits.org format 'type(optional-scope): description': "Test tïtle" diff --git a/gitlint/tests/expected/test_cli/test_debug_1 b/gitlint/tests/expected/test_cli/test_debug_1 new file mode 100644 index 0000000..612f78e --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_debug_1 @@ -0,0 +1,102 @@ +DEBUG: gitlint.cli To report issues, please visit https://github.com/jorisroovers/gitlint/issues +DEBUG: gitlint.cli Platform: {platform} +DEBUG: gitlint.cli Python version: {python_version} +DEBUG: gitlint.cli Git version: git version 1.2.3 +DEBUG: gitlint.cli Gitlint version: {gitlint_version} +DEBUG: gitlint.cli GITLINT_USE_SH_LIB: {GITLINT_USE_SH_LIB} +DEBUG: gitlint.cli Configuration +config-path: {config_path} +[GENERAL] +extra-path: None +contrib: [] +ignore: title-trailing-whitespace,B2 +ignore-merge-commits: False +ignore-fixup-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: False +verbosity: 1 +debug: True +target: {target} +[RULES] + I1: ignore-by-title + ignore=all + regex=None + I2: ignore-by-body + ignore=all + regex=None + T1: title-max-length + line-length=20 + T2: title-trailing-whitespace + T6: title-leading-whitespace + T3: title-trailing-punctuation + T4: title-hard-tab + T5: title-must-not-contain-word + words=WIP,bögus + T7: title-match-regex + regex=.* + B1: body-max-line-length + line-length=30 + B5: body-min-length + min-length=20 + B6: body-is-missing + ignore-merge-commits=True + B2: body-trailing-whitespace + B3: body-hard-tab + B4: body-first-line-empty + B7: body-changed-file-mention + files= + M1: author-valid-email + regex=[^@ ]+@[^@ ]+\.[^@ ]+ + +DEBUG: gitlint.cli No --msg-filename flag, no or empty data passed to stdin. Using the local repo. +DEBUG: gitlint.cli Linting 3 commit(s) +DEBUG: gitlint.lint Linting commit 6f29bf81a8322a04071bb794666e48c443a90360 +DEBUG: gitlint.lint Commit Object +--- Commit Message ---- +commït-title1 + +commït-body1 +--- Meta info --------- +Author: test åuthor1 <test-email1@föo.com> +Date: 2016-12-03 15:28:15 +0100 +is-merge-commit: False +is-fixup-commit: False +is-squash-commit: False +is-revert-commit: False +Branches: ['commit-1-branch-1', 'commit-1-branch-2'] +Changed Files: ['commit-1/file-1', 'commit-1/file-2'] +----------------------- +DEBUG: gitlint.lint Linting commit 25053ccec5e28e1bb8f7551fdbb5ab213ada2401 +DEBUG: gitlint.lint Commit Object +--- Commit Message ---- +commït-title2. + +commït-body2 +--- Meta info --------- +Author: test åuthor2 <test-email2@föo.com> +Date: 2016-12-04 15:28:15 +0100 +is-merge-commit: False +is-fixup-commit: False +is-squash-commit: False +is-revert-commit: False +Branches: ['commit-2-branch-1', 'commit-2-branch-2'] +Changed Files: ['commit-2/file-1', 'commit-2/file-2'] +----------------------- +DEBUG: gitlint.lint Linting commit 4da2656b0dadc76c7ee3fd0243a96cb64007f125 +DEBUG: gitlint.lint Commit Object +--- Commit Message ---- +föo +bar +--- Meta info --------- +Author: test åuthor3 <test-email3@föo.com> +Date: 2016-12-05 15:28:15 +0100 +is-merge-commit: False +is-fixup-commit: False +is-squash-commit: False +is-revert-commit: False +Branches: ['commit-3-branch-1', 'commit-3-branch-2'] +Changed Files: ['commit-3/file-1', 'commit-3/file-2'] +----------------------- +DEBUG: gitlint.cli Exit Code = 6
\ No newline at end of file diff --git a/gitlint/tests/expected/test_cli/test_input_stream_1 b/gitlint/tests/expected/test_cli/test_input_stream_1 new file mode 100644 index 0000000..4326729 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_input_stream_1 @@ -0,0 +1,3 @@ +1: T2 Title has trailing whitespace: "WIP: tïtle " +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle " +3: B6 Body message is missing diff --git a/gitlint/tests/expected/test_cli/test_input_stream_debug_1 b/gitlint/tests/expected/test_cli/test_input_stream_debug_1 new file mode 100644 index 0000000..4326729 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_input_stream_debug_1 @@ -0,0 +1,3 @@ +1: T2 Title has trailing whitespace: "WIP: tïtle " +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle " +3: B6 Body message is missing diff --git a/gitlint/tests/expected/test_cli/test_input_stream_debug_2 b/gitlint/tests/expected/test_cli/test_input_stream_debug_2 new file mode 100644 index 0000000..a9028e1 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_input_stream_debug_2 @@ -0,0 +1,71 @@ +DEBUG: gitlint.cli To report issues, please visit https://github.com/jorisroovers/gitlint/issues +DEBUG: gitlint.cli Platform: {platform} +DEBUG: gitlint.cli Python version: {python_version} +DEBUG: gitlint.cli Git version: git version 1.2.3 +DEBUG: gitlint.cli Gitlint version: {gitlint_version} +DEBUG: gitlint.cli GITLINT_USE_SH_LIB: {GITLINT_USE_SH_LIB} +DEBUG: gitlint.cli Configuration +config-path: None +[GENERAL] +extra-path: None +contrib: [] +ignore: +ignore-merge-commits: True +ignore-fixup-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: False +verbosity: 3 +debug: True +target: {target} +[RULES] + I1: ignore-by-title + ignore=all + regex=None + I2: ignore-by-body + ignore=all + regex=None + T1: title-max-length + line-length=72 + T2: title-trailing-whitespace + T6: title-leading-whitespace + T3: title-trailing-punctuation + T4: title-hard-tab + T5: title-must-not-contain-word + words=WIP + T7: title-match-regex + regex=.* + B1: body-max-line-length + line-length=80 + B5: body-min-length + min-length=20 + B6: body-is-missing + ignore-merge-commits=True + B2: body-trailing-whitespace + B3: body-hard-tab + B4: body-first-line-empty + B7: body-changed-file-mention + files= + M1: author-valid-email + regex=[^@ ]+@[^@ ]+\.[^@ ]+ + +DEBUG: gitlint.cli Stdin data: 'WIP: tïtle +' +DEBUG: gitlint.cli Stdin detected and not ignored. Using as input. +DEBUG: gitlint.cli Linting 1 commit(s) +DEBUG: gitlint.lint Linting commit [SHA UNKNOWN] +DEBUG: gitlint.lint Commit Object +--- Commit Message ---- +WIP: tïtle +--- Meta info --------- +Author: None <None> +Date: None +is-merge-commit: False +is-fixup-commit: False +is-squash-commit: False +is-revert-commit: False +Branches: [] +Changed Files: [] +----------------------- +DEBUG: gitlint.cli Exit Code = 3
\ No newline at end of file diff --git a/gitlint/tests/expected/test_cli/test_lint_multiple_commits_1 b/gitlint/tests/expected/test_cli/test_lint_multiple_commits_1 new file mode 100644 index 0000000..be3288b --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_lint_multiple_commits_1 @@ -0,0 +1,8 @@ +Commit 6f29bf81a8: +3: B5 Body message is too short (12<20): "commït-body1" + +Commit 25053ccec5: +3: B5 Body message is too short (12<20): "commït-body2" + +Commit 4da2656b0d: +3: B5 Body message is too short (12<20): "commït-body3" diff --git a/gitlint/tests/expected/test_cli/test_lint_multiple_commits_config_1 b/gitlint/tests/expected/test_cli/test_lint_multiple_commits_config_1 new file mode 100644 index 0000000..1bf0503 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_lint_multiple_commits_config_1 @@ -0,0 +1,6 @@ +Commit 6f29bf81a8: +3: B5 Body message is too short (12<20): "commït-body1" + +Commit 4da2656b0d: +1: T3 Title has trailing punctuation (.): "commït-title3." +3: B5 Body message is too short (12<20): "commït-body3" diff --git a/gitlint/tests/expected/test_cli/test_lint_staged_msg_filename_1 b/gitlint/tests/expected/test_cli/test_lint_staged_msg_filename_1 new file mode 100644 index 0000000..9a9091b --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_lint_staged_msg_filename_1 @@ -0,0 +1,2 @@ +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: msg-filename tïtle" +3: B6 Body message is missing diff --git a/gitlint/tests/expected/test_cli/test_lint_staged_msg_filename_2 b/gitlint/tests/expected/test_cli/test_lint_staged_msg_filename_2 new file mode 100644 index 0000000..3e5dcb6 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_lint_staged_msg_filename_2 @@ -0,0 +1,70 @@ +DEBUG: gitlint.cli To report issues, please visit https://github.com/jorisroovers/gitlint/issues +DEBUG: gitlint.cli Platform: {platform} +DEBUG: gitlint.cli Python version: {python_version} +DEBUG: gitlint.cli Git version: git version 1.2.3 +DEBUG: gitlint.cli Gitlint version: {gitlint_version} +DEBUG: gitlint.cli GITLINT_USE_SH_LIB: {GITLINT_USE_SH_LIB} +DEBUG: gitlint.cli Configuration +config-path: None +[GENERAL] +extra-path: None +contrib: [] +ignore: +ignore-merge-commits: True +ignore-fixup-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: True +verbosity: 3 +debug: True +target: {target} +[RULES] + I1: ignore-by-title + ignore=all + regex=None + I2: ignore-by-body + ignore=all + regex=None + T1: title-max-length + line-length=72 + T2: title-trailing-whitespace + T6: title-leading-whitespace + T3: title-trailing-punctuation + T4: title-hard-tab + T5: title-must-not-contain-word + words=WIP + T7: title-match-regex + regex=.* + B1: body-max-line-length + line-length=80 + B5: body-min-length + min-length=20 + B6: body-is-missing + ignore-merge-commits=True + B2: body-trailing-whitespace + B3: body-hard-tab + B4: body-first-line-empty + B7: body-changed-file-mention + files= + M1: author-valid-email + regex=[^@ ]+@[^@ ]+\.[^@ ]+ + +DEBUG: gitlint.cli Fetching additional meta-data from staged commit +DEBUG: gitlint.cli Using --msg-filename. +DEBUG: gitlint.cli Linting 1 commit(s) +DEBUG: gitlint.lint Linting commit [SHA UNKNOWN] +DEBUG: gitlint.lint Commit Object +--- Commit Message ---- +WIP: msg-filename tïtle +--- Meta info --------- +Author: föo user <föo@bar.com> +Date: 2020-02-19 12:18:46 +0100 +is-merge-commit: False +is-fixup-commit: False +is-squash-commit: False +is-revert-commit: False +Branches: ['my-branch'] +Changed Files: ['commit-1/file-1', 'commit-1/file-2'] +----------------------- +DEBUG: gitlint.cli Exit Code = 2
\ No newline at end of file diff --git a/gitlint/tests/expected/test_cli/test_lint_staged_stdin_1 b/gitlint/tests/expected/test_cli/test_lint_staged_stdin_1 new file mode 100644 index 0000000..4326729 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_lint_staged_stdin_1 @@ -0,0 +1,3 @@ +1: T2 Title has trailing whitespace: "WIP: tïtle " +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle " +3: B6 Body message is missing diff --git a/gitlint/tests/expected/test_cli/test_lint_staged_stdin_2 b/gitlint/tests/expected/test_cli/test_lint_staged_stdin_2 new file mode 100644 index 0000000..03fd8c3 --- /dev/null +++ b/gitlint/tests/expected/test_cli/test_lint_staged_stdin_2 @@ -0,0 +1,72 @@ +DEBUG: gitlint.cli To report issues, please visit https://github.com/jorisroovers/gitlint/issues +DEBUG: gitlint.cli Platform: {platform} +DEBUG: gitlint.cli Python version: {python_version} +DEBUG: gitlint.cli Git version: git version 1.2.3 +DEBUG: gitlint.cli Gitlint version: {gitlint_version} +DEBUG: gitlint.cli GITLINT_USE_SH_LIB: {GITLINT_USE_SH_LIB} +DEBUG: gitlint.cli Configuration +config-path: None +[GENERAL] +extra-path: None +contrib: [] +ignore: +ignore-merge-commits: True +ignore-fixup-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: True +verbosity: 3 +debug: True +target: {target} +[RULES] + I1: ignore-by-title + ignore=all + regex=None + I2: ignore-by-body + ignore=all + regex=None + T1: title-max-length + line-length=72 + T2: title-trailing-whitespace + T6: title-leading-whitespace + T3: title-trailing-punctuation + T4: title-hard-tab + T5: title-must-not-contain-word + words=WIP + T7: title-match-regex + regex=.* + B1: body-max-line-length + line-length=80 + B5: body-min-length + min-length=20 + B6: body-is-missing + ignore-merge-commits=True + B2: body-trailing-whitespace + B3: body-hard-tab + B4: body-first-line-empty + B7: body-changed-file-mention + files= + M1: author-valid-email + regex=[^@ ]+@[^@ ]+\.[^@ ]+ + +DEBUG: gitlint.cli Fetching additional meta-data from staged commit +DEBUG: gitlint.cli Stdin data: 'WIP: tïtle +' +DEBUG: gitlint.cli Stdin detected and not ignored. Using as input. +DEBUG: gitlint.cli Linting 1 commit(s) +DEBUG: gitlint.lint Linting commit [SHA UNKNOWN] +DEBUG: gitlint.lint Commit Object +--- Commit Message ---- +WIP: tïtle +--- Meta info --------- +Author: föo user <föo@bar.com> +Date: 2020-02-19 12:18:46 +0100 +is-merge-commit: False +is-fixup-commit: False +is-squash-commit: False +is-revert-commit: False +Branches: ['my-branch'] +Changed Files: ['commit-1/file-1', 'commit-1/file-2'] +----------------------- +DEBUG: gitlint.cli Exit Code = 3
\ No newline at end of file diff --git a/gitlint/tests/git/test_git.py b/gitlint/tests/git/test_git.py new file mode 100644 index 0000000..297b10c --- /dev/null +++ b/gitlint/tests/git/test_git.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +import os + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +from gitlint.shell import ErrorReturnCode, CommandNotFound + +from gitlint.tests.base import BaseTestCase +from gitlint.git import GitContext, GitContextError, GitNotInstalledError, git_commentchar, git_hooks_dir + + +class GitTests(BaseTestCase): + + # Expected special_args passed to 'sh' + expected_sh_special_args = { + '_tty_out': False, + '_cwd': u"fåke/path" + } + + @patch('gitlint.git.sh') + def test_get_latest_commit_command_not_found(self, sh): + sh.git.side_effect = CommandNotFound("git") + expected_msg = "'git' command not found. You need to install git to use gitlint on a local repository. " + \ + "See https://git-scm.com/book/en/v2/Getting-Started-Installing-Git on how to install git." + with self.assertRaisesRegex(GitNotInstalledError, expected_msg): + GitContext.from_local_repository(u"fåke/path") + + # assert that commit message was read using git command + sh.git.assert_called_once_with("log", "-1", "--pretty=%H", **self.expected_sh_special_args) + + @patch('gitlint.git.sh') + def test_get_latest_commit_git_error(self, sh): + # Current directory not a git repo + err = b"fatal: Not a git repository (or any of the parent directories): .git" + sh.git.side_effect = ErrorReturnCode("git log -1 --pretty=%H", b"", err) + + with self.assertRaisesRegex(GitContextError, u"fåke/path is not a git repository."): + GitContext.from_local_repository(u"fåke/path") + + # assert that commit message was read using git command + sh.git.assert_called_once_with("log", "-1", "--pretty=%H", **self.expected_sh_special_args) + sh.git.reset_mock() + + err = b"fatal: Random git error" + sh.git.side_effect = ErrorReturnCode("git log -1 --pretty=%H", b"", err) + + expected_msg = u"An error occurred while executing 'git log -1 --pretty=%H': {0}".format(err) + with self.assertRaisesRegex(GitContextError, expected_msg): + GitContext.from_local_repository(u"fåke/path") + + # assert that commit message was read using git command + sh.git.assert_called_once_with("log", "-1", "--pretty=%H", **self.expected_sh_special_args) + + @patch('gitlint.git.sh') + def test_git_no_commits_error(self, sh): + # No commits: returned by 'git log' + err = b"fatal: your current branch 'master' does not have any commits yet" + + sh.git.side_effect = ErrorReturnCode("git log -1 --pretty=%H", b"", err) + + expected_msg = u"Current branch has no commits. Gitlint requires at least one commit to function." + with self.assertRaisesRegex(GitContextError, expected_msg): + GitContext.from_local_repository(u"fåke/path") + + # assert that commit message was read using git command + sh.git.assert_called_once_with("log", "-1", "--pretty=%H", **self.expected_sh_special_args) + sh.git.reset_mock() + + # Unknown reference 'HEAD' commits: returned by 'git rev-parse' + err = (b"HEAD" + b"fatal: ambiguous argument 'HEAD': unknown revision or path not in the working tree." + b"Use '--' to separate paths from revisions, like this:" + b"'git <command> [<revision>...] -- [<file>...]'") + + sh.git.side_effect = [ + u"#\n", # git config --get core.commentchar + ErrorReturnCode("rev-parse --abbrev-ref HEAD", b"", err) + ] + + with self.assertRaisesRegex(GitContextError, expected_msg): + context = GitContext.from_commit_msg(u"test") + context.current_branch + + # assert that commit message was read using git command + sh.git.assert_called_with("rev-parse", "--abbrev-ref", "HEAD", _tty_out=False, _cwd=None) + + @patch("gitlint.git._git") + def test_git_commentchar(self, git): + git.return_value.exit_code = 1 + self.assertEqual(git_commentchar(), "#") + + git.return_value.exit_code = 0 + git.return_value.__str__ = lambda _: u"ä" + git.return_value.__unicode__ = lambda _: u"ä" + self.assertEqual(git_commentchar(), u"ä") + + git.return_value = ';\n' + self.assertEqual(git_commentchar(os.path.join(u"/föo", u"bar")), ';') + + git.assert_called_with("config", "--get", "core.commentchar", _ok_code=[0, 1], + _cwd=os.path.join(u"/föo", u"bar")) + + @patch("gitlint.git._git") + def test_git_hooks_dir(self, git): + hooks_dir = os.path.join(u"föo", ".git", "hooks") + git.return_value.__str__ = lambda _: hooks_dir + "\n" + git.return_value.__unicode__ = lambda _: hooks_dir + "\n" + self.assertEqual(git_hooks_dir(u"/blä"), os.path.abspath(os.path.join(u"/blä", hooks_dir))) + + git.assert_called_once_with("rev-parse", "--git-path", "hooks", _cwd=u"/blä") diff --git a/gitlint/tests/git/test_git_commit.py b/gitlint/tests/git/test_git_commit.py new file mode 100644 index 0000000..dc83ccb --- /dev/null +++ b/gitlint/tests/git/test_git_commit.py @@ -0,0 +1,535 @@ +# -*- coding: utf-8 -*- +import copy +import datetime + +import dateutil + +import arrow + +try: + # python 2.x + from mock import patch, call +except ImportError: + # python 3.x + from unittest.mock import patch, call # pylint: disable=no-name-in-module, import-error + +from gitlint.tests.base import BaseTestCase +from gitlint.git import GitContext, GitCommit, LocalGitCommit, StagedLocalGitCommit, GitCommitMessage + + +class GitCommitTests(BaseTestCase): + + # Expected special_args passed to 'sh' + expected_sh_special_args = { + '_tty_out': False, + '_cwd': u"fåke/path" + } + + @patch('gitlint.git.sh') + def test_get_latest_commit(self, sh): + sample_sha = "d8ac47e9f2923c7f22d8668e3a1ed04eb4cdbca9" + + sh.git.side_effect = [ + sample_sha, + u"test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"cömmit-title\n\ncömmit-body", + u"#", # git config --get core.commentchar + u"file1.txt\npåth/to/file2.txt\n", + u"foöbar\n* hürdur\n" + ] + + context = GitContext.from_local_repository(u"fåke/path") + # assert that commit info was read using git command + expected_calls = [ + call("log", "-1", "--pretty=%H", **self.expected_sh_special_args), + call("log", sample_sha, "-1", "--pretty=%aN%x00%aE%x00%ai%x00%P%n%B", **self.expected_sh_special_args), + call('config', '--get', 'core.commentchar', _ok_code=[0, 1], **self.expected_sh_special_args), + call('diff-tree', '--no-commit-id', '--name-only', '-r', '--root', sample_sha, + **self.expected_sh_special_args), + call('branch', '--contains', sample_sha, **self.expected_sh_special_args) + ] + + # Only first 'git log' call should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:1]) + + last_commit = context.commits[-1] + self.assertIsInstance(last_commit, LocalGitCommit) + self.assertEqual(last_commit.sha, sample_sha) + self.assertEqual(last_commit.message.title, u"cömmit-title") + self.assertEqual(last_commit.message.body, ["", u"cömmit-body"]) + self.assertEqual(last_commit.author_name, u"test åuthor") + self.assertEqual(last_commit.author_email, u"test-emåil@foo.com") + self.assertEqual(last_commit.date, datetime.datetime(2016, 12, 3, 15, 28, 15, + tzinfo=dateutil.tz.tzoffset("+0100", 3600))) + self.assertListEqual(last_commit.parents, [u"åbc"]) + self.assertFalse(last_commit.is_merge_commit) + self.assertFalse(last_commit.is_fixup_commit) + self.assertFalse(last_commit.is_squash_commit) + self.assertFalse(last_commit.is_revert_commit) + + # First 2 'git log' calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:3]) + + self.assertListEqual(last_commit.changed_files, ["file1.txt", u"påth/to/file2.txt"]) + # 'git diff-tree' should have happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:4]) + + self.assertListEqual(last_commit.branches, [u"foöbar", u"hürdur"]) + # All expected calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls) + + @patch('gitlint.git.sh') + def test_from_local_repository_specific_ref(self, sh): + sample_sha = "myspecialref" + + sh.git.side_effect = [ + sample_sha, + u"test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"cömmit-title\n\ncömmit-body", + u"#", # git config --get core.commentchar + u"file1.txt\npåth/to/file2.txt\n", + u"foöbar\n* hürdur\n" + ] + + context = GitContext.from_local_repository(u"fåke/path", sample_sha) + # assert that commit info was read using git command + expected_calls = [ + call("rev-list", sample_sha, **self.expected_sh_special_args), + call("log", sample_sha, "-1", "--pretty=%aN%x00%aE%x00%ai%x00%P%n%B", **self.expected_sh_special_args), + call('config', '--get', 'core.commentchar', _ok_code=[0, 1], **self.expected_sh_special_args), + call('diff-tree', '--no-commit-id', '--name-only', '-r', '--root', sample_sha, + **self.expected_sh_special_args), + call('branch', '--contains', sample_sha, **self.expected_sh_special_args) + ] + + # Only first 'git log' call should've happened at this point + self.assertEqual(sh.git.mock_calls, expected_calls[:1]) + + last_commit = context.commits[-1] + self.assertIsInstance(last_commit, LocalGitCommit) + self.assertEqual(last_commit.sha, sample_sha) + self.assertEqual(last_commit.message.title, u"cömmit-title") + self.assertEqual(last_commit.message.body, ["", u"cömmit-body"]) + self.assertEqual(last_commit.author_name, u"test åuthor") + self.assertEqual(last_commit.author_email, u"test-emåil@foo.com") + self.assertEqual(last_commit.date, datetime.datetime(2016, 12, 3, 15, 28, 15, + tzinfo=dateutil.tz.tzoffset("+0100", 3600))) + self.assertListEqual(last_commit.parents, [u"åbc"]) + self.assertFalse(last_commit.is_merge_commit) + self.assertFalse(last_commit.is_fixup_commit) + self.assertFalse(last_commit.is_squash_commit) + self.assertFalse(last_commit.is_revert_commit) + + # First 2 'git log' calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:3]) + + self.assertListEqual(last_commit.changed_files, ["file1.txt", u"påth/to/file2.txt"]) + # 'git diff-tree' should have happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:4]) + + self.assertListEqual(last_commit.branches, [u"foöbar", u"hürdur"]) + # All expected calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls) + + @patch('gitlint.git.sh') + def test_get_latest_commit_merge_commit(self, sh): + sample_sha = "d8ac47e9f2923c7f22d8668e3a1ed04eb4cdbca9" + + sh.git.side_effect = [ + sample_sha, + u"test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc def\n" + u"Merge \"foo bår commit\"", + u"#", # git config --get core.commentchar + u"file1.txt\npåth/to/file2.txt\n", + u"foöbar\n* hürdur\n" + ] + + context = GitContext.from_local_repository(u"fåke/path") + # assert that commit info was read using git command + expected_calls = [ + call("log", "-1", "--pretty=%H", **self.expected_sh_special_args), + call("log", sample_sha, "-1", "--pretty=%aN%x00%aE%x00%ai%x00%P%n%B", **self.expected_sh_special_args), + call('config', '--get', 'core.commentchar', _ok_code=[0, 1], **self.expected_sh_special_args), + call('diff-tree', '--no-commit-id', '--name-only', '-r', '--root', sample_sha, + **self.expected_sh_special_args), + call('branch', '--contains', sample_sha, **self.expected_sh_special_args) + ] + + # Only first 'git log' call should've happened at this point + self.assertEqual(sh.git.mock_calls, expected_calls[:1]) + + last_commit = context.commits[-1] + self.assertIsInstance(last_commit, LocalGitCommit) + self.assertEqual(last_commit.sha, sample_sha) + self.assertEqual(last_commit.message.title, u"Merge \"foo bår commit\"") + self.assertEqual(last_commit.message.body, []) + self.assertEqual(last_commit.author_name, u"test åuthor") + self.assertEqual(last_commit.author_email, u"test-emåil@foo.com") + self.assertEqual(last_commit.date, datetime.datetime(2016, 12, 3, 15, 28, 15, + tzinfo=dateutil.tz.tzoffset("+0100", 3600))) + self.assertListEqual(last_commit.parents, [u"åbc", "def"]) + self.assertTrue(last_commit.is_merge_commit) + self.assertFalse(last_commit.is_fixup_commit) + self.assertFalse(last_commit.is_squash_commit) + self.assertFalse(last_commit.is_revert_commit) + + # First 2 'git log' calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:3]) + + self.assertListEqual(last_commit.changed_files, ["file1.txt", u"påth/to/file2.txt"]) + # 'git diff-tree' should have happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:4]) + + self.assertListEqual(last_commit.branches, [u"foöbar", u"hürdur"]) + # All expected calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls) + + @patch('gitlint.git.sh') + def test_get_latest_commit_fixup_squash_commit(self, sh): + commit_types = ["fixup", "squash"] + for commit_type in commit_types: + sample_sha = "d8ac47e9f2923c7f22d8668e3a1ed04eb4cdbca9" + + sh.git.side_effect = [ + sample_sha, + u"test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + u"{0}! \"foo bår commit\"".format(commit_type), + u"#", # git config --get core.commentchar + u"file1.txt\npåth/to/file2.txt\n", + u"foöbar\n* hürdur\n" + ] + + context = GitContext.from_local_repository(u"fåke/path") + # assert that commit info was read using git command + expected_calls = [ + call("log", "-1", "--pretty=%H", **self.expected_sh_special_args), + call("log", sample_sha, "-1", "--pretty=%aN%x00%aE%x00%ai%x00%P%n%B", **self.expected_sh_special_args), + call('config', '--get', 'core.commentchar', _ok_code=[0, 1], **self.expected_sh_special_args), + call('diff-tree', '--no-commit-id', '--name-only', '-r', '--root', sample_sha, + **self.expected_sh_special_args), + call('branch', '--contains', sample_sha, **self.expected_sh_special_args) + ] + + # Only first 'git log' call should've happened at this point + self.assertEqual(sh.git.mock_calls, expected_calls[:-4]) + + last_commit = context.commits[-1] + self.assertIsInstance(last_commit, LocalGitCommit) + self.assertEqual(last_commit.sha, sample_sha) + self.assertEqual(last_commit.message.title, u"{0}! \"foo bår commit\"".format(commit_type)) + self.assertEqual(last_commit.message.body, []) + self.assertEqual(last_commit.author_name, u"test åuthor") + self.assertEqual(last_commit.author_email, u"test-emåil@foo.com") + self.assertEqual(last_commit.date, datetime.datetime(2016, 12, 3, 15, 28, 15, + tzinfo=dateutil.tz.tzoffset("+0100", 3600))) + self.assertListEqual(last_commit.parents, [u"åbc"]) + + # First 2 'git log' calls should've happened at this point + self.assertEqual(sh.git.mock_calls, expected_calls[:3]) + + # Asserting that squash and fixup are correct + for type in commit_types: + attr = "is_" + type + "_commit" + self.assertEqual(getattr(last_commit, attr), commit_type == type) + + self.assertFalse(last_commit.is_merge_commit) + self.assertFalse(last_commit.is_revert_commit) + self.assertListEqual(last_commit.changed_files, ["file1.txt", u"påth/to/file2.txt"]) + + self.assertListEqual(last_commit.changed_files, ["file1.txt", u"påth/to/file2.txt"]) + # 'git diff-tree' should have happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:4]) + + self.assertListEqual(last_commit.branches, [u"foöbar", u"hürdur"]) + # All expected calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls) + + sh.git.reset_mock() + + @patch("gitlint.git.git_commentchar") + def test_from_commit_msg_full(self, commentchar): + commentchar.return_value = u"#" + gitcontext = GitContext.from_commit_msg(self.get_sample("commit_message/sample1")) + + expected_title = u"Commit title contåining 'WIP', as well as trailing punctuation." + expected_body = ["This line should be empty", + "This is the first line of the commit message body and it is meant to test a " + + "line that exceeds the maximum line length of 80 characters.", + u"This line has a tråiling space. ", + "This line has a trailing tab.\t"] + expected_full = expected_title + "\n" + "\n".join(expected_body) + expected_original = expected_full + ( + u"\n# This is a cömmented line\n" + u"# ------------------------ >8 ------------------------\n" + u"# Anything after this line should be cleaned up\n" + u"# this line appears on `git commit -v` command\n" + u"diff --git a/gitlint/tests/samples/commit_message/sample1 " + u"b/gitlint/tests/samples/commit_message/sample1\n" + u"index 82dbe7f..ae71a14 100644\n" + u"--- a/gitlint/tests/samples/commit_message/sample1\n" + u"+++ b/gitlint/tests/samples/commit_message/sample1\n" + u"@@ -1 +1 @@\n" + ) + + commit = gitcontext.commits[-1] + self.assertIsInstance(commit, GitCommit) + self.assertFalse(isinstance(commit, LocalGitCommit)) + self.assertEqual(commit.message.title, expected_title) + self.assertEqual(commit.message.body, expected_body) + self.assertEqual(commit.message.full, expected_full) + self.assertEqual(commit.message.original, expected_original) + self.assertEqual(commit.author_name, None) + self.assertEqual(commit.author_email, None) + self.assertEqual(commit.date, None) + self.assertListEqual(commit.parents, []) + self.assertListEqual(commit.branches, []) + self.assertFalse(commit.is_merge_commit) + self.assertFalse(commit.is_fixup_commit) + self.assertFalse(commit.is_squash_commit) + self.assertFalse(commit.is_revert_commit) + self.assertEqual(len(gitcontext.commits), 1) + + def test_from_commit_msg_just_title(self): + gitcontext = GitContext.from_commit_msg(self.get_sample("commit_message/sample2")) + commit = gitcontext.commits[-1] + + self.assertIsInstance(commit, GitCommit) + self.assertFalse(isinstance(commit, LocalGitCommit)) + self.assertEqual(commit.message.title, u"Just a title contåining WIP") + self.assertEqual(commit.message.body, []) + self.assertEqual(commit.message.full, u"Just a title contåining WIP") + self.assertEqual(commit.message.original, u"Just a title contåining WIP") + self.assertEqual(commit.author_name, None) + self.assertEqual(commit.author_email, None) + self.assertListEqual(commit.parents, []) + self.assertListEqual(commit.branches, []) + self.assertFalse(commit.is_merge_commit) + self.assertFalse(commit.is_fixup_commit) + self.assertFalse(commit.is_squash_commit) + self.assertFalse(commit.is_revert_commit) + self.assertEqual(len(gitcontext.commits), 1) + + def test_from_commit_msg_empty(self): + gitcontext = GitContext.from_commit_msg("") + commit = gitcontext.commits[-1] + + self.assertIsInstance(commit, GitCommit) + self.assertFalse(isinstance(commit, LocalGitCommit)) + self.assertEqual(commit.message.title, "") + self.assertEqual(commit.message.body, []) + self.assertEqual(commit.message.full, "") + self.assertEqual(commit.message.original, "") + self.assertEqual(commit.author_name, None) + self.assertEqual(commit.author_email, None) + self.assertEqual(commit.date, None) + self.assertListEqual(commit.parents, []) + self.assertListEqual(commit.branches, []) + self.assertFalse(commit.is_merge_commit) + self.assertFalse(commit.is_fixup_commit) + self.assertFalse(commit.is_squash_commit) + self.assertFalse(commit.is_revert_commit) + self.assertEqual(len(gitcontext.commits), 1) + + @patch("gitlint.git.git_commentchar") + def test_from_commit_msg_comment(self, commentchar): + commentchar.return_value = u"#" + gitcontext = GitContext.from_commit_msg(u"Tïtle\n\nBödy 1\n#Cömment\nBody 2") + commit = gitcontext.commits[-1] + + self.assertIsInstance(commit, GitCommit) + self.assertFalse(isinstance(commit, LocalGitCommit)) + self.assertEqual(commit.message.title, u"Tïtle") + self.assertEqual(commit.message.body, ["", u"Bödy 1", "Body 2"]) + self.assertEqual(commit.message.full, u"Tïtle\n\nBödy 1\nBody 2") + self.assertEqual(commit.message.original, u"Tïtle\n\nBödy 1\n#Cömment\nBody 2") + self.assertEqual(commit.author_name, None) + self.assertEqual(commit.author_email, None) + self.assertEqual(commit.date, None) + self.assertListEqual(commit.parents, []) + self.assertListEqual(commit.branches, []) + self.assertFalse(commit.is_merge_commit) + self.assertFalse(commit.is_fixup_commit) + self.assertFalse(commit.is_squash_commit) + self.assertFalse(commit.is_revert_commit) + self.assertEqual(len(gitcontext.commits), 1) + + def test_from_commit_msg_merge_commit(self): + commit_msg = "Merge f919b8f34898d9b48048bcd703bc47139f4ff621 into 8b0409a26da6ba8a47c1fd2e746872a8dab15401" + gitcontext = GitContext.from_commit_msg(commit_msg) + commit = gitcontext.commits[-1] + + self.assertIsInstance(commit, GitCommit) + self.assertFalse(isinstance(commit, LocalGitCommit)) + self.assertEqual(commit.message.title, commit_msg) + self.assertEqual(commit.message.body, []) + self.assertEqual(commit.message.full, commit_msg) + self.assertEqual(commit.message.original, commit_msg) + self.assertEqual(commit.author_name, None) + self.assertEqual(commit.author_email, None) + self.assertEqual(commit.date, None) + self.assertListEqual(commit.parents, []) + self.assertListEqual(commit.branches, []) + self.assertTrue(commit.is_merge_commit) + self.assertFalse(commit.is_fixup_commit) + self.assertFalse(commit.is_squash_commit) + self.assertFalse(commit.is_revert_commit) + self.assertEqual(len(gitcontext.commits), 1) + + def test_from_commit_msg_revert_commit(self): + commit_msg = "Revert \"Prev commit message\"\n\nThis reverts commit a8ad67e04164a537198dea94a4fde81c5592ae9c." + gitcontext = GitContext.from_commit_msg(commit_msg) + commit = gitcontext.commits[-1] + + self.assertIsInstance(commit, GitCommit) + self.assertFalse(isinstance(commit, LocalGitCommit)) + self.assertEqual(commit.message.title, "Revert \"Prev commit message\"") + self.assertEqual(commit.message.body, ["", "This reverts commit a8ad67e04164a537198dea94a4fde81c5592ae9c."]) + self.assertEqual(commit.message.full, commit_msg) + self.assertEqual(commit.message.original, commit_msg) + self.assertEqual(commit.author_name, None) + self.assertEqual(commit.author_email, None) + self.assertEqual(commit.date, None) + self.assertListEqual(commit.parents, []) + self.assertListEqual(commit.branches, []) + self.assertFalse(commit.is_merge_commit) + self.assertFalse(commit.is_fixup_commit) + self.assertFalse(commit.is_squash_commit) + self.assertTrue(commit.is_revert_commit) + self.assertEqual(len(gitcontext.commits), 1) + + def test_from_commit_msg_fixup_squash_commit(self): + commit_types = ["fixup", "squash"] + for commit_type in commit_types: + commit_msg = "{0}! Test message".format(commit_type) + gitcontext = GitContext.from_commit_msg(commit_msg) + commit = gitcontext.commits[-1] + + self.assertIsInstance(commit, GitCommit) + self.assertFalse(isinstance(commit, LocalGitCommit)) + self.assertEqual(commit.message.title, commit_msg) + self.assertEqual(commit.message.body, []) + self.assertEqual(commit.message.full, commit_msg) + self.assertEqual(commit.message.original, commit_msg) + self.assertEqual(commit.author_name, None) + self.assertEqual(commit.author_email, None) + self.assertEqual(commit.date, None) + self.assertListEqual(commit.parents, []) + self.assertListEqual(commit.branches, []) + self.assertEqual(len(gitcontext.commits), 1) + self.assertFalse(commit.is_merge_commit) + self.assertFalse(commit.is_revert_commit) + # Asserting that squash and fixup are correct + for type in commit_types: + attr = "is_" + type + "_commit" + self.assertEqual(getattr(commit, attr), commit_type == type) + + @patch('gitlint.git.sh') + @patch('arrow.now') + def test_staged_commit(self, now, sh): + # StagedLocalGitCommit() + + sh.git.side_effect = [ + u"#", # git config --get core.commentchar + u"test åuthor\n", # git config --get user.name + u"test-emåil@foo.com\n", # git config --get user.email + u"my-brånch\n", # git rev-parse --abbrev-ref HEAD + u"file1.txt\npåth/to/file2.txt\n", + ] + now.side_effect = [arrow.get("2020-02-19T12:18:46.675182+01:00")] + + # We use a fixup commit, just to test a non-default path + context = GitContext.from_staged_commit(u"fixup! Foōbar 123\n\ncömmit-body\n", u"fåke/path") + + # git calls we're expexting + expected_calls = [ + call('config', '--get', 'core.commentchar', _ok_code=[0, 1], **self.expected_sh_special_args), + call('config', '--get', 'user.name', **self.expected_sh_special_args), + call('config', '--get', 'user.email', **self.expected_sh_special_args), + call("rev-parse", "--abbrev-ref", "HEAD", **self.expected_sh_special_args), + call("diff", "--staged", "--name-only", "-r", **self.expected_sh_special_args) + ] + + last_commit = context.commits[-1] + self.assertIsInstance(last_commit, StagedLocalGitCommit) + self.assertIsNone(last_commit.sha, None) + self.assertEqual(last_commit.message.title, u"fixup! Foōbar 123") + self.assertEqual(last_commit.message.body, ["", u"cömmit-body"]) + # Only `git config --get core.commentchar` should've happened up until this point + self.assertListEqual(sh.git.mock_calls, expected_calls[0:1]) + + self.assertEqual(last_commit.author_name, u"test åuthor") + self.assertListEqual(sh.git.mock_calls, expected_calls[0:2]) + + self.assertEqual(last_commit.author_email, u"test-emåil@foo.com") + self.assertListEqual(sh.git.mock_calls, expected_calls[0:3]) + + self.assertEqual(last_commit.date, datetime.datetime(2020, 2, 19, 12, 18, 46, + tzinfo=dateutil.tz.tzoffset("+0100", 3600))) + now.assert_called_once() + + self.assertListEqual(last_commit.parents, []) + self.assertFalse(last_commit.is_merge_commit) + self.assertTrue(last_commit.is_fixup_commit) + self.assertFalse(last_commit.is_squash_commit) + self.assertFalse(last_commit.is_revert_commit) + + self.assertListEqual(last_commit.branches, [u"my-brånch"]) + self.assertListEqual(sh.git.mock_calls, expected_calls[0:4]) + + self.assertListEqual(last_commit.changed_files, ["file1.txt", u"påth/to/file2.txt"]) + self.assertListEqual(sh.git.mock_calls, expected_calls[0:5]) + + def test_gitcommitmessage_equality(self): + commit_message1 = GitCommitMessage(GitContext(), u"tëst\n\nfoo", u"tëst\n\nfoo", u"tēst", ["", u"föo"]) + attrs = ['original', 'full', 'title', 'body'] + self.object_equality_test(commit_message1, attrs, {"context": commit_message1.context}) + + def test_gitcommit_equality(self): + # Test simple equality case + now = datetime.datetime.utcnow() + context1 = GitContext() + commit_message1 = GitCommitMessage(context1, u"tëst\n\nfoo", u"tëst\n\nfoo", u"tēst", ["", u"föo"]) + commit1 = GitCommit(context1, commit_message1, u"shä", now, u"Jöhn Smith", u"jöhn.smith@test.com", None, + [u"föo/bar"], [u"brånch1", u"brånch2"]) + context1.commits = [commit1] + + context2 = GitContext() + commit_message2 = GitCommitMessage(context2, u"tëst\n\nfoo", u"tëst\n\nfoo", u"tēst", ["", u"föo"]) + commit2 = GitCommit(context2, commit_message1, u"shä", now, u"Jöhn Smith", u"jöhn.smith@test.com", None, + [u"föo/bar"], [u"brånch1", u"brånch2"]) + context2.commits = [commit2] + + self.assertEqual(context1, context2) + self.assertEqual(commit_message1, commit_message2) + self.assertEqual(commit1, commit2) + + # Check that objects are unequal when changing a single attribute + kwargs = {'message': commit1.message, 'sha': commit1.sha, 'date': commit1.date, + 'author_name': commit1.author_name, 'author_email': commit1.author_email, 'parents': commit1.parents, + 'changed_files': commit1.changed_files, 'branches': commit1.branches} + + self.object_equality_test(commit1, kwargs.keys(), {"context": commit1.context}) + + # Check that the is_* attributes that are affected by the commit message affect equality + special_messages = {'is_merge_commit': u"Merge: foöbar", 'is_fixup_commit': u"fixup! foöbar", + 'is_squash_commit': u"squash! foöbar", 'is_revert_commit': u"Revert: foöbar"} + for key in special_messages: + kwargs_copy = copy.deepcopy(kwargs) + clone1 = GitCommit(context=commit1.context, **kwargs_copy) + clone1.message = GitCommitMessage.from_full_message(context1, special_messages[key]) + self.assertTrue(getattr(clone1, key)) + + clone2 = GitCommit(context=commit1.context, **kwargs_copy) + clone2.message = GitCommitMessage.from_full_message(context1, u"foöbar") + self.assertNotEqual(clone1, clone2) + + @patch("gitlint.git.git_commentchar") + def test_commit_msg_custom_commentchar(self, patched): + patched.return_value = u"ä" + context = GitContext() + message = GitCommitMessage.from_full_message(context, u"Tïtle\n\nBödy 1\näCömment\nBody 2") + + self.assertEqual(message.title, u"Tïtle") + self.assertEqual(message.body, ["", u"Bödy 1", "Body 2"]) + self.assertEqual(message.full, u"Tïtle\n\nBödy 1\nBody 2") + self.assertEqual(message.original, u"Tïtle\n\nBödy 1\näCömment\nBody 2") diff --git a/gitlint/tests/git/test_git_context.py b/gitlint/tests/git/test_git_context.py new file mode 100644 index 0000000..b243d5e --- /dev/null +++ b/gitlint/tests/git/test_git_context.py @@ -0,0 +1,89 @@ +# -*- coding: utf-8 -*- + +try: + # python 2.x + from mock import patch, call +except ImportError: + # python 3.x + from unittest.mock import patch, call # pylint: disable=no-name-in-module, import-error + +from gitlint.tests.base import BaseTestCase +from gitlint.git import GitContext + + +class GitContextTests(BaseTestCase): + + # Expected special_args passed to 'sh' + expected_sh_special_args = { + '_tty_out': False, + '_cwd': u"fåke/path" + } + + @patch('gitlint.git.sh') + def test_gitcontext(self, sh): + + sh.git.side_effect = [ + u"#", # git config --get core.commentchar + u"\nfoöbar\n" + ] + + expected_calls = [ + call("config", "--get", "core.commentchar", _ok_code=[0, 1], **self.expected_sh_special_args), + call("rev-parse", "--abbrev-ref", "HEAD", **self.expected_sh_special_args) + ] + + context = GitContext(u"fåke/path") + self.assertEqual(sh.git.mock_calls, []) + + # gitcontext.comment_branch + self.assertEqual(context.commentchar, u"#") + self.assertEqual(sh.git.mock_calls, expected_calls[0:1]) + + # gitcontext.current_branch + self.assertEqual(context.current_branch, u"foöbar") + self.assertEqual(sh.git.mock_calls, expected_calls) + + @patch('gitlint.git.sh') + def test_gitcontext_equality(self, sh): + + sh.git.side_effect = [ + u"û\n", # context1: git config --get core.commentchar + u"û\n", # context2: git config --get core.commentchar + u"my-brånch\n", # context1: git rev-parse --abbrev-ref HEAD + u"my-brånch\n", # context2: git rev-parse --abbrev-ref HEAD + ] + + context1 = GitContext(u"fåke/path") + context1.commits = [u"fōo", u"bår"] # we don't need real commits to check for equality + + context2 = GitContext(u"fåke/path") + context2.commits = [u"fōo", u"bår"] + self.assertEqual(context1, context2) + + # INEQUALITY + # Different commits + context2.commits = [u"hür", u"dür"] + self.assertNotEqual(context1, context2) + + # Different repository_path + context2.commits = context1.commits + context2.repository_path = u"ōther/path" + self.assertNotEqual(context1, context2) + + # Different comment_char + context3 = GitContext(u"fåke/path") + context3.commits = [u"fōo", u"bår"] + sh.git.side_effect = ([ + u"ç\n", # context3: git config --get core.commentchar + u"my-brånch\n" # context3: git rev-parse --abbrev-ref HEAD + ]) + self.assertNotEqual(context1, context3) + + # Different current_branch + context4 = GitContext(u"fåke/path") + context4.commits = [u"fōo", u"bår"] + sh.git.side_effect = ([ + u"û\n", # context4: git config --get core.commentchar + u"different-brånch\n" # context4: git rev-parse --abbrev-ref HEAD + ]) + self.assertNotEqual(context1, context4) diff --git a/gitlint/tests/rules/__init__.py b/gitlint/tests/rules/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint/tests/rules/__init__.py diff --git a/gitlint/tests/rules/test_body_rules.py b/gitlint/tests/rules/test_body_rules.py new file mode 100644 index 0000000..fcb1b30 --- /dev/null +++ b/gitlint/tests/rules/test_body_rules.py @@ -0,0 +1,180 @@ +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint import rules + + +class BodyRuleTests(BaseTestCase): + def test_max_line_length(self): + rule = rules.BodyMaxLineLength() + + # assert no error + violation = rule.validate(u"å" * 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) + 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) + 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) + self.assertListEqual(violations, [expected_violation]) + + def test_trailing_whitespace(self): + rule = rules.BodyTrailingWhitespace() + + # assert no error + violations = rule.validate(u"å", None) + self.assertIsNone(violations) + + # trailing space + expected_violation = rules.RuleViolation("B2", "Line has trailing whitespace", u"å ") + violations = rule.validate(u"å ", 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) + self.assertListEqual(violations, [expected_violation]) + + def test_hard_tabs(self): + rule = rules.BodyHardTab() + + # assert no error + violations = rule.validate(u"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) + 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") + 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) + + commit = self.gitcommit(u"Tïtle\nnöt empty\nThis is the secönd body line") + violations = rule.validate(commit) + self.assertListEqual(violations, [expected_violation]) + + def test_body_min_length(self): + rule = rules.BodyMinLength() + + # assert no error - body is long enough + commit = self.gitcommit("Title\n\nThis is the second body line\n") + + violations = rule.validate(commit) + self.assertIsNone(violations) + + # assert no error - no body + commit = self.gitcommit(u"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) + + commit = self.gitcommit(u"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") + 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) + + rule = rules.BodyMinLength({'min-length': 120}) + commit = self.gitcommit(u"Title\n\n%s\n" % (u"å" * 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)) + violations = rule.validate(commit) + self.assertIsNone(violations) + + def test_body_missing(self): + rule = rules.BodyMissing() + + # assert no error - body is present + commit = self.gitcommit(u"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") + violations = rule.validate(commit) + self.assertListEqual(violations, [expected_violation]) + + def test_body_missing_merge_commit(self): + rule = rules.BodyMissing() + + # assert no error - merge commit + commit = self.gitcommit(u"Merge: Tïtle\n") + violations = rule.validate(commit) + self.assertIsNone(violations) + + # assert error for merge commits if ignore-merge-commits is disabled + rule = rules.BodyMissing({'ignore-merge-commits': False}) + violations = rule.validate(commit) + expected_violation = rules.RuleViolation("B6", "Body message is missing", None, 3) + self.assertListEqual(violations, [expected_violation]) + + def test_body_changed_file_mention(self): + 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") + 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") + 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"]) + 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"]) + 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"]) + violations = rule.validate(commit) + expected_violation = rules.RuleViolation("B7", u"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"]) + 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) diff --git a/gitlint/tests/rules/test_configuration_rules.py b/gitlint/tests/rules/test_configuration_rules.py new file mode 100644 index 0000000..73d42f3 --- /dev/null +++ b/gitlint/tests/rules/test_configuration_rules.py @@ -0,0 +1,71 @@ +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint import rules +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") + + # No regex specified -> Config shouldn't be changed + rule = rules.IgnoreByTitle() + config = LintConfig() + rule.apply(config, commit) + self.assertEqual(config, LintConfig()) + self.assert_logged([]) # nothing logged -> nothing ignored + + # Matching regex -> expect config to ignore all rules + rule = rules.IgnoreByTitle({"regex": u"^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" + self.assert_log_contains(expected_log_message) + + # Matching regex with specific ignore + rule = rules.IgnoreByTitle({"regex": u"^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" + + def test_ignore_by_body(self): + commit = self.gitcommit(u"Tïtle\n\nThis is\n a relëase body\n line") + + # No regex specified -> Config shouldn't be changed + rule = rules.IgnoreByBody() + config = LintConfig() + rule.apply(config, commit) + self.assertEqual(config, LintConfig()) + self.assert_logged([]) # nothing logged -> nothing ignored + + # Matching regex -> expect config to ignore all rules + rule = rules.IgnoreByBody({"regex": u"(.*)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" + self.assert_log_contains(expected_log_message) + + # Matching regex with specific ignore + rule = rules.IgnoreByBody({"regex": u"(.*)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 'I1': " + \ + u"Commit message line ' a relëase body' matches the regex '(.*)relëase(.*)', ignoring rules: T1,B2" diff --git a/gitlint/tests/rules/test_meta_rules.py b/gitlint/tests/rules/test_meta_rules.py new file mode 100644 index 0000000..c94b8b3 --- /dev/null +++ b/gitlint/tests/rules/test_meta_rules.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint.rules import AuthorValidEmail, RuleViolation + + +class MetaRuleTests(BaseTestCase): + def test_author_valid_email_rule(self): + 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"] + for email in valid_email_addresses: + commit = self.gitcommit(u"", 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"") + 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"] + for email in invalid_email_addresses: + commit = self.gitcommit(u"", author_email=email) + violations = rule.validate(commit) + self.assertListEqual(violations, + [RuleViolation("M1", "Author email for commit is invalid", email)]) + + def test_author_valid_email_rule_custom_regex(self): + # Custom domain + rule = AuthorValidEmail({'regex': u"[^@]+@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"] + for email in valid_email_addresses: + commit = self.gitcommit(u"", author_email=email) + violations = rule.validate(commit) + self.assertIsNone(violations) + + # Invalid email addresses + invalid_email_addresses = [u"föo@hur.com"] + for email in invalid_email_addresses: + commit = self.gitcommit(u"", 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 new file mode 100644 index 0000000..89caa27 --- /dev/null +++ b/gitlint/tests/rules/test_rules.py @@ -0,0 +1,18 @@ +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint.rules import Rule, RuleViolation + + +class RuleTests(BaseTestCase): + + def test_rule_equality(self): + self.assertEqual(Rule(), Rule()) + # 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") + self.assertNotEqual(Rule(), rule) + + def test_rule_violation_equality(self): + violation1 = RuleViolation(u"ïd1", u"My messåge", u"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 new file mode 100644 index 0000000..07d2323 --- /dev/null +++ b/gitlint/tests/rules/test_title_rules.py @@ -0,0 +1,154 @@ +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint.rules import TitleMaxLength, TitleTrailingWhitespace, TitleHardTab, TitleMustNotContainWord, \ + TitleTrailingPunctuation, TitleLeadingWhitespace, TitleRegexMatches, RuleViolation + + +class TitleRuleTests(BaseTestCase): + def test_max_line_length(self): + rule = TitleMaxLength() + + # assert no error + violation = rule.validate(u"å" * 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) + 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) + 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) + self.assertListEqual(violations, [expected_violation]) + + def test_trailing_whitespace(self): + rule = TitleTrailingWhitespace() + + # assert no error + violations = rule.validate(u"å", None) + self.assertIsNone(violations) + + # trailing space + expected_violation = RuleViolation("T2", "Title has trailing whitespace", u"å ") + violations = rule.validate(u"å ", None) + self.assertListEqual(violations, [expected_violation]) + + # trailing tab + expected_violation = RuleViolation("T2", "Title has trailing whitespace", u"å\t") + violations = rule.validate(u"å\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) + 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) + self.assertListEqual(violations, [expected_violation]) + + def test_trailing_punctuation(self): + rule = TitleTrailingPunctuation() + + # assert no error + violations = rule.validate(u"This is å test", None) + self.assertIsNone(violations) + + # assert errors for different punctuations + punctuation = u"?:!.,;" + for char in punctuation: + line = u"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) + violations = rule.validate(line, gitcontext) + self.assertListEqual(violations, [expected_violation]) + + def test_title_must_not_contain_word(self): + rule = TitleMustNotContainWord() + + # no violations + violations = rule.validate(u"This is å test", None) + self.assertIsNone(violations) + + # no violation if WIP occurs inside a wor + violations = rule.validate(u"This is å wiping test", None) + self.assertIsNone(violations) + + # match literally + violations = rule.validate(u"WIP This is å test", None) + expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", + u"WIP This is å test") + self.assertListEqual(violations, [expected_violation]) + + # match case insensitive + violations = rule.validate(u"wip This is å test", None) + expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", + u"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) + expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", + u"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) + expected_violation = RuleViolation("T5", "Title contains the word 'wip' (case-insensitive)", + u"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") + self.assertListEqual(violations, [expected_violation, expected_violation2, expected_violation3]) + + def test_leading_whitespace(self): + rule = TitleLeadingWhitespace() + + # assert no error + violations = rule.validate("a", None) + self.assertIsNone(violations) + + # leading space + expected_violation = RuleViolation("T6", "Title has leading whitespace", " a") + violations = rule.validate(" a", None) + self.assertListEqual(violations, [expected_violation]) + + # leading tab + expected_violation = RuleViolation("T6", "Title has leading whitespace", "\ta") + violations = rule.validate("\ta", None) + self.assertListEqual(violations, [expected_violation]) + + # unicode test + expected_violation = RuleViolation("T6", "Title has leading whitespace", u" ☺") + violations = rule.validate(u" ☺", None) + self.assertListEqual(violations, [expected_violation]) + + def test_regex_matches(self): + commit = self.gitcommit(u"US1234: åbc\n") + + # assert no violation on default regex (=everything allowed) + rule = TitleRegexMatches() + violations = rule.validate(commit.message.title, commit) + self.assertIsNone(violations) + + # assert no violation on matching regex + rule = TitleRegexMatches({'regex': u"^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]*"}) + violations = rule.validate(commit.message.title, commit) + expected_violation = RuleViolation("T7", u"Title does not match regex (^UÅ[0-9]*)", u"US1234: åbc") + self.assertListEqual(violations, [expected_violation]) diff --git a/gitlint/tests/rules/test_user_rules.py b/gitlint/tests/rules/test_user_rules.py new file mode 100644 index 0000000..57c03a0 --- /dev/null +++ b/gitlint/tests/rules/test_user_rules.py @@ -0,0 +1,223 @@ +# -*- coding: utf-8 -*- + +import os +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 + + +class UserRuleTests(BaseTestCase): + def test_find_rule_classes(self): + # Let's find some user classes! + user_rule_path = self.get_sample_path("user_rules") + classes = find_rule_classes(user_rule_path) + + # Compare string representations because we can't import MyUserCommitRule here since samples/user_rules is not + # a proper python package + # Note that the following check effectively asserts that: + # - There is only 1 rule recognized and it is MyUserCommitRule + # - Other non-python files in the directory are ignored + # - 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)) + + # Assert that we added the new user_rules directory to the system path and modules + self.assertIn(user_rule_path, sys.path) + self.assertIn("my_commit_rules", sys.modules) + + # 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.assertListEqual(classes[0].options_spec, [expected_option]) + self.assertTrue(hasattr(classes[0], "validate")) + + # Test that we can instantiate the class and can execute run the validate method and that it returns the + # 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)]) + + # 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)]) + + 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 + user_rule_path = self.get_sample_path("user_rules") + user_rule_module = os.path.join(user_rule_path, "my_commit_rules.py") + classes = find_rule_classes(user_rule_module) + + 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)]) + + def test_rules_from_init_file(self): + # Test that we can import rules that are defined in __init__.py files + # This also tests that we can import rules from python packages. This use to cause issues with pypy + # So this is also a regression test for that. + user_rule_path = self.get_sample_path(os.path.join("user_rules", "parent_package")) + 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'>"] + self.assertListEqual(class_strings, expected) + + def test_empty_user_classes(self): + # Test that we don't find rules if we scan a different directory + user_rule_path = self.get_sample_path("config") + classes = find_rule_classes(user_rule_path) + self.assertListEqual(classes, []) + + # Importantly, ensure that the directory is not added to the syspath as this happens only when we actually + # find modules + self.assertNotIn(user_rule_path, sys.path) + + def test_failed_module_import(self): + # test importing a bogus module + user_rule_path = self.get_sample_path("user_rules/import_exception") + # We don't check the entire error message because that is different based on the python version and underlying + # operating system + expected_msg = "Error while importing extra-path module 'invalid_python'" + with self.assertRaisesRegex(UserRuleError, expected_msg): + find_rule_classes(user_rule_path) + + def test_find_rule_classes_nonexisting_path(self): + with self.assertRaisesRegex(UserRuleError, u"Invalid extra-path: föo/bar"): + find_rule_classes(u"föo/bar") + + def test_assert_valid_rule_class(self): + class MyLineRuleClass(rules.LineRule): + id = 'UC1' + name = u'my-lïne-rule' + target = rules.CommitMessageTitle + + def validate(self): + pass + + class MyCommitRuleClass(rules.CommitRule): + id = 'UC2' + name = u'my-cömmit-rule' + + def validate(self): + pass + + # Just assert that no error is raised + self.assertIsNone(assert_valid_rule_class(MyLineRuleClass)) + self.assertIsNone(assert_valid_rule_class(MyCommitRuleClass)) + + def test_assert_valid_rule_class_negative(self): + # general test to make sure that incorrect rules will raise an exception + user_rule_path = self.get_sample_path("user_rules/incorrect_linerule") + with self.assertRaisesRegex(UserRuleError, + "User-defined rule class 'MyUserLineRule' must have a 'validate' method"): + find_rule_classes(user_rule_path) + + def test_assert_valid_rule_class_negative_parent(self): + # rule class must extend from LineRule or CommitRule + class MyRuleClass(object): + pass + + expected_msg = "User-defined rule class 'MyRuleClass' must extend from gitlint.rules.LineRule " + \ + "or gitlint.rules.CommitRule" + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + def test_assert_valid_rule_class_negative_id(self): + class MyRuleClass(rules.LineRule): + pass + + # Rule class must have an id + expected_msg = "User-defined rule class 'MyRuleClass' must have an 'id' attribute" + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + # Rule ids must be non-empty + MyRuleClass.id = "" + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + # Rule ids must not start with one of the reserved id letters + for letter in ["T", "R", "B", "M"]: + MyRuleClass.id = letter + "1" + expected_msg = "The id '{0}' of 'MyRuleClass' is invalid. Gitlint reserves ids starting with R,T,B,M" + with self.assertRaisesRegex(UserRuleError, expected_msg.format(letter)): + assert_valid_rule_class(MyRuleClass) + + def test_assert_valid_rule_class_negative_name(self): + class MyRuleClass(rules.LineRule): + id = "UC1" + + # Rule class must have an name + expected_msg = "User-defined rule class 'MyRuleClass' must have a 'name' attribute" + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + # Rule names must be non-empty + MyRuleClass.name = "" + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + def test_assert_valid_rule_class_negative_option_spec(self): + class MyRuleClass(rules.LineRule): + id = "UC1" + name = u"my-rüle-class" + + # if set, option_spec must be a list of gitlint options + MyRuleClass.options_spec = u"föo" + expected_msg = "The options_spec attribute of user-defined rule class 'MyRuleClass' must be a list " + \ + "of gitlint.options.RuleOption" + with self.assertRaisesRegex(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 + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + def test_assert_valid_rule_class_negative_validate(self): + class MyRuleClass(rules.LineRule): + id = "UC1" + name = u"my-rüle-class" + + with self.assertRaisesRegex(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" + with self.assertRaisesRegex(UserRuleError, + "User-defined rule class 'MyRuleClass' must have a 'validate' method"): + 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" + + def validate(self): + pass + + # no target + expected_msg = "The target attribute of the user-defined LineRule class 'MyRuleClass' must be either " + \ + "gitlint.rules.CommitMessageTitle or gitlint.rules.CommitMessageBody" + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + # invalid target + MyRuleClass.target = u"föo" + with self.assertRaisesRegex(UserRuleError, expected_msg): + assert_valid_rule_class(MyRuleClass) + + # valid target, no exception should be raised + MyRuleClass.target = rules.CommitMessageTitle # pylint: disable=bad-option-value,redefined-variable-type + self.assertIsNone(assert_valid_rule_class(MyRuleClass)) diff --git a/gitlint/tests/samples/commit_message/fixup b/gitlint/tests/samples/commit_message/fixup new file mode 100644 index 0000000..2539dd1 --- /dev/null +++ b/gitlint/tests/samples/commit_message/fixup @@ -0,0 +1 @@ +fixup! WIP: This is a fixup cömmit with violations. diff --git a/gitlint/tests/samples/commit_message/merge b/gitlint/tests/samples/commit_message/merge new file mode 100644 index 0000000..764e131 --- /dev/null +++ b/gitlint/tests/samples/commit_message/merge @@ -0,0 +1,3 @@ +Merge: "This is a merge commit with a long title that most definitely exceeds the normål limit of 72 chars" +This line should be ëmpty +This is the first line is meant to test å line that exceeds the maximum line length of 80 characters. diff --git a/gitlint/tests/samples/commit_message/revert b/gitlint/tests/samples/commit_message/revert new file mode 100644 index 0000000..6dc8368 --- /dev/null +++ b/gitlint/tests/samples/commit_message/revert @@ -0,0 +1,3 @@ +Revert "WIP: this is a tïtle" + +This reverts commit a8ad67e04164a537198dea94a4fde81c5592ae9c.
\ No newline at end of file diff --git a/gitlint/tests/samples/commit_message/sample1 b/gitlint/tests/samples/commit_message/sample1 new file mode 100644 index 0000000..646c0cb --- /dev/null +++ b/gitlint/tests/samples/commit_message/sample1 @@ -0,0 +1,14 @@ +Commit title contåining 'WIP', as well as trailing punctuation. +This line should be empty +This is the first line of the commit message body and it is meant to test a line that exceeds the maximum line length of 80 characters. +This line has a tråiling space. +This line has a trailing tab. +# This is a cömmented line +# ------------------------ >8 ------------------------ +# Anything after this line should be cleaned up +# this line appears on `git commit -v` command +diff --git a/gitlint/tests/samples/commit_message/sample1 b/gitlint/tests/samples/commit_message/sample1 +index 82dbe7f..ae71a14 100644 +--- a/gitlint/tests/samples/commit_message/sample1 ++++ b/gitlint/tests/samples/commit_message/sample1 +@@ -1 +1 @@ diff --git a/gitlint/tests/samples/commit_message/sample2 b/gitlint/tests/samples/commit_message/sample2 new file mode 100644 index 0000000..356540c --- /dev/null +++ b/gitlint/tests/samples/commit_message/sample2 @@ -0,0 +1 @@ +Just a title contåining WIP
\ No newline at end of file diff --git a/gitlint/tests/samples/commit_message/sample3 b/gitlint/tests/samples/commit_message/sample3 new file mode 100644 index 0000000..d67d70b --- /dev/null +++ b/gitlint/tests/samples/commit_message/sample3 @@ -0,0 +1,6 @@ + Commit title containing 'WIP', leading and tråiling whitespace and longer than 72 characters. +This line should be empty +This is the first line is meånt to test a line that exceeds the maximum line length of 80 characters. +This line has a trailing space. +This line has a tråiling tab. +# This is a commented line diff --git a/gitlint/tests/samples/commit_message/sample4 b/gitlint/tests/samples/commit_message/sample4 new file mode 100644 index 0000000..c858d89 --- /dev/null +++ b/gitlint/tests/samples/commit_message/sample4 @@ -0,0 +1,7 @@ + Commit title containing 'WIP', leading and tråiling whitespace and longer than 72 characters. +This line should be empty +This is the first line is meånt to test a line that exceeds the maximum line length of 80 characters. +This line has a tråiling space. +This line has a trailing tab. +# This is a commented line +gitlint-ignore: all diff --git a/gitlint/tests/samples/commit_message/sample5 b/gitlint/tests/samples/commit_message/sample5 new file mode 100644 index 0000000..77ccbe8 --- /dev/null +++ b/gitlint/tests/samples/commit_message/sample5 @@ -0,0 +1,7 @@ + Commit title containing 'WIP', leading and tråiling whitespace and longer than 72 characters. +This line should be ëmpty +This is the first line is meånt to test a line that exceeds the maximum line length of 80 characters. +This line has a tråiling space. +This line has a trailing tab. +# This is a commented line +gitlint-ignore: T3, T6, body-max-line-length diff --git a/gitlint/tests/samples/commit_message/squash b/gitlint/tests/samples/commit_message/squash new file mode 100644 index 0000000..538a93a --- /dev/null +++ b/gitlint/tests/samples/commit_message/squash @@ -0,0 +1,3 @@ +squash! WIP: This is a squash cömmit with violations. + +Body töo short diff --git a/gitlint/tests/samples/config/gitlintconfig b/gitlint/tests/samples/config/gitlintconfig new file mode 100644 index 0000000..8c93f71 --- /dev/null +++ b/gitlint/tests/samples/config/gitlintconfig @@ -0,0 +1,15 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 +ignore-merge-commits = false +debug = false + +[title-max-length] +line-length=20 + +[B1] +# B1 = body-max-line-length +line-length=30 + +[title-must-not-contain-word] +words=WIP,bögus
\ No newline at end of file diff --git a/gitlint/tests/samples/config/invalid-option-value b/gitlint/tests/samples/config/invalid-option-value new file mode 100644 index 0000000..92015aa --- /dev/null +++ b/gitlint/tests/samples/config/invalid-option-value @@ -0,0 +1,11 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 + +[title-max-length] +line-length=föo + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint/tests/samples/config/no-sections b/gitlint/tests/samples/config/no-sections new file mode 100644 index 0000000..ec82b25 --- /dev/null +++ b/gitlint/tests/samples/config/no-sections @@ -0,0 +1 @@ +ignore=title-max-length, T3 diff --git a/gitlint/tests/samples/config/nonexisting-general-option b/gitlint/tests/samples/config/nonexisting-general-option new file mode 100644 index 0000000..d5cfef2 --- /dev/null +++ b/gitlint/tests/samples/config/nonexisting-general-option @@ -0,0 +1,13 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 +ignore-merge-commits = false +foo = bar + +[title-max-length] +line-length=20 + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint/tests/samples/config/nonexisting-option b/gitlint/tests/samples/config/nonexisting-option new file mode 100644 index 0000000..6964c77 --- /dev/null +++ b/gitlint/tests/samples/config/nonexisting-option @@ -0,0 +1,11 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 + +[title-max-length] +föobar=foo + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint/tests/samples/config/nonexisting-rule b/gitlint/tests/samples/config/nonexisting-rule new file mode 100644 index 0000000..c0f0d2b --- /dev/null +++ b/gitlint/tests/samples/config/nonexisting-rule @@ -0,0 +1,11 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 + +[föobar] +line-length=20 + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint/tests/samples/user_rules/bogus-file.txt b/gitlint/tests/samples/user_rules/bogus-file.txt new file mode 100644 index 0000000..2a56650 --- /dev/null +++ b/gitlint/tests/samples/user_rules/bogus-file.txt @@ -0,0 +1,2 @@ +This is just a bogus file. +This file being here is part of the test: gitlint should ignore it.
\ No newline at end of file diff --git a/gitlint/tests/samples/user_rules/import_exception/invalid_python.py b/gitlint/tests/samples/user_rules/import_exception/invalid_python.py new file mode 100644 index 0000000..e75fed3 --- /dev/null +++ b/gitlint/tests/samples/user_rules/import_exception/invalid_python.py @@ -0,0 +1,3 @@ +# flake8: noqa +# This is invalid python code which will cause an import exception +class MyObject: diff --git a/gitlint/tests/samples/user_rules/incorrect_linerule/my_line_rule.py b/gitlint/tests/samples/user_rules/incorrect_linerule/my_line_rule.py new file mode 100644 index 0000000..004ef9d --- /dev/null +++ b/gitlint/tests/samples/user_rules/incorrect_linerule/my_line_rule.py @@ -0,0 +1,10 @@ +# -*- coding: utf-8 -*- + +from gitlint.rules import LineRule + + +class MyUserLineRule(LineRule): + id = "UC2" + name = "my-lïne-rule" + + # missing validate method, missing target attribute diff --git a/gitlint/tests/samples/user_rules/my_commit_rules.foo b/gitlint/tests/samples/user_rules/my_commit_rules.foo new file mode 100644 index 0000000..605d704 --- /dev/null +++ b/gitlint/tests/samples/user_rules/my_commit_rules.foo @@ -0,0 +1,16 @@ +# This rule is ignored because it doesn't have a .py extension +from gitlint.rules import CommitRule, RuleViolation +from gitlint.options import IntOption + + +class MyUserCommitRule2(CommitRule): + name = "my-user-commit-rule2" + id = "TUC2" + options_spec = [IntOption('violation-count', 0, "Number of violations to return")] + + def validate(self, _commit): + violations = [] + for i in range(1, self.options['violation-count'].value + 1): + violations.append(RuleViolation(self.id, "Commit violation %d" % i, "Content %d" % i, i)) + + return violations diff --git a/gitlint/tests/samples/user_rules/my_commit_rules.py b/gitlint/tests/samples/user_rules/my_commit_rules.py new file mode 100644 index 0000000..5456487 --- /dev/null +++ b/gitlint/tests/samples/user_rules/my_commit_rules.py @@ -0,0 +1,26 @@ +# -*- coding: utf-8 -*- + +from gitlint.rules import CommitRule, RuleViolation +from gitlint.options import IntOption + + +class MyUserCommitRule(CommitRule): + name = u"my-üser-commit-rule" + id = "UC1" + options_spec = [IntOption('violation-count', 1, u"Number of violåtions to return")] + + def validate(self, _commit): + violations = [] + for i in range(1, self.options['violation-count'].value + 1): + violations.append(RuleViolation(self.id, u"Commit violåtion %d" % i, u"Contënt %d" % i, i)) + + return violations + + +# The below code is present so that we can test that we actually ignore it + +def func_should_be_ignored(): + pass + + +global_variable_should_be_ignored = True diff --git a/gitlint/tests/samples/user_rules/parent_package/__init__.py b/gitlint/tests/samples/user_rules/parent_package/__init__.py new file mode 100644 index 0000000..32c05fc --- /dev/null +++ b/gitlint/tests/samples/user_rules/parent_package/__init__.py @@ -0,0 +1,13 @@ +# -*- coding: utf-8 -*- +# This file is meant to test that we can also load rules from __init__.py files, this was an issue with pypy before. + +from gitlint.rules import CommitRule + + +class InitFileRule(CommitRule): + name = u"my-init-cömmit-rule" + id = "UC1" + options_spec = [] + + def validate(self, _commit): + return [] diff --git a/gitlint/tests/samples/user_rules/parent_package/my_commit_rules.py b/gitlint/tests/samples/user_rules/parent_package/my_commit_rules.py new file mode 100644 index 0000000..b73a305 --- /dev/null +++ b/gitlint/tests/samples/user_rules/parent_package/my_commit_rules.py @@ -0,0 +1,12 @@ +# -*- coding: utf-8 -*- + +from gitlint.rules import CommitRule + + +class MyUserCommitRule(CommitRule): + name = u"my-user-cömmit-rule" + id = "UC2" + options_spec = [] + + def validate(self, _commit): + return [] diff --git a/gitlint/tests/test_cache.py b/gitlint/tests/test_cache.py new file mode 100644 index 0000000..5d78953 --- /dev/null +++ b/gitlint/tests/test_cache.py @@ -0,0 +1,57 @@ +# -*- coding: utf-8 -*- +from gitlint.tests.base import BaseTestCase +from gitlint.cache import PropertyCache, cache + + +class CacheTests(BaseTestCase): + + class MyClass(PropertyCache): + """ Simple class that has cached properties, used for testing. """ + + def __init__(self): + PropertyCache.__init__(self) + self.counter = 0 + + @property + @cache + def foo(self): + self.counter += 1 + return u"bår" + + @property + @cache(cachekey=u"hür") + def bar(self): + self.counter += 1 + return u"fōo" + + def test_cache(self): + # Init new class with cached properties + myclass = self.MyClass() + self.assertEqual(myclass.counter, 0) + self.assertDictEqual(myclass._cache, {}) + + # Assert that function is called on first access, cache is set + self.assertEqual(myclass.foo, u"bår") + self.assertEqual(myclass.counter, 1) + self.assertDictEqual(myclass._cache, {"foo": u"bår"}) + + # After function is not called on subsequent access, cache is still set + self.assertEqual(myclass.foo, u"bår") + self.assertEqual(myclass.counter, 1) + self.assertDictEqual(myclass._cache, {"foo": u"bår"}) + + def test_cache_custom_key(self): + # Init new class with cached properties + myclass = self.MyClass() + self.assertEqual(myclass.counter, 0) + self.assertDictEqual(myclass._cache, {}) + + # Assert that function is called on first access, cache is set with custom key + self.assertEqual(myclass.bar, u"fōo") + self.assertEqual(myclass.counter, 1) + self.assertDictEqual(myclass._cache, {u"hür": u"fōo"}) + + # After function is not called on subsequent access, cache is still set + self.assertEqual(myclass.bar, u"fōo") + self.assertEqual(myclass.counter, 1) + self.assertDictEqual(myclass._cache, {u"hür": u"fōo"}) diff --git a/gitlint/tests/test_display.py b/gitlint/tests/test_display.py new file mode 100644 index 0000000..1c64b34 --- /dev/null +++ b/gitlint/tests/test_display.py @@ -0,0 +1,74 @@ +# -*- coding: utf-8 -*- + +try: + # python 2.x + from StringIO import StringIO +except ImportError: + # python 3.x + from io import StringIO + + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +from gitlint.display import Display +from gitlint.config import LintConfig +from gitlint.tests.base import BaseTestCase + + +class DisplayTests(BaseTestCase): + def test_v(self): + display = Display(LintConfig()) + display.config.verbosity = 2 + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + # Non exact outputting, should output both v and vv output + with patch('gitlint.display.stdout', new=StringIO()) as stdout: + display.v(u"tëst") + display.vv(u"tëst2") + # vvvv should be ignored regardless + display.vvv(u"tëst3.1") + display.vvv(u"tëst3.2", exact=True) + self.assertEqual(u"tëst\ntëst2\n", stdout.getvalue()) + + # exact outputting, should only output v + with patch('gitlint.display.stdout', new=StringIO()) as stdout: + display.v(u"tëst", exact=True) + display.vv(u"tëst2", exact=True) + # vvvv should be ignored regardless + display.vvv(u"tëst3.1") + display.vvv(u"tëst3.2", exact=True) + self.assertEqual(u"tëst2\n", stdout.getvalue()) + + # standard error should be empty throughtout all of this + self.assertEqual('', stderr.getvalue()) + + def test_e(self): + display = Display(LintConfig()) + display.config.verbosity = 2 + + with patch('gitlint.display.stdout', new=StringIO()) as stdout: + # Non exact outputting, should output both v and vv output + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + display.e(u"tëst") + display.ee(u"tëst2") + # vvvv should be ignored regardless + display.eee(u"tëst3.1") + display.eee(u"tëst3.2", exact=True) + self.assertEqual(u"tëst\ntëst2\n", stderr.getvalue()) + + # exact outputting, should only output v + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + display.e(u"tëst", exact=True) + display.ee(u"tëst2", exact=True) + # vvvv should be ignored regardless + display.eee(u"tëst3.1") + display.eee(u"tëst3.2", exact=True) + self.assertEqual(u"tëst2\n", stderr.getvalue()) + + # standard output should be empty throughtout all of this + self.assertEqual('', stdout.getvalue()) diff --git a/gitlint/tests/test_hooks.py b/gitlint/tests/test_hooks.py new file mode 100644 index 0000000..08bd730 --- /dev/null +++ b/gitlint/tests/test_hooks.py @@ -0,0 +1,136 @@ +# -*- coding: utf-8 -*- + +import os + +try: + # python 2.x + from mock import patch, ANY, mock_open +except ImportError: + # python 3.x + from unittest.mock import patch, ANY, mock_open # pylint: disable=no-name-in-module, import-error + +from gitlint.tests.base import BaseTestCase +from gitlint.config import LintConfig +from gitlint.hooks import GitHookInstaller, GitHookInstallerError, COMMIT_MSG_HOOK_SRC_PATH, COMMIT_MSG_HOOK_DST_PATH, \ + GITLINT_HOOK_IDENTIFIER + + +class HookTests(BaseTestCase): + + @patch('gitlint.hooks.git_hooks_dir') + def test_commit_msg_hook_path(self, git_hooks_dir): + git_hooks_dir.return_value = os.path.join(u"/föo", u"bar") + lint_config = LintConfig() + lint_config.target = self.SAMPLES_DIR + expected_path = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH) + path = GitHookInstaller.commit_msg_hook_path(lint_config) + + git_hooks_dir.assert_called_once_with(self.SAMPLES_DIR) + self.assertEqual(path, expected_path) + + @staticmethod + @patch('os.chmod') + @patch('os.stat') + @patch('gitlint.hooks.shutil.copy') + @patch('os.path.exists', return_value=False) + @patch('os.path.isdir', return_value=True) + @patch('gitlint.hooks.git_hooks_dir') + def test_install_commit_msg_hook(git_hooks_dir, isdir, path_exists, copy, stat, chmod): + lint_config = LintConfig() + lint_config.target = os.path.join(u"/hür", u"dur") + git_hooks_dir.return_value = os.path.join(u"/föo", u"bar", ".git", "hooks") + expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH) + GitHookInstaller.install_commit_msg_hook(lint_config) + isdir.assert_called_with(git_hooks_dir.return_value) + path_exists.assert_called_once_with(expected_dst) + copy.assert_called_once_with(COMMIT_MSG_HOOK_SRC_PATH, expected_dst) + stat.assert_called_once_with(expected_dst) + chmod.assert_called_once_with(expected_dst, ANY) + git_hooks_dir.assert_called_with(lint_config.target) + + @patch('gitlint.hooks.shutil.copy') + @patch('os.path.exists', return_value=False) + @patch('os.path.isdir', return_value=True) + @patch('gitlint.hooks.git_hooks_dir') + def test_install_commit_msg_hook_negative(self, git_hooks_dir, isdir, path_exists, copy): + lint_config = LintConfig() + lint_config.target = os.path.join(u"/hür", u"dur") + git_hooks_dir.return_value = os.path.join(u"/föo", u"bar", ".git", "hooks") + # mock that current dir is not a git repo + isdir.return_value = False + expected_msg = u"{0} is not a git repository".format(lint_config.target) + with self.assertRaisesRegex(GitHookInstallerError, expected_msg): + GitHookInstaller.install_commit_msg_hook(lint_config) + isdir.assert_called_with(git_hooks_dir.return_value) + path_exists.assert_not_called() + copy.assert_not_called() + + # mock that there is already a commit hook present + isdir.return_value = True + path_exists.return_value = True + expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH) + expected_msg = u"There is already a commit-msg hook file present in {0}.\n".format(expected_dst) + \ + "gitlint currently does not support appending to an existing commit-msg file." + with self.assertRaisesRegex(GitHookInstallerError, expected_msg): + GitHookInstaller.install_commit_msg_hook(lint_config) + + @staticmethod + @patch('os.remove') + @patch('os.path.exists', return_value=True) + @patch('os.path.isdir', return_value=True) + @patch('gitlint.hooks.git_hooks_dir') + def test_uninstall_commit_msg_hook(git_hooks_dir, isdir, path_exists, remove): + lint_config = LintConfig() + git_hooks_dir.return_value = os.path.join(u"/föo", u"bar", ".git", "hooks") + lint_config.target = os.path.join(u"/hür", u"dur") + read_data = "#!/bin/sh\n" + GITLINT_HOOK_IDENTIFIER + with patch('gitlint.hooks.io.open', mock_open(read_data=read_data), create=True): + GitHookInstaller.uninstall_commit_msg_hook(lint_config) + + expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH) + isdir.assert_called_with(git_hooks_dir.return_value) + path_exists.assert_called_once_with(expected_dst) + remove.assert_called_with(expected_dst) + git_hooks_dir.assert_called_with(lint_config.target) + + @patch('os.remove') + @patch('os.path.exists', return_value=True) + @patch('os.path.isdir', return_value=True) + @patch('gitlint.hooks.git_hooks_dir') + def test_uninstall_commit_msg_hook_negative(self, git_hooks_dir, isdir, path_exists, remove): + lint_config = LintConfig() + lint_config.target = os.path.join(u"/hür", u"dur") + git_hooks_dir.return_value = os.path.join(u"/föo", u"bar", ".git", "hooks") + + # mock that the current directory is not a git repo + isdir.return_value = False + expected_msg = u"{0} is not a git repository".format(lint_config.target) + with self.assertRaisesRegex(GitHookInstallerError, expected_msg): + GitHookInstaller.uninstall_commit_msg_hook(lint_config) + isdir.assert_called_with(git_hooks_dir.return_value) + path_exists.assert_not_called() + remove.assert_not_called() + + # mock that there is no commit hook present + isdir.return_value = True + path_exists.return_value = False + expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH) + expected_msg = u"There is no commit-msg hook present in {0}.".format(expected_dst) + with self.assertRaisesRegex(GitHookInstallerError, expected_msg): + GitHookInstaller.uninstall_commit_msg_hook(lint_config) + isdir.assert_called_with(git_hooks_dir.return_value) + path_exists.assert_called_once_with(expected_dst) + remove.assert_not_called() + + # mock that there is a different (=not gitlint) commit hook + isdir.return_value = True + path_exists.return_value = True + read_data = "#!/bin/sh\nfoo" + expected_dst = os.path.join(git_hooks_dir.return_value, COMMIT_MSG_HOOK_DST_PATH) + expected_msg = u"The commit-msg hook in {0} was not installed by gitlint ".format(expected_dst) + \ + "(or it was modified).\nUninstallation of 3th party or modified gitlint hooks " + \ + "is not supported." + with patch('gitlint.hooks.io.open', mock_open(read_data=read_data), create=True): + with self.assertRaisesRegex(GitHookInstallerError, expected_msg): + GitHookInstaller.uninstall_commit_msg_hook(lint_config) + remove.assert_not_called() diff --git a/gitlint/tests/test_lint.py b/gitlint/tests/test_lint.py new file mode 100644 index 0000000..bcdd984 --- /dev/null +++ b/gitlint/tests/test_lint.py @@ -0,0 +1,197 @@ +# -*- coding: utf-8 -*- + +try: + # python 2.x + from StringIO import StringIO +except ImportError: + # python 3.x + from io import StringIO + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + +from gitlint.tests.base import BaseTestCase +from gitlint.lint import GitLinter +from gitlint.rules import RuleViolation +from gitlint.config import LintConfig, LintConfigBuilder + + +class LintTests(BaseTestCase): + + def test_lint_sample1(self): + linter = GitLinter(LintConfig()) + gitcontext = self.gitcontext(self.get_sample("commit_message/sample1")) + violations = linter.lint(gitcontext.commits[-1]) + expected_errors = [RuleViolation("T3", "Title has trailing punctuation (.)", + u"Commit title contåining 'WIP', as well as trailing punctuation.", 1), + RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", + u"Commit title contåining 'WIP', as well as trailing punctuation.", 1), + RuleViolation("B4", "Second line is not empty", "This line should be empty", 2), + RuleViolation("B1", "Line exceeds max length (135>80)", + "This is the first line of the commit message body and it is meant to test " + + "a line that exceeds the maximum line length of 80 characters.", 3), + RuleViolation("B2", "Line has trailing whitespace", u"This line has a tråiling space. ", 4), + RuleViolation("B2", "Line has trailing whitespace", "This line has a trailing tab.\t", 5), + RuleViolation("B3", "Line contains hard tab characters (\\t)", + "This line has a trailing tab.\t", 5)] + + self.assertListEqual(violations, expected_errors) + + def test_lint_sample2(self): + linter = GitLinter(LintConfig()) + gitcontext = self.gitcontext(self.get_sample("commit_message/sample2")) + violations = linter.lint(gitcontext.commits[-1]) + expected = [RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", + u"Just a title contåining WIP", 1), + RuleViolation("B6", "Body message is missing", None, 3)] + + self.assertListEqual(violations, expected) + + def test_lint_sample3(self): + linter = GitLinter(LintConfig()) + gitcontext = self.gitcontext(self.get_sample("commit_message/sample3")) + violations = linter.lint(gitcontext.commits[-1]) + + title = u" Commit title containing 'WIP', \tleading and tråiling whitespace and longer than 72 characters." + expected = [RuleViolation("T1", "Title exceeds max length (95>72)", title, 1), + RuleViolation("T3", "Title has trailing punctuation (.)", title, 1), + RuleViolation("T4", "Title contains hard tab characters (\\t)", title, 1), + RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", title, 1), + RuleViolation("T6", "Title has leading whitespace", title, 1), + RuleViolation("B4", "Second line is not empty", "This line should be empty", 2), + RuleViolation("B1", "Line exceeds max length (101>80)", + u"This is the first line is meånt to test a line that exceeds the maximum line " + + "length of 80 characters.", 3), + RuleViolation("B2", "Line has trailing whitespace", "This line has a trailing space. ", 4), + RuleViolation("B2", "Line has trailing whitespace", u"This line has a tråiling tab.\t", 5), + RuleViolation("B3", "Line contains hard tab characters (\\t)", + u"This line has a tråiling tab.\t", 5)] + + self.assertListEqual(violations, expected) + + def test_lint_sample4(self): + commit = self.gitcommit(self.get_sample("commit_message/sample4")) + config_builder = LintConfigBuilder() + config_builder.set_config_from_commit(commit) + linter = GitLinter(config_builder.build()) + violations = linter.lint(commit) + # expect no violations because sample4 has a 'gitlint: disable line' + expected = [] + self.assertListEqual(violations, expected) + + def test_lint_sample5(self): + commit = self.gitcommit(self.get_sample("commit_message/sample5")) + config_builder = LintConfigBuilder() + config_builder.set_config_from_commit(commit) + linter = GitLinter(config_builder.build()) + violations = linter.lint(commit) + + title = u" Commit title containing 'WIP', \tleading and tråiling whitespace and longer than 72 characters." + # expect only certain violations because sample5 has a 'gitlint-ignore: T3, T6, body-max-line-length' + expected = [RuleViolation("T1", "Title exceeds max length (95>72)", title, 1), + RuleViolation("T4", "Title contains hard tab characters (\\t)", title, 1), + RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", title, 1), + RuleViolation("B4", "Second line is not empty", u"This line should be ëmpty", 2), + RuleViolation("B2", "Line has trailing whitespace", u"This line has a tråiling space. ", 4), + RuleViolation("B2", "Line has trailing whitespace", "This line has a trailing tab.\t", 5), + RuleViolation("B3", "Line contains hard tab characters (\\t)", + "This line has a trailing tab.\t", 5)] + self.assertListEqual(violations, expected) + + def test_lint_meta(self): + """ Lint sample2 but also add some metadata to the commit so we that get's linted as well """ + linter = GitLinter(LintConfig()) + gitcontext = self.gitcontext(self.get_sample("commit_message/sample2")) + gitcontext.commits[0].author_email = u"foo bår" + violations = linter.lint(gitcontext.commits[-1]) + expected = [RuleViolation("M1", "Author email for commit is invalid", u"foo bår", None), + RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", + u"Just a title contåining WIP", 1), + RuleViolation("B6", "Body message is missing", None, 3)] + + self.assertListEqual(violations, expected) + + def test_lint_ignore(self): + lint_config = LintConfig() + lint_config.ignore = ["T1", "T3", "T4", "T5", "T6", "B1", "B2"] + linter = GitLinter(lint_config) + violations = linter.lint(self.gitcommit(self.get_sample("commit_message/sample3"))) + + expected = [RuleViolation("B4", "Second line is not empty", "This line should be empty", 2), + RuleViolation("B3", "Line contains hard tab characters (\\t)", + u"This line has a tråiling tab.\t", 5)] + + self.assertListEqual(violations, expected) + + def test_lint_configuration_rule(self): + # Test that all rules are ignored because of matching regex + lint_config = LintConfig() + lint_config.set_rule_option("I1", "regex", "^Just a title(.*)") + + linter = GitLinter(lint_config) + violations = linter.lint(self.gitcommit(self.get_sample("commit_message/sample2"))) + self.assertListEqual(violations, []) + + # Test ignoring only certain rules + lint_config = LintConfig() + lint_config.set_rule_option("I1", "regex", "^Just a title(.*)") + lint_config.set_rule_option("I1", "ignore", "B6") + + linter = GitLinter(lint_config) + violations = linter.lint(self.gitcommit(self.get_sample("commit_message/sample2"))) + + # Normally we'd expect a B6 violation, but that one is skipped because of the specific ignore set above + expected = [RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", + u"Just a title contåining WIP", 1)] + + self.assertListEqual(violations, expected) + + def test_lint_special_commit(self): + for commit_type in ["merge", "revert", "squash", "fixup"]: + commit = self.gitcommit(self.get_sample("commit_message/{0}".format(commit_type))) + lintconfig = LintConfig() + linter = GitLinter(lintconfig) + violations = linter.lint(commit) + # Even though there are a number of violations in the commit message, they are ignored because + # we are dealing with a merge commit + self.assertListEqual(violations, []) + + # Check that we do see violations if we disable 'ignore-merge-commits' + setattr(lintconfig, "ignore_{0}_commits".format(commit_type), False) + linter = GitLinter(lintconfig) + violations = linter.lint(commit) + self.assertTrue(len(violations) > 0) + + def test_print_violations(self): + violations = [RuleViolation("RULE_ID_1", u"Error Messåge 1", "Violating Content 1", None), + RuleViolation("RULE_ID_2", "Error Message 2", u"Violåting Content 2", 2)] + linter = GitLinter(LintConfig()) + + # test output with increasing verbosity + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + linter.config.verbosity = 0 + linter.print_violations(violations) + self.assertEqual("", stderr.getvalue()) + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + linter.config.verbosity = 1 + linter.print_violations(violations) + expected = u"-: RULE_ID_1\n2: RULE_ID_2\n" + self.assertEqual(expected, stderr.getvalue()) + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + linter.config.verbosity = 2 + linter.print_violations(violations) + expected = u"-: RULE_ID_1 Error Messåge 1\n2: RULE_ID_2 Error Message 2\n" + self.assertEqual(expected, stderr.getvalue()) + + with patch('gitlint.display.stderr', new=StringIO()) as stderr: + linter.config.verbosity = 3 + linter.print_violations(violations) + expected = u"-: RULE_ID_1 Error Messåge 1: \"Violating Content 1\"\n" + \ + u"2: RULE_ID_2 Error Message 2: \"Violåting Content 2\"\n" + self.assertEqual(expected, stderr.getvalue()) diff --git a/gitlint/tests/test_options.py b/gitlint/tests/test_options.py new file mode 100644 index 0000000..2c17226 --- /dev/null +++ b/gitlint/tests/test_options.py @@ -0,0 +1,179 @@ +# -*- coding: utf-8 -*- +import os + +from gitlint.tests.base import BaseTestCase + +from gitlint.options import IntOption, BoolOption, StrOption, ListOption, PathOption, RuleOptionError + + +class RuleOptionTests(BaseTestCase): + def test_option_equality(self): + # 2 options are equal if their name, value and description match + option1 = IntOption("test-option", 123, u"Test Dëscription") + option2 = IntOption("test-option", 123, u"Test Dëscription") + self.assertEqual(option1, option2) + + # Not equal: name, description, value are different + self.assertNotEqual(option1, IntOption("test-option1", 123, u"Test Dëscription")) + self.assertNotEqual(option1, IntOption("test-option", 1234, u"Test Dëscription")) + self.assertNotEqual(option1, IntOption("test-option", 123, u"Test Dëscription2")) + + def test_int_option(self): + # normal behavior + option = IntOption("test-name", 123, "Test Description") + self.assertEqual(option.value, 123) + self.assertEqual(option.name, "test-name") + self.assertEqual(option.description, "Test Description") + + # re-set value + option.set(456) + self.assertEqual(option.value, 456) + + # error on negative int when not allowed + expected_error = u"Option 'test-name' must be a positive integer (current value: '-123')" + with self.assertRaisesRegex(RuleOptionError, expected_error): + option.set(-123) + + # error on non-int value + expected_error = u"Option 'test-name' must be a positive integer (current value: 'foo')" + with self.assertRaisesRegex(RuleOptionError, expected_error): + option.set("foo") + + # no error on negative value when allowed and negative int is passed + option = IntOption("test-name", 123, "Test Description", allow_negative=True) + option.set(-456) + self.assertEqual(option.value, -456) + + # error on non-int value when negative int is allowed + expected_error = u"Option 'test-name' must be an integer (current value: 'foo')" + with self.assertRaisesRegex(RuleOptionError, expected_error): + option.set("foo") + + def test_str_option(self): + # normal behavior + option = StrOption("test-name", u"föo", "Test Description") + self.assertEqual(option.value, u"föo") + self.assertEqual(option.name, "test-name") + self.assertEqual(option.description, "Test Description") + + # re-set value + option.set(u"bår") + self.assertEqual(option.value, u"bår") + + # conversion to str + option.set(123) + self.assertEqual(option.value, "123") + + # conversion to str + option.set(-123) + self.assertEqual(option.value, "-123") + + def test_boolean_option(self): + # normal behavior + option = BoolOption("test-name", "true", "Test Description") + self.assertEqual(option.value, True) + + # re-set value + option.set("False") + self.assertEqual(option.value, False) + + # Re-set using actual boolean + option.set(True) + self.assertEqual(option.value, True) + + # error on incorrect value + incorrect_values = [1, -1, "foo", u"bår", ["foo"], {'foo': "bar"}] + for value in incorrect_values: + with self.assertRaisesRegex(RuleOptionError, "Option 'test-name' must be either 'true' or 'false'"): + option.set(value) + + def test_list_option(self): + # normal behavior + option = ListOption("test-name", u"å,b,c,d", "Test Description") + self.assertListEqual(option.value, [u"å", u"b", u"c", u"d"]) + + # re-set value + option.set(u"1,2,3,4") + self.assertListEqual(option.value, [u"1", u"2", u"3", u"4"]) + + # set list + option.set([u"foo", u"bår", u"test"]) + self.assertListEqual(option.value, [u"foo", u"bår", u"test"]) + + # empty string + option.set("") + self.assertListEqual(option.value, []) + + # whitespace string + option.set(" \t ") + self.assertListEqual(option.value, []) + + # empty list + option.set([]) + self.assertListEqual(option.value, []) + + # trailing comma + option.set(u"ë,f,g,") + self.assertListEqual(option.value, [u"ë", u"f", u"g"]) + + # leading and trailing whitespace should be trimmed, but only deduped within text + option.set(" abc , def , ghi \t , jkl mno ") + self.assertListEqual(option.value, ["abc", "def", "ghi", "jkl mno"]) + + # Also strip whitespace within a list + option.set(["\t foo", "bar \t ", " test 123 "]) + self.assertListEqual(option.value, ["foo", "bar", "test 123"]) + + # conversion to string before split + option.set(123) + self.assertListEqual(option.value, ["123"]) + + def test_path_option(self): + option = PathOption("test-directory", ".", u"Test Description", type=u"dir") + self.assertEqual(option.value, os.getcwd()) + self.assertEqual(option.name, "test-directory") + self.assertEqual(option.description, u"Test Description") + self.assertEqual(option.type, u"dir") + + # re-set value + option.set(self.SAMPLES_DIR) + self.assertEqual(option.value, self.SAMPLES_DIR) + + # set to int + expected = u"Option test-directory must be an existing directory (current value: '1234')" + with self.assertRaisesRegex(RuleOptionError, expected): + option.set(1234) + + # set to non-existing directory + non_existing_path = os.path.join(u"/föo", u"bar") + expected = u"Option test-directory must be an existing directory (current value: '{0}')" + with self.assertRaisesRegex(RuleOptionError, expected.format(non_existing_path)): + option.set(non_existing_path) + + # set to a file, should raise exception since option.type = dir + sample_path = self.get_sample_path(os.path.join("commit_message", "sample1")) + expected = u"Option test-directory must be an existing directory (current value: '{0}')".format(sample_path) + with self.assertRaisesRegex(RuleOptionError, expected): + option.set(sample_path) + + # set option.type = file, file should now be accepted, directories not + option.type = u"file" + option.set(sample_path) + self.assertEqual(option.value, sample_path) + expected = u"Option test-directory must be an existing file (current value: '{0}')".format( + self.get_sample_path()) + with self.assertRaisesRegex(RuleOptionError, expected): + option.set(self.get_sample_path()) + + # set option.type = both, files and directories should now be accepted + option.type = u"both" + option.set(sample_path) + self.assertEqual(option.value, sample_path) + option.set(self.get_sample_path()) + self.assertEqual(option.value, self.get_sample_path()) + + # Expect exception if path type is invalid + option.type = u'föo' + expected = u"Option test-directory type must be one of: 'file', 'dir', 'both' (current: 'föo')" + with self.assertRaisesRegex(RuleOptionError, expected): + option.set("haha") diff --git a/gitlint/tests/test_utils.py b/gitlint/tests/test_utils.py new file mode 100644 index 0000000..6f667c2 --- /dev/null +++ b/gitlint/tests/test_utils.py @@ -0,0 +1,78 @@ +# -*- coding: utf-8 -*- + +from gitlint import utils +from gitlint.tests.base import BaseTestCase + +try: + # python 2.x + from mock import patch +except ImportError: + # python 3.x + from unittest.mock import patch # pylint: disable=no-name-in-module, import-error + + +class UtilsTests(BaseTestCase): + + def tearDown(self): + # Since we're messing around with `utils.PLATFORM_IS_WINDOWS` during these tests, we need to reset + # its value after we're done this doesn't influence other tests + utils.PLATFORM_IS_WINDOWS = utils.platform_is_windows() + + @patch('os.environ') + def test_use_sh_library(self, patched_env): + patched_env.get.return_value = "1" + self.assertEqual(utils.use_sh_library(), True) + patched_env.get.assert_called_once_with("GITLINT_USE_SH_LIB", None) + + for invalid_val in ["0", u"foöbar"]: + patched_env.get.reset_mock() # reset mock call count + patched_env.get.return_value = invalid_val + self.assertEqual(utils.use_sh_library(), False, invalid_val) + patched_env.get.assert_called_once_with("GITLINT_USE_SH_LIB", None) + + # Assert that when GITLINT_USE_SH_LIB is not set, we fallback to checking whether we're on Windows + utils.PLATFORM_IS_WINDOWS = True + patched_env.get.return_value = None + self.assertEqual(utils.use_sh_library(), False) + + utils.PLATFORM_IS_WINDOWS = False + self.assertEqual(utils.use_sh_library(), True) + + @patch('gitlint.utils.locale') + def test_default_encoding_non_windows(self, mocked_locale): + utils.PLATFORM_IS_WINDOWS = False + mocked_locale.getpreferredencoding.return_value = u"foöbar" + self.assertEqual(utils.getpreferredencoding(), u"foöbar") + mocked_locale.getpreferredencoding.assert_called_once() + + mocked_locale.getpreferredencoding.return_value = False + self.assertEqual(utils.getpreferredencoding(), u"UTF-8") + + @patch('os.environ') + def test_default_encoding_windows(self, patched_env): + utils.PLATFORM_IS_WINDOWS = True + # Mock out os.environ + mock_env = {} + + def mocked_get(key, default): + return mock_env.get(key, default) + + patched_env.get.side_effect = mocked_get + + # Assert getpreferredencoding reads env vars in order: LC_ALL, LC_CTYPE, LANG + mock_env = {"LC_ALL": u"lc_all_välue", "LC_CTYPE": u"foo", "LANG": u"bar"} + self.assertEqual(utils.getpreferredencoding(), u"lc_all_välue") + mock_env = {"LC_CTYPE": u"lc_ctype_välue", "LANG": u"hur"} + self.assertEqual(utils.getpreferredencoding(), u"lc_ctype_välue") + mock_env = {"LANG": u"lang_välue"} + self.assertEqual(utils.getpreferredencoding(), u"lang_välue") + + # Assert split on dot + mock_env = {"LANG": u"foo.bär"} + self.assertEqual(utils.getpreferredencoding(), u"bär") + + # assert default encoding is UTF-8 + mock_env = {} + self.assertEqual(utils.getpreferredencoding(), "UTF-8") + mock_env = {"FOO": u"föo"} + self.assertEqual(utils.getpreferredencoding(), "UTF-8") |