diff options
Diffstat (limited to 'gitlint/tests')
84 files changed, 0 insertions, 5266 deletions
diff --git a/gitlint/tests/__init__.py b/gitlint/tests/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/gitlint/tests/__init__.py +++ /dev/null diff --git a/gitlint/tests/base.py b/gitlint/tests/base.py deleted file mode 100644 index 017122b..0000000 --- a/gitlint/tests/base.py +++ /dev/null @@ -1,191 +0,0 @@ -# -*- coding: utf-8 -*- - -import contextlib -import copy -import io -import logging -import os -import re -import shutil -import tempfile - -import unittest - -from unittest.mock import patch - -from gitlint.git import GitContext -from gitlint.utils import LOG_FORMAT, DEFAULT_ENCODING - - -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 - @contextlib.contextmanager - def tempdir(): - tmpdir = tempfile.mkdtemp() - try: - yield tmpdir - finally: - shutil.rmtree(tmpdir) - - @staticmethod - def get_sample_path(filename=""): - # Don't join up empty files names because this will add a trailing slash - if filename == "": - return BaseTestCase.SAMPLES_DIR - - return 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 = content.read() - return sample - - @staticmethod - def patch_input(side_effect): - """ Patches the built-in input() with a provided side-effect """ - module_path = "builtins.input" - patched_module = patch(module_path, side_effect=side_effect) - return patched_module - - @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 = 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 = "#" - 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().assertRaisesRegex(expected_exception, re.escape(expected_regex), *args, **kwargs) - - def clearlog(self): - """ Clears the log capture """ - self.logcapture.clear() - - @contextlib.contextmanager - def assertRaisesMessage(self, expected_exception, expected_msg): # pylint: disable=invalid-name - """ Asserts an exception has occurred with a given error message """ - try: - yield - except expected_exception as exc: - exception_msg = str(exc) - if exception_msg != expected_msg: - error = f"Right exception, wrong message:\n got: {exception_msg}\n expected: {expected_msg}" - raise self.fail(error) - # else: everything is fine, just return - return - except Exception as exc: - raise self.fail(f"Expected '{expected_exception.__name__}' got '{exc.__class__.__name__}'") - - # No exception raised while we expected one - raise self.fail(f"Expected to raise {expected_exception.__name__}, didn't get an exception at all") - - 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, "föo") - self.assertNotEqual(obj, clone) - attr_kwargs_copy[attr] = "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(self.format(record)) - - def clear(self): - self.messages = [] diff --git a/gitlint/tests/cli/test_cli.py b/gitlint/tests/cli/test_cli.py deleted file mode 100644 index 59ec7af..0000000 --- a/gitlint/tests/cli/test_cli.py +++ /dev/null @@ -1,593 +0,0 @@ -# -*- coding: utf-8 -*- - - -import io -import os -import sys -import platform - -import arrow - -from io import StringIO - -from click.testing import CliRunner - -from unittest.mock import patch - -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 - - -class CLITests(BaseTestCase): - USAGE_ERROR_CODE = 253 - GIT_CONTEXT_ERROR_CODE = 254 - CONFIG_ERROR_CODE = 255 - GITLINT_SUCCESS_CODE = 0 - - 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()), - 'DEFAULT_ENCODING': DEFAULT_ENCODING} - - def test_version(self): - """ Test for --version option """ - result = self.cli.invoke(cli.cli, ["--version"]) - self.assertEqual(result.output.split("\n")[0], f"cli, version {__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", - "test åuthor\x00test-email@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "commït-title\n\ncommït-body", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", - "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> - "test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "commït-title1\n\ncommït-body1", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> - "commit-1/file-1\ncommit-1/file-2\n", # git diff-tree - # git log --pretty <FORMAT> <SHA> - "test åuthor2\x00test-email3@föo.com\x002016-12-04 15:28:15 +0100\x00åbc\n" - "commït-title2\n\ncommït-body2", - "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> - "commit-2/file-1\ncommit-2/file-2\n", # git diff-tree - # git log --pretty <FORMAT> <SHA> - "test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00åbc\n" - "commït-title3\n\ncommït-body3", - "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> - "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("cli/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> - "test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "commït-title1\n\ncommït-body1", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> - "commit-1/file-1\ncommit-1/file-2\n", # git diff-tree - # git log --pretty <FORMAT> <SHA> - "test åuthor2\x00test-email2@föo.com\x002016-12-04 15:28:15 +0100\x00åbc\n" - "commït-title2.\n\ncommït-body2\ngitlint-ignore: T3\n", - "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> - "commit-2/file-1\ncommit-2/file-2\n", # git diff-tree - # git log --pretty <FORMAT> <SHA> - "test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00åbc\n" - "commït-title3.\n\ncommït-body3", - "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> - "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("cli/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> - "test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "commït-title1\n\ncommït-body1", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> - "commit-1/file-1\ncommit-1/file-2\n", # git diff-tree - # git log --pretty <FORMAT> <SHA> - "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 - "commït-title2.\n\ncommït-body2\n", - "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> - "commit-2/file-1\ncommit-2/file-2\n", # git diff-tree - # git log --pretty <FORMAT> <SHA> - "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 - "commït-title3.\n\ncommït-body3 foo", - "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> - "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 = ("Commit 6f29bf81a8:\n" - u'3: B5 Body message is too short (12<20): "commït-body1"\n\n' - "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=False) - @patch('gitlint.git.sh') - def test_lint_commit(self, sh, _): - """ Test for --commit option """ - - sh.git.side_effect = [ - "6f29bf81a8322a04071bb794666e48c443a90360\n", # git log -1 <SHA> --pretty=%H - # git log --pretty <FORMAT> <SHA> - "test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "WIP: commït-title1\n\ncommït-body1", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> - "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, ["--commit", "foo"]) - self.assertEqual(result.output, "") - - self.assertEqual(stderr.getvalue(), self.get_expected("cli/test_cli/test_lint_commit_1")) - self.assertEqual(result.exit_code, 2) - - @patch('gitlint.cli.get_stdin_data', return_value=False) - @patch('gitlint.git.sh') - def test_lint_commit_negative(self, sh, _): - """ Negative test for --commit option """ - - # Try using --commit and --commits at the same time (not allowed) - result = self.cli.invoke(cli.cli, ["--commit", "foo", "--commits", "foo...bar"]) - expected_output = "Error: --commit and --commits are mutually exclusive, use one or the other.\n" - self.assertEqual(result.output, expected_output) - self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) - - @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("cli/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("cli/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('cli/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", - "test åuthor\x00test-email@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "commït-title\n\ncommït-body", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> - "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 = [ - "#", # git config --get core.commentchar - "föo user\n", # git config --get user.name - "föo@bar.com\n", # git config --get user.email - "my-branch\n", # git rev-parse --abbrev-ref HEAD (=current branch) - "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("cli/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('cli/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 = [ - "#", # git config --get core.commentchar - "föo user\n", # git config --get user.name - "föo@bar.com\n", # git config --get user.email - "my-branch\n", # git rev-parse --abbrev-ref HEAD (=current branch) - "commit-1/file-1\ncommit-1/file-2\n", # git diff-tree - ] - - with self.tempdir() as tmpdir: - msg_filename = os.path.join(tmpdir, "msg") - with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: - f.write("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("cli/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('cli/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, ("Error: The 'staged' option (--staged) can only be used when using " - "'--msg-filename' or when piping data to gitlint via stdin.\n")) - - @patch('gitlint.cli.get_stdin_data', return_value=False) - @patch('gitlint.git.sh') - def test_fail_without_commits(self, sh, _): - """ Test for --debug option """ - - sh.git.side_effect = [ - "", # First invocation of git rev-list - "" # Second invocation of git rev-list - ] - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - # By default, gitlint should silently exit with code GITLINT_SUCCESS when there are no commits - result = self.cli.invoke(cli.cli, ["--commits", "foo..bar"]) - self.assertEqual(stderr.getvalue(), "") - self.assertEqual(result.exit_code, cli.GITLINT_SUCCESS) - self.assert_log_contains("DEBUG: gitlint.cli No commits in range \"foo..bar\"") - - # When --fail-without-commits is set, gitlint should hard fail with code USAGE_ERROR_CODE - self.clearlog() - result = self.cli.invoke(cli.cli, ["--commits", "foo..bar", "--fail-without-commits"]) - self.assertEqual(result.output, 'Error: No commits in range "foo..bar"\n') - self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) - self.assert_log_contains("DEBUG: gitlint.cli No commits in range \"foo..bar\"") - - @patch('gitlint.cli.get_stdin_data', return_value=False) - def test_msg_filename(self, _): - expected_output = "3: B6 Body message is missing\n" - - with self.tempdir() as tmpdir: - msg_filename = os.path.join(tmpdir, "msg") - with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: - f.write("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="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="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="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> - "test åuthor1\x00test-email1@föo.com\x002016-12-03 15:28:15 +0100\x00abc\n" - "commït-title1\n\ncommït-body1", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> - "commit-1/file-1\ncommit-1/file-2\n", # git diff-tree - "test åuthor2\x00test-email2@föo.com\x002016-12-04 15:28:15 +0100\x00abc\n" - "commït-title2.\n\ncommït-body2", - "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> - "commit-2/file-1\ncommit-2/file-2\n", # git diff-tree - "test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00abc\n" - "föobar\nbar", - "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> - "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('cli/test_cli/test_debug_1', expected_kwargs) - self.assert_logged(expected_logs) - - @patch('gitlint.cli.get_stdin_data', return_value="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]) - expected_output = "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]) - expected_output = "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="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('cli/test_cli/test_contrib_1') - self.assertEqual(stderr.getvalue(), expected_output) - self.assertEqual(result.exit_code, 2) - - @patch('gitlint.cli.get_stdin_data', return_value="Test tïtle\n") - def test_contrib_negative(self, _): - result = self.cli.invoke(cli.cli, ["--contrib", "föobar,CC1"]) - self.assertEqual(result.output, "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="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 = f"Error: Invalid value for '-C' / '--config': File '{config_path}' is a directory." - 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("föo") - result = self.cli.invoke(cli.cli, ["--config", config_path]) - expected_string = f"Error: Invalid value for '-C' / '--config': File '{config_path}' does not exist." - 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 """ - with self.tempdir() as tmpdir: - tmpdir_path = os.path.realpath(tmpdir) - os.environ["LANGUAGE"] = "C" # Force language to english so we can check for error message - result = self.cli.invoke(cli.cli, ["--target", tmpdir_path]) - # We expect gitlint to tell us that /tmp is not a git repo (this proves that it takes the target parameter - # into account). - self.assertEqual(result.output, "%s is not a git repository.\n" % tmpdir_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", "/föo/bar"]) - self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) - expected_msg = "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 = f"Error: Invalid value for '--target': Directory '{target_path}' is a file." - 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="tëstfile\n") - self.assertEqual(result.exit_code, self.GITLINT_SUCCESS_CODE) - expected_msg = "Please specify a location for the sample gitlint config file [.gitlint]: tëstfile\n" + \ - f"Successfully generated {os.path.realpath('tëstfile')}\n" - self.assertEqual(result.output, expected_msg) - generate_config.assert_called_once_with(os.path.realpath("tëstfile")) - - def test_generate_config_negative(self): - """ Negative test for the generate-config subcommand """ - # Non-existing directory - fake_dir = os.path.abspath("/föo") - fake_path = os.path.join(fake_dir, "bar") - result = self.cli.invoke(cli.cli, ["generate-config"], input=fake_path) - self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) - expected_msg = f"Please specify a location for the sample gitlint config file [.gitlint]: {fake_path}\n" + \ - f"Error: Directory '{fake_dir}' does not exist.\n" - 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 " + \ - f"config file [.gitlint]: {sample_path}\n" + \ - f"Error: File \"{sample_path}\" already exists.\n" - 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("DEBUG: gitlint.cli No commits in range \"master...HEAD\"") - self.assertEqual(result.exit_code, self.GITLINT_SUCCESS_CODE) - - @patch('gitlint.cli.get_stdin_data', return_value="WIP: tëst tïtle") - def test_named_rules(self, _): - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - config_path = self.get_sample_path(os.path.join("config", "named-rules")) - result = self.cli.invoke(cli.cli, ["--config", config_path, "--debug"]) - self.assertEqual(result.output, "") - self.assertEqual(stderr.getvalue(), self.get_expected("cli/test_cli/test_named_rules_1")) - self.assertEqual(result.exit_code, 4) - - # Assert debug logs are correct - expected_kwargs = self.get_system_info_dict() - expected_kwargs.update({'config_path': config_path}) - expected_logs = self.get_expected('cli/test_cli/test_named_rules_2', expected_kwargs) - self.assert_logged(expected_logs) diff --git a/gitlint/tests/cli/test_cli_hooks.py b/gitlint/tests/cli/test_cli_hooks.py deleted file mode 100644 index 825345f..0000000 --- a/gitlint/tests/cli/test_cli_hooks.py +++ /dev/null @@ -1,281 +0,0 @@ -# -*- coding: utf-8 -*- - -import io -from io import StringIO -import os - -from click.testing import CliRunner - -from unittest.mock import patch - -from gitlint.tests.base import BaseTestCase -from gitlint import cli -from gitlint import hooks -from gitlint import config -from gitlint.shell import ErrorReturnCode - -from gitlint.utils import DEFAULT_ENCODING - - -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("/hür", "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("/hür", "dur", hooks.COMMIT_MSG_HOOK_DST_PATH) - expected = f"Successfully installed gitlint commit-msg hook in {expected_path}\n" - 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("/hür", "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("/hür", "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("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, "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("/hür", "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("/hür", "dur", hooks.COMMIT_MSG_HOOK_DST_PATH) - expected = f"Successfully uninstalled gitlint commit-msg hook from {expected_path}\n" - 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("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, "tëst\n") - expected_config = config.LintConfig() - expected_config.target = os.path.realpath(os.getcwd()) - uninstall_hook.assert_called_once_with(expected_config) - - def test_run_hook_no_tty(self): - """ Test for run-hook subcommand. - When no TTY is available (like is the case for this test), the hook will abort after the first check. - """ - - # No need to patch git as we're passing a msg-filename to run-hook, so no git calls are made. - # Note that this is the case when passing --staged as well, but that's tested as part of the integration tests - # (=end-to-end scenario). - - # Ideally we'd be able to assert that run-hook internally calls the lint cli command, but couldn't make - # that work. Have tried many different variatons of mocking and patching without avail. For now, we just - # check the output which indirectly proves the same thing. - - with self.tempdir() as tmpdir: - msg_filename = os.path.join(tmpdir, "hür") - with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: - f.write("WIP: tïtle\n") - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["--msg-filename", msg_filename, "run-hook"]) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_hook_no_tty_1_stdout')) - self.assertEqual(stderr.getvalue(), self.get_expected("cli/test_cli_hooks/test_hook_no_tty_1_stderr")) - - # exit code is 1 because aborted (no stdin available) - self.assertEqual(result.exit_code, 1) - - @patch('gitlint.cli.shell') - def test_run_hook_edit(self, shell): - """ Test for run-hook subcommand, answering 'e(dit)' after commit-hook """ - - set_editors = [None, "myeditor"] - expected_editors = ["vim -n", "myeditor"] - commit_messages = ["WIP: höok edit 1", "WIP: höok edit 2"] - - for i in range(0, len(set_editors)): - if set_editors[i]: - os.environ['EDITOR'] = set_editors[i] - - with self.patch_input(['e', 'e', 'n']): - with self.tempdir() as tmpdir: - msg_filename = os.path.realpath(os.path.join(tmpdir, "hür")) - with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: - f.write(commit_messages[i] + "\n") - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["--msg-filename", msg_filename, "run-hook"]) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_hook_edit_1_stdout', - {"commit_msg": commit_messages[i]})) - expected = self.get_expected("cli/test_cli_hooks/test_hook_edit_1_stderr", - {"commit_msg": commit_messages[i]}) - self.assertEqual(stderr.getvalue(), expected) - - # exit code = number of violations - self.assertEqual(result.exit_code, 2) - - shell.assert_called_with(expected_editors[i] + " " + msg_filename) - self.assert_log_contains("DEBUG: gitlint.cli run-hook: editing commit message") - self.assert_log_contains(f"DEBUG: gitlint.cli run-hook: {expected_editors[i]} {msg_filename}") - - def test_run_hook_no(self): - """ Test for run-hook subcommand, answering 'n(o)' after commit-hook """ - - with self.patch_input(['n']): - with self.tempdir() as tmpdir: - msg_filename = os.path.join(tmpdir, "hür") - with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: - f.write("WIP: höok no\n") - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["--msg-filename", msg_filename, "run-hook"]) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_hook_no_1_stdout')) - self.assertEqual(stderr.getvalue(), self.get_expected("cli/test_cli_hooks/test_hook_no_1_stderr")) - - # We decided not to keep the commit message: hook returns number of violations (>0) - # This will cause git to abort the commit - self.assertEqual(result.exit_code, 2) - self.assert_log_contains("DEBUG: gitlint.cli run-hook: commit message declined") - - def test_run_hook_yes(self): - """ Test for run-hook subcommand, answering 'y(es)' after commit-hook """ - with self.patch_input(['y']): - with self.tempdir() as tmpdir: - msg_filename = os.path.join(tmpdir, "hür") - with io.open(msg_filename, 'w', encoding=DEFAULT_ENCODING) as f: - f.write("WIP: höok yes\n") - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["--msg-filename", msg_filename, "run-hook"]) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_hook_yes_1_stdout')) - self.assertEqual(stderr.getvalue(), self.get_expected("cli/test_cli_hooks/test_hook_yes_1_stderr")) - - # Exit code is 0 because we decide to keep the commit message - # This will cause git to keep the commit - self.assertEqual(result.exit_code, 0) - self.assert_log_contains("DEBUG: gitlint.cli run-hook: commit message accepted") - - @patch('gitlint.cli.get_stdin_data', return_value=False) - @patch('gitlint.git.sh') - def test_run_hook_negative(self, sh, _): - """ Negative test for the run-hook subcommand: testing whether exceptions are correctly handled when - running `gitlint run-hook`. - """ - # GIT_CONTEXT_ERROR_CODE: git error - error_msg = b"fatal: not a git repository (or any of the parent directories): .git" - sh.git.side_effect = ErrorReturnCode("full command", b"stdout", error_msg) - result = self.cli.invoke(cli.cli, ["run-hook"]) - expected = self.get_expected('cli/test_cli_hooks/test_run_hook_negative_1', {'git_repo': os.getcwd()}) - self.assertEqual(result.output, expected) - self.assertEqual(result.exit_code, self.GIT_CONTEXT_ERROR_CODE) - - # USAGE_ERROR_CODE: incorrect use of gitlint - result = self.cli.invoke(cli.cli, ["--staged", "run-hook"]) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_run_hook_negative_2')) - self.assertEqual(result.exit_code, self.USAGE_ERROR_CODE) - - # CONFIG_ERROR_CODE: incorrect config. Note that this is handled before the hook even runs - result = self.cli.invoke(cli.cli, ["-c", "föo.bár=1", "run-hook"]) - self.assertEqual(result.output, "Config Error: No such rule 'föo'\n") - self.assertEqual(result.exit_code, self.CONFIG_ERROR_CODE) - - @patch('gitlint.cli.get_stdin_data', return_value="WIP: Test hook stdin tïtle\n") - def test_run_hook_stdin_violations(self, _): - """ Test for passing stdin data to run-hook, expecting some violations. Equivalent of: - $ echo "WIP: Test hook stdin tïtle" | gitlint run-hook - """ - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["run-hook"]) - expected_stderr = self.get_expected('cli/test_cli_hooks/test_hook_stdin_violations_1_stderr') - self.assertEqual(stderr.getvalue(), expected_stderr) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_hook_stdin_violations_1_stdout')) - # Hook will auto-abort because we're using stdin. Abort = exit code 1 - self.assertEqual(result.exit_code, 1) - - @patch('gitlint.cli.get_stdin_data', return_value="Test tïtle\n\nTest bödy that is long enough") - def test_run_hook_stdin_no_violations(self, _): - """ Test for passing stdin data to run-hook, expecting *NO* violations, Equivalent of: - $ echo -e "Test tïtle\n\nTest bödy that is long enough" | gitlint run-hook - """ - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["run-hook"]) - self.assertEqual(stderr.getvalue(), "") # no errors = no stderr output - expected_stdout = self.get_expected('cli/test_cli_hooks/test_hook_stdin_no_violations_1_stdout') - self.assertEqual(result.output, expected_stdout) - self.assertEqual(result.exit_code, 0) - - @patch('gitlint.cli.get_stdin_data', return_value="WIP: Test hook config tïtle\n") - def test_run_hook_config(self, _): - """ Test that gitlint still respects config when running run-hook, equivalent of: - $ echo "WIP: Test hook config tïtle" | gitlint -c title-max-length.line-length=5 --ignore B6 run-hook - """ - - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["-c", "title-max-length.line-length=5", "--ignore", "B6", "run-hook"]) - self.assertEqual(stderr.getvalue(), self.get_expected('cli/test_cli_hooks/test_hook_config_1_stderr')) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_hook_config_1_stdout')) - # Hook will auto-abort because we're using stdin. Abort = exit code 1 - self.assertEqual(result.exit_code, 1) - - @patch('gitlint.cli.get_stdin_data', return_value=False) - @patch('gitlint.git.sh') - def test_run_hook_local_commit(self, sh, _): - """ Test running the hook on the last commit-msg from the local repo, equivalent of: - $ gitlint run-hook - and then choosing 'e' - """ - sh.git.side_effect = [ - "6f29bf81a8322a04071bb794666e48c443a90360", - "test åuthor\x00test-email@föo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "WIP: commït-title\n\ncommït-body", - "#", # git config --get core.commentchar - "commit-1-branch-1\ncommit-1-branch-2\n", - "file1.txt\npåth/to/file2.txt\n" - ] - - with self.patch_input(['e']): - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["run-hook"]) - expected = self.get_expected('cli/test_cli_hooks/test_hook_local_commit_1_stderr') - self.assertEqual(stderr.getvalue(), expected) - self.assertEqual(result.output, self.get_expected('cli/test_cli_hooks/test_hook_local_commit_1_stdout')) - # If we can't edit the message, run-hook follows regular gitlint behavior and exit code = # violations - self.assertEqual(result.exit_code, 2) diff --git a/gitlint/tests/config/test_config.py b/gitlint/tests/config/test_config.py deleted file mode 100644 index c3fd78a..0000000 --- a/gitlint/tests/config/test_config.py +++ /dev/null @@ -1,287 +0,0 @@ -# -*- coding: utf-8 -*- - -from unittest.mock import patch - -from gitlint import rules -from gitlint.config import LintConfig, LintConfigError, LintConfigGenerator, GITLINT_CONFIG_TEMPLATE_SRC_PATH -from gitlint import options -from gitlint.tests.base import BaseTestCase - - -class LintConfigTests(BaseTestCase): - - def test_set_rule_option(self): - config = LintConfig() - - # assert default title line-length - self.assertEqual(config.get_rule_option('title-max-length', 'line-length'), 72) - - # change line length and assert it is set - config.set_rule_option('title-max-length', 'line-length', 60) - self.assertEqual(config.get_rule_option('title-max-length', 'line-length'), 60) - - def test_set_rule_option_negative(self): - config = LintConfig() - - # non-existing rule - expected_error_msg = "No such rule 'föobar'" - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config.set_rule_option(u'föobar', u'lïne-length', 60) - - # non-existing option - expected_error_msg = "Rule 'title-max-length' has no option 'föobar'" - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config.set_rule_option('title-max-length', u'föobar', 60) - - # invalid option value - expected_error_msg = "'föo' is not a valid value for option 'title-max-length.line-length'. " + \ - "Option 'line-length' must be a positive integer (current value: 'föo')." - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config.set_rule_option('title-max-length', 'line-length', "föo") - - def test_set_general_option(self): - config = LintConfig() - - # Check that default general options are correct - self.assertTrue(config.ignore_merge_commits) - self.assertTrue(config.ignore_fixup_commits) - self.assertTrue(config.ignore_squash_commits) - self.assertTrue(config.ignore_revert_commits) - - self.assertFalse(config.ignore_stdin) - self.assertFalse(config.staged) - self.assertFalse(config.fail_without_commits) - self.assertFalse(config.debug) - self.assertEqual(config.verbosity, 3) - active_rule_classes = tuple(type(rule) for rule in config.rules) - self.assertTupleEqual(active_rule_classes, config.default_rule_classes) - - # ignore - set by string - config.set_general_option("ignore", "title-trailing-whitespace, B2") - self.assertEqual(config.ignore, ["title-trailing-whitespace", "B2"]) - - # ignore - set by list - config.set_general_option("ignore", ["T1", "B3"]) - self.assertEqual(config.ignore, ["T1", "B3"]) - - # verbosity - config.set_general_option("verbosity", 1) - self.assertEqual(config.verbosity, 1) - - # ignore_merge_commit - config.set_general_option("ignore-merge-commits", "false") - self.assertFalse(config.ignore_merge_commits) - - # ignore_fixup_commit - config.set_general_option("ignore-fixup-commits", "false") - self.assertFalse(config.ignore_fixup_commits) - - # ignore_squash_commit - config.set_general_option("ignore-squash-commits", "false") - self.assertFalse(config.ignore_squash_commits) - - # ignore_revert_commit - config.set_general_option("ignore-revert-commits", "false") - self.assertFalse(config.ignore_revert_commits) - - # debug - config.set_general_option("debug", "true") - self.assertTrue(config.debug) - - # ignore-stdin - config.set_general_option("ignore-stdin", "true") - self.assertTrue(config.debug) - - # staged - config.set_general_option("staged", "true") - self.assertTrue(config.staged) - - # fail-without-commits - config.set_general_option("fail-without-commits", "true") - self.assertTrue(config.fail_without_commits) - - # target - config.set_general_option("target", self.SAMPLES_DIR) - self.assertEqual(config.target, self.SAMPLES_DIR) - - # extra_path has its own test: test_extra_path and test_extra_path_negative - # contrib has its own tests: test_contrib and test_contrib_negative - - def test_contrib(self): - config = LintConfig() - contrib_rules = ["contrib-title-conventional-commits", "CC1"] - config.set_general_option("contrib", ",".join(contrib_rules)) - self.assertEqual(config.contrib, contrib_rules) - - # Check contrib-title-conventional-commits contrib rule - actual_rule = config.rules.find_rule("contrib-title-conventional-commits") - self.assertTrue(actual_rule.is_contrib) - - self.assertEqual(str(type(actual_rule)), "<class 'conventional_commit.ConventionalCommit'>") - self.assertEqual(actual_rule.id, 'CT1') - self.assertEqual(actual_rule.name, u'contrib-title-conventional-commits') - self.assertEqual(actual_rule.target, rules.CommitMessageTitle) - - expected_rule_option = options.ListOption( - "types", - ["fix", "feat", "chore", "docs", "style", "refactor", "perf", "test", "revert", "ci", "build"], - "Comma separated list of allowed commit types.", - ) - - self.assertListEqual(actual_rule.options_spec, [expected_rule_option]) - self.assertDictEqual(actual_rule.options, {'types': expected_rule_option}) - - # Check contrib-body-requires-signed-off-by contrib rule - actual_rule = config.rules.find_rule("contrib-body-requires-signed-off-by") - self.assertTrue(actual_rule.is_contrib) - - self.assertEqual(str(type(actual_rule)), "<class 'signedoff_by.SignedOffBy'>") - self.assertEqual(actual_rule.id, 'CC1') - self.assertEqual(actual_rule.name, u'contrib-body-requires-signed-off-by') - - # reset value (this is a different code path) - config.set_general_option("contrib", "contrib-body-requires-signed-off-by") - self.assertEqual(actual_rule, config.rules.find_rule("contrib-body-requires-signed-off-by")) - self.assertIsNone(config.rules.find_rule("contrib-title-conventional-commits")) - - # empty value - config.set_general_option("contrib", "") - self.assertListEqual(config.contrib, []) - - def test_contrib_negative(self): - config = LintConfig() - # non-existent contrib rule - with self.assertRaisesMessage(LintConfigError, "No contrib rule with id or name 'föo' found."): - config.contrib = "contrib-title-conventional-commits,föo" - - # UserRuleError, RuleOptionError should be re-raised as LintConfigErrors - side_effects = [rules.UserRuleError("üser-rule"), options.RuleOptionError("rüle-option")] - for side_effect in side_effects: - with patch('gitlint.config.rule_finder.find_rule_classes', side_effect=side_effect): - with self.assertRaisesMessage(LintConfigError, str(side_effect)): - config.contrib = "contrib-title-conventional-commits" - - def test_extra_path(self): - config = LintConfig() - - config.set_general_option("extra-path", self.get_user_rules_path()) - self.assertEqual(config.extra_path, self.get_user_rules_path()) - actual_rule = config.rules.find_rule('UC1') - self.assertTrue(actual_rule.is_user_defined) - self.assertEqual(str(type(actual_rule)), "<class 'my_commit_rules.MyUserCommitRule'>") - self.assertEqual(actual_rule.id, 'UC1') - self.assertEqual(actual_rule.name, u'my-üser-commit-rule') - self.assertEqual(actual_rule.target, None) - expected_rule_option = options.IntOption('violation-count', 1, "Number of violåtions to return") - self.assertListEqual(actual_rule.options_spec, [expected_rule_option]) - self.assertDictEqual(actual_rule.options, {'violation-count': expected_rule_option}) - - # reset value (this is a different code path) - config.set_general_option("extra-path", self.SAMPLES_DIR) - self.assertEqual(config.extra_path, self.SAMPLES_DIR) - self.assertIsNone(config.rules.find_rule("UC1")) - - def test_extra_path_negative(self): - config = LintConfig() - regex = "Option extra-path must be either an existing directory or file (current value: 'föo/bar')" - # incorrect extra_path - with self.assertRaisesMessage(LintConfigError, regex): - config.extra_path = "föo/bar" - - # extra path contains classes with errors - with self.assertRaisesMessage(LintConfigError, - "User-defined rule class 'MyUserLineRule' must have a 'validate' method"): - config.extra_path = self.get_sample_path("user_rules/incorrect_linerule") - - def test_set_general_option_negative(self): - config = LintConfig() - - # Note that we shouldn't test whether we can set unicode because python just doesn't allow unicode attributes - with self.assertRaisesMessage(LintConfigError, "'foo' is not a valid gitlint option"): - config.set_general_option("foo", "bår") - - # try setting _config_path, this is a real attribute of LintConfig, but the code should prevent it from - # being set - with self.assertRaisesMessage(LintConfigError, "'_config_path' is not a valid gitlint option"): - config.set_general_option("_config_path", "bår") - - # invalid verbosity - incorrect_values = [-1, "föo"] - for value in incorrect_values: - expected_msg = f"Option 'verbosity' must be a positive integer (current value: '{value}')" - with self.assertRaisesMessage(LintConfigError, expected_msg): - config.verbosity = value - - incorrect_values = [4] - for value in incorrect_values: - with self.assertRaisesMessage(LintConfigError, "Option 'verbosity' must be set between 0 and 3"): - config.verbosity = value - - # invalid ignore_xxx_commits - ignore_attributes = ["ignore_merge_commits", "ignore_fixup_commits", "ignore_squash_commits", - "ignore_revert_commits"] - incorrect_values = [-1, 4, "föo"] - for attribute in ignore_attributes: - for value in incorrect_values: - option_name = attribute.replace("_", "-") - with self.assertRaisesMessage(LintConfigError, - f"Option '{option_name}' must be either 'true' or 'false'"): - setattr(config, attribute, value) - - # invalid ignore -> not here because ignore is a ListOption which converts everything to a string before - # splitting which means it it will accept just about everything - - # invalid boolean options - for attribute in ['debug', 'staged', 'ignore_stdin', 'fail_without_commits']: - option_name = attribute.replace("_", "-") - with self.assertRaisesMessage(LintConfigError, - f"Option '{option_name}' must be either 'true' or 'false'"): - setattr(config, attribute, "föobar") - - # extra-path has its own negative test - - # invalid target - with self.assertRaisesMessage(LintConfigError, - "Option target must be an existing directory (current value: 'föo/bar')"): - config.target = "föo/bar" - - def test_ignore_independent_from_rules(self): - # Test that the lintconfig rules are not modified when setting config.ignore - # This was different in the past, this test is mostly here to catch regressions - config = LintConfig() - original_rules = config.rules - config.ignore = ["T1", "T2"] - self.assertEqual(config.ignore, ["T1", "T2"]) - self.assertSequenceEqual(config.rules, original_rules) - - def test_config_equality(self): - self.assertEqual(LintConfig(), LintConfig()) - self.assertNotEqual(LintConfig(), LintConfigGenerator()) - - # Ensure LintConfig are not equal if they differ on their attributes - attrs = [("verbosity", 1), ("rules", []), ("ignore_stdin", True), ("debug", True), - ("ignore", ["T1"]), ("staged", True), ("_config_path", self.get_sample_path()), - ("ignore_merge_commits", False), ("ignore_fixup_commits", False), - ("ignore_squash_commits", False), ("ignore_revert_commits", False), - ("extra_path", self.get_sample_path("user_rules")), ("target", self.get_sample_path()), - ("contrib", ["CC1"])] - for attr, val in attrs: - config = LintConfig() - setattr(config, attr, val) - self.assertNotEqual(LintConfig(), config) - - # Other attributes don't matter - config1 = LintConfig() - config2 = LintConfig() - config1.foo = "bår" - self.assertEqual(config1, config2) - config2.foo = "dūr" - self.assertEqual(config1, config2) - - -class LintConfigGeneratorTests(BaseTestCase): - @staticmethod - @patch('gitlint.config.shutil.copyfile') - def test_install_commit_msg_hook_negative(copy): - LintConfigGenerator.generate_config("föo/bar/test") - copy.assert_called_with(GITLINT_CONFIG_TEMPLATE_SRC_PATH, "föo/bar/test") diff --git a/gitlint/tests/config/test_config_builder.py b/gitlint/tests/config/test_config_builder.py deleted file mode 100644 index e0d7f9b..0000000 --- a/gitlint/tests/config/test_config_builder.py +++ /dev/null @@ -1,264 +0,0 @@ -# -*- coding: utf-8 -*- -import copy - -from gitlint.tests.base import BaseTestCase - -from gitlint.config import LintConfig, LintConfigBuilder, LintConfigError - -from gitlint import rules - - -class LintConfigBuilderTests(BaseTestCase): - def test_set_option(self): - config_builder = LintConfigBuilder() - config = config_builder.build() - - # assert some defaults - self.assertEqual(config.get_rule_option('title-max-length', 'line-length'), 72) - self.assertEqual(config.get_rule_option('body-max-line-length', 'line-length'), 80) - self.assertListEqual(config.get_rule_option('title-must-not-contain-word', 'words'), ["WIP"]) - self.assertEqual(config.verbosity, 3) - - # Make some changes and check blueprint - config_builder.set_option('title-max-length', 'line-length', 100) - config_builder.set_option('general', 'verbosity', 2) - config_builder.set_option('title-must-not-contain-word', 'words', ["foo", "bar"]) - expected_blueprint = {'title-must-not-contain-word': {'words': ['foo', 'bar']}, - 'title-max-length': {'line-length': 100}, 'general': {'verbosity': 2}} - self.assertDictEqual(config_builder._config_blueprint, expected_blueprint) - - # Build config and verify that the changes have occurred and no other changes - config = config_builder.build() - self.assertEqual(config.get_rule_option('title-max-length', 'line-length'), 100) - self.assertEqual(config.get_rule_option('body-max-line-length', 'line-length'), 80) # should be unchanged - self.assertListEqual(config.get_rule_option('title-must-not-contain-word', 'words'), ["foo", "bar"]) - self.assertEqual(config.verbosity, 2) - - def test_set_from_commit_ignore_all(self): - config = LintConfig() - original_rules = config.rules - original_rule_ids = [rule.id for rule in original_rules] - - config_builder = LintConfigBuilder() - - # nothing gitlint - config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint\nfoo")) - config = config_builder.build() - self.assertSequenceEqual(config.rules, original_rules) - self.assertListEqual(config.ignore, []) - - # ignore all rules - config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore: all\nfoo")) - config = config_builder.build() - self.assertEqual(config.ignore, original_rule_ids) - - # ignore all rules, no space - config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore:all\nfoo")) - config = config_builder.build() - self.assertEqual(config.ignore, original_rule_ids) - - # ignore all rules, more spacing - config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore: \t all\nfoo")) - config = config_builder.build() - self.assertEqual(config.ignore, original_rule_ids) - - def test_set_from_commit_ignore_specific(self): - # ignore specific rules - config_builder = LintConfigBuilder() - config_builder.set_config_from_commit(self.gitcommit("tëst\ngitlint-ignore: T1, body-hard-tab")) - config = config_builder.build() - self.assertEqual(config.ignore, ["T1", "body-hard-tab"]) - - def test_set_from_config_file(self): - # regular config file load, no problems - config_builder = LintConfigBuilder() - config_builder.set_from_config_file(self.get_sample_path("config/gitlintconfig")) - config = config_builder.build() - - # Do some assertions on the config - self.assertEqual(config.verbosity, 1) - self.assertFalse(config.debug) - self.assertFalse(config.ignore_merge_commits) - self.assertIsNone(config.extra_path) - self.assertEqual(config.ignore, ["title-trailing-whitespace", "B2"]) - - self.assertEqual(config.get_rule_option('title-max-length', 'line-length'), 20) - self.assertEqual(config.get_rule_option('body-max-line-length', 'line-length'), 30) - - def test_set_from_config_file_negative(self): - config_builder = LintConfigBuilder() - - # bad config file load - foo_path = self.get_sample_path("föo") - expected_error_msg = f"Invalid file path: {foo_path}" - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config_builder.set_from_config_file(foo_path) - - # error during file parsing - path = self.get_sample_path("config/no-sections") - expected_error_msg = "File contains no section headers." - # We only match the start of the message here, since the exact message can vary depending on platform - with self.assertRaisesRegex(LintConfigError, expected_error_msg): - config_builder.set_from_config_file(path) - - # non-existing rule - path = self.get_sample_path("config/nonexisting-rule") - config_builder = LintConfigBuilder() - config_builder.set_from_config_file(path) - expected_error_msg = "No such rule 'föobar'" - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config_builder.build() - - # non-existing general option - path = self.get_sample_path("config/nonexisting-general-option") - config_builder = LintConfigBuilder() - config_builder.set_from_config_file(path) - expected_error_msg = "'foo' is not a valid gitlint option" - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config_builder.build() - - # non-existing option - path = self.get_sample_path("config/nonexisting-option") - config_builder = LintConfigBuilder() - config_builder.set_from_config_file(path) - expected_error_msg = "Rule 'title-max-length' has no option 'föobar'" - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config_builder.build() - - # invalid option value - path = self.get_sample_path("config/invalid-option-value") - config_builder = LintConfigBuilder() - config_builder.set_from_config_file(path) - expected_error_msg = "'föo' is not a valid value for option 'title-max-length.line-length'. " + \ - "Option 'line-length' must be a positive integer (current value: 'föo')." - with self.assertRaisesMessage(LintConfigError, expected_error_msg): - config_builder.build() - - def test_set_config_from_string_list(self): - config = LintConfig() - - # change and assert changes - config_builder = LintConfigBuilder() - config_builder.set_config_from_string_list(['general.verbosity=1', 'title-max-length.line-length=60', - 'body-max-line-length.line-length=120', - "title-must-not-contain-word.words=håha"]) - - config = config_builder.build() - self.assertEqual(config.get_rule_option('title-max-length', 'line-length'), 60) - self.assertEqual(config.get_rule_option('body-max-line-length', 'line-length'), 120) - self.assertListEqual(config.get_rule_option('title-must-not-contain-word', 'words'), ["håha"]) - self.assertEqual(config.verbosity, 1) - - def test_set_config_from_string_list_negative(self): - config_builder = LintConfigBuilder() - - # assert error on incorrect rule - this happens at build time - config_builder.set_config_from_string_list(["föo.bar=1"]) - with self.assertRaisesMessage(LintConfigError, "No such rule 'föo'"): - config_builder.build() - - # no equal sign - expected_msg = "'föo.bar' is an invalid configuration option. Use '<rule>.<option>=<value>'" - with self.assertRaisesMessage(LintConfigError, expected_msg): - config_builder.set_config_from_string_list(["föo.bar"]) - - # missing value - expected_msg = "'föo.bar=' is an invalid configuration option. Use '<rule>.<option>=<value>'" - with self.assertRaisesMessage(LintConfigError, expected_msg): - config_builder.set_config_from_string_list(["föo.bar="]) - - # space instead of equal sign - expected_msg = "'föo.bar 1' is an invalid configuration option. Use '<rule>.<option>=<value>'" - with self.assertRaisesMessage(LintConfigError, expected_msg): - config_builder.set_config_from_string_list(["föo.bar 1"]) - - # no period between rule and option names - expected_msg = "'föobar=1' is an invalid configuration option. Use '<rule>.<option>=<value>'" - with self.assertRaisesMessage(LintConfigError, expected_msg): - config_builder.set_config_from_string_list([u'föobar=1']) - - def test_rebuild_config(self): - # normal config build - config_builder = LintConfigBuilder() - config_builder.set_option('general', 'verbosity', 3) - lint_config = config_builder.build() - self.assertEqual(lint_config.verbosity, 3) - - # check that existing config gets overwritten when we pass it to a configbuilder with different options - existing_lintconfig = LintConfig() - existing_lintconfig.verbosity = 2 - lint_config = config_builder.build(existing_lintconfig) - self.assertEqual(lint_config.verbosity, 3) - self.assertEqual(existing_lintconfig.verbosity, 3) - - def test_clone(self): - config_builder = LintConfigBuilder() - config_builder.set_option('general', 'verbosity', 2) - config_builder.set_option('title-max-length', 'line-length', 100) - expected = {'title-max-length': {'line-length': 100}, 'general': {'verbosity': 2}} - self.assertDictEqual(config_builder._config_blueprint, expected) - - # Clone and verify that the blueprint is the same as the original - cloned_builder = config_builder.clone() - self.assertDictEqual(cloned_builder._config_blueprint, expected) - - # Modify the original and make sure we're not modifying the clone (i.e. check that the copy is a deep copy) - config_builder.set_option('title-max-length', 'line-length', 120) - self.assertDictEqual(cloned_builder._config_blueprint, expected) - - def test_named_rules(self): - # Store a copy of the default rules from the config, so we can reference it later - config_builder = LintConfigBuilder() - config = config_builder.build() - default_rules = copy.deepcopy(config.rules) - self.assertEqual(default_rules, config.rules) # deepcopy should be equal - - # Add a named rule by setting an option in the config builder that follows the named rule pattern - # Assert that whitespace in the rule name is stripped - rule_qualifiers = [u'T7:my-extra-rüle', u' T7 : my-extra-rüle ', u'\tT7:\tmy-extra-rüle\t', - u'T7:\t\n \tmy-extra-rüle\t\n\n', "title-match-regex:my-extra-rüle"] - for rule_qualifier in rule_qualifiers: - config_builder = LintConfigBuilder() - config_builder.set_option(rule_qualifier, 'regex', "föo") - - expected_rules = copy.deepcopy(default_rules) - my_rule = rules.TitleRegexMatches({'regex': "föo"}) - my_rule.id = rules.TitleRegexMatches.id + ":my-extra-rüle" - my_rule.name = rules.TitleRegexMatches.name + ":my-extra-rüle" - expected_rules._rules[u'T7:my-extra-rüle'] = my_rule - self.assertEqual(config_builder.build().rules, expected_rules) - - # assert that changing an option on the newly added rule is passed correctly to the RuleCollection - # we try this with all different rule qualifiers to ensure they all are normalized and map - # to the same rule - for other_rule_qualifier in rule_qualifiers: - cb = config_builder.clone() - cb.set_option(other_rule_qualifier, 'regex', other_rule_qualifier + "bōr") - # before setting the expected rule option value correctly, the RuleCollection should be different - self.assertNotEqual(cb.build().rules, expected_rules) - # after setting the option on the expected rule, it should be equal - my_rule.options['regex'].set(other_rule_qualifier + "bōr") - self.assertEqual(cb.build().rules, expected_rules) - my_rule.options['regex'].set("wrong") - - def test_named_rules_negative(self): - # T7 = title-match-regex - # Invalid rule name - for invalid_name in ["", " ", " ", "\t", "\n", "å b", "å:b", "åb:", ":åb"]: - config_builder = LintConfigBuilder() - config_builder.set_option(f"T7:{invalid_name}", 'regex', "tëst") - expected_msg = f"The rule-name part in 'T7:{invalid_name}' cannot contain whitespace, colons or be empty" - with self.assertRaisesMessage(LintConfigError, expected_msg): - config_builder.build() - - # Invalid parent rule name - config_builder = LintConfigBuilder() - config_builder.set_option("Ž123:foöbar", "fåke-option", "fåke-value") - with self.assertRaisesMessage(LintConfigError, "No such rule 'Ž123' (named rule: 'Ž123:foöbar')"): - config_builder.build() - - # Invalid option name (this is the same as with regular rules) - config_builder = LintConfigBuilder() - config_builder.set_option("T7:foöbar", "blå", "my-rëgex") - with self.assertRaisesMessage(LintConfigError, "Rule 'T7:foöbar' has no option 'blå'"): - config_builder.build() diff --git a/gitlint/tests/config/test_config_precedence.py b/gitlint/tests/config/test_config_precedence.py deleted file mode 100644 index aa4de88..0000000 --- a/gitlint/tests/config/test_config_precedence.py +++ /dev/null @@ -1,98 +0,0 @@ -# -*- coding: utf-8 -*- - -from io import StringIO - -from click.testing import CliRunner - -from unittest.mock import patch - -from gitlint.tests.base import BaseTestCase -from gitlint import cli -from gitlint.config import LintConfigBuilder - - -class LintConfigPrecedenceTests(BaseTestCase): - def setUp(self): - self.cli = CliRunner() - - @patch('gitlint.cli.get_stdin_data', return_value="WIP:fö\n\nThis is å test message\n") - def test_config_precedence(self, _): - # TODO(jroovers): this test really only test verbosity, we need to do some refactoring to gitlint.cli - # to more easily test everything - # Test that the config precedence is followed: - # 1. commandline convenience flags - # 2. environment variables - # 3. commandline -c flags - # 4. config file - # 5. default config - config_path = self.get_sample_path("config/gitlintconfig") - - # 1. commandline convenience flags - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["-vvv", "-c", "general.verbosity=2", "--config", config_path]) - self.assertEqual(result.output, "") - self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP:fö\"\n") - - # 2. environment variables - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["-c", "general.verbosity=2", "--config", config_path], - env={"GITLINT_VERBOSITY": "3"}) - self.assertEqual(result.output, "") - self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP:fö\"\n") - - # 3. commandline -c flags - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["-c", "general.verbosity=2", "--config", config_path]) - self.assertEqual(result.output, "") - self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive)\n") - - # 4. config file - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli, ["--config", config_path]) - self.assertEqual(result.output, "") - self.assertEqual(stderr.getvalue(), "1: T5\n") - - # 5. default config - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - result = self.cli.invoke(cli.cli) - self.assertEqual(result.output, "") - self.assertEqual(stderr.getvalue(), "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP:fö\"\n") - - @patch('gitlint.cli.get_stdin_data', return_value="WIP: This is å test") - def test_ignore_precedence(self, get_stdin_data): - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - # --ignore takes precedence over -c general.ignore - result = self.cli.invoke(cli.cli, ["-c", "general.ignore=T5", "--ignore", "B6"]) - self.assertEqual(result.output, "") - self.assertEqual(result.exit_code, 1) - # We still expect the T5 violation, but no B6 violation as --ignore overwrites -c general.ignore - self.assertEqual(stderr.getvalue(), - "1: T5 Title contains the word 'WIP' (case-insensitive): \"WIP: This is å test\"\n") - - # test that we can also still configure a rule that is first ignored but then not - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - get_stdin_data.return_value = "This is å test" - # --ignore takes precedence over -c general.ignore - result = self.cli.invoke(cli.cli, ["-c", "general.ignore=title-max-length", - "-c", "title-max-length.line-length=5", - "--ignore", "B6"]) - self.assertEqual(result.output, "") - self.assertEqual(result.exit_code, 1) - - # We still expect the T1 violation with custom config, - # but no B6 violation as --ignore overwrites -c general.ignore - self.assertEqual(stderr.getvalue(), "1: T1 Title exceeds max length (14>5): \"This is å test\"\n") - - def test_general_option_after_rule_option(self): - # We used to have a bug where we didn't process general options before setting specific options, this would - # lead to errors when e.g.: trying to configure a user rule before the rule class was loaded by extra-path - # This test is here to test for regressions against this. - - config_builder = LintConfigBuilder() - config_builder.set_option(u'my-üser-commit-rule', 'violation-count', 3) - user_rules_path = self.get_sample_path("user_rules") - config_builder.set_option('general', 'extra-path', user_rules_path) - config = config_builder.build() - - self.assertEqual(config.extra_path, user_rules_path) - self.assertEqual(config.get_rule_option(u'my-üser-commit-rule', 'violation-count'), 3) diff --git a/gitlint/tests/config/test_rule_collection.py b/gitlint/tests/config/test_rule_collection.py deleted file mode 100644 index 5a50be0..0000000 --- a/gitlint/tests/config/test_rule_collection.py +++ /dev/null @@ -1,64 +0,0 @@ -# -*- coding: utf-8 -*- - -from collections import OrderedDict -from gitlint import rules -from gitlint.config import RuleCollection -from gitlint.tests.base import BaseTestCase - - -class RuleCollectionTests(BaseTestCase): - - def test_add_rule(self): - collection = RuleCollection() - collection.add_rule(rules.TitleMaxLength, "my-rüle", {"my_attr": "föo", "my_attr2": 123}) - - expected = rules.TitleMaxLength() - expected.id = "my-rüle" - expected.my_attr = "föo" - expected.my_attr2 = 123 - - self.assertEqual(len(collection), 1) - self.assertDictEqual(collection._rules, OrderedDict({"my-rüle": expected})) - # Need to explicitely compare expected attributes as the rule.__eq__ method does not compare these attributes - self.assertEqual(collection._rules[expected.id].my_attr, expected.my_attr) - self.assertEqual(collection._rules[expected.id].my_attr2, expected.my_attr2) - - def test_add_find_rule(self): - collection = RuleCollection() - collection.add_rules([rules.TitleMaxLength, rules.TitleTrailingWhitespace], {"my_attr": "föo"}) - - # find by id - expected = rules.TitleMaxLength() - rule = collection.find_rule('T1') - self.assertEqual(rule, expected) - self.assertEqual(rule.my_attr, "föo") - - # find by name - expected2 = rules.TitleTrailingWhitespace() - rule = collection.find_rule('title-trailing-whitespace') - self.assertEqual(rule, expected2) - self.assertEqual(rule.my_attr, "föo") - - # find non-existing - rule = collection.find_rule(u'föo') - self.assertIsNone(rule) - - def test_delete_rules_by_attr(self): - collection = RuleCollection() - collection.add_rules([rules.TitleMaxLength, rules.TitleTrailingWhitespace], {"foo": "bår"}) - collection.add_rules([rules.BodyHardTab], {"hur": "dûr"}) - - # Assert all rules are there as expected - self.assertEqual(len(collection), 3) - for expected_rule in [rules.TitleMaxLength(), rules.TitleTrailingWhitespace(), rules.BodyHardTab()]: - self.assertEqual(collection.find_rule(expected_rule.id), expected_rule) - - # Delete rules by attr, assert that we still have the right rules in the collection - collection.delete_rules_by_attr("foo", "bår") - self.assertEqual(len(collection), 1) - self.assertIsNone(collection.find_rule(rules.TitleMaxLength.id), None) - self.assertIsNone(collection.find_rule(rules.TitleTrailingWhitespace.id), None) - - found = collection.find_rule(rules.BodyHardTab.id) - self.assertEqual(found, rules.BodyHardTab()) - self.assertEqual(found.hur, "dûr") diff --git a/gitlint/tests/contrib/__init__.py b/gitlint/tests/contrib/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/gitlint/tests/contrib/__init__.py +++ /dev/null diff --git a/gitlint/tests/contrib/rules/__init__.py b/gitlint/tests/contrib/rules/__init__.py deleted file mode 100644 index e69de29..0000000 --- a/gitlint/tests/contrib/rules/__init__.py +++ /dev/null diff --git a/gitlint/tests/contrib/rules/test_conventional_commit.py b/gitlint/tests/contrib/rules/test_conventional_commit.py deleted file mode 100644 index 5da5cd5..0000000 --- a/gitlint/tests/contrib/rules/test_conventional_commit.py +++ /dev/null @@ -1,75 +0,0 @@ - -# -*- 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", "ci", "build"]: - violations = rule.validate(type + ": 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, ci, build", "bår: foo") - violations = rule.validate("bår: foo", None) - self.assertListEqual([expected_violation], violations) - - # assert violation when use strange chars after correct type - expected_violation = RuleViolation("CT1", "Title does not start with one of fix, feat, chore, docs," - " style, refactor, perf, test, revert, ci, build", - "feat_wrong_chars: föo") - violations = rule.validate("feat_wrong_chars: föo", None) - self.assertListEqual([expected_violation], violations) - - # assert violation when use strange chars after correct type - expected_violation = RuleViolation("CT1", "Title does not start with one of fix, feat, chore, docs," - " style, refactor, perf, test, revert, ci, build", - "feat_wrong_chars(scope): föo") - violations = rule.validate("feat_wrong_chars(scope): föo", 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'", "fix föo") - violations = rule.validate("fix föo", None) - self.assertListEqual([expected_violation], violations) - - # assert no violation when use ! for breaking changes without scope - violations = rule.validate("feat!: föo", None) - self.assertListEqual([], violations) - - # assert no violation when use ! for breaking changes with scope - violations = rule.validate("fix(scope)!: föo", None) - self.assertListEqual([], violations) - - # assert no violation when adding new type - rule = ConventionalCommit({'types': ["föo", "bär"]}) - for typ in ["föo", "bär"]: - violations = rule.validate(typ + ": hür dur", None) - self.assertListEqual([], violations) - - # assert violation when using incorrect type when types have been reconfigured - violations = rule.validate("fix: hür dur", None) - expected_violation = RuleViolation("CT1", "Title does not start with one of föo, bär", "fix: hür dur") - self.assertListEqual([expected_violation], violations) - - # assert no violation when adding new type named with numbers - rule = ConventionalCommit({'types': ["föo123", "123bär"]}) - for typ in ["föo123", "123bär"]: - violations = rule.validate(typ + ": hür dur", None) - self.assertListEqual([], violations) diff --git a/gitlint/tests/contrib/rules/test_signedoff_by.py b/gitlint/tests/contrib/rules/test_signedoff_by.py deleted file mode 100644 index 0369cdc..0000000 --- a/gitlint/tests/contrib/rules/test_signedoff_by.py +++ /dev/null @@ -1,32 +0,0 @@ - -# -*- 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("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("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("Signed-off-by\n\nFöobar")) - self.assertListEqual(violations, [expected_violation]) diff --git a/gitlint/tests/contrib/test_contrib_rules.py b/gitlint/tests/contrib/test_contrib_rules.py deleted file mode 100644 index 8ab6539..0000000 --- a/gitlint/tests/contrib/test_contrib_rules.py +++ /dev/null @@ -1,69 +0,0 @@ -# -*- coding: utf-8 -*- -import os - -from gitlint.tests.base import BaseTestCase -from gitlint.contrib import rules as contrib_rules -from gitlint.tests.contrib import rules as contrib_tests -from gitlint import rule_finder, rules - - -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 = "test_" + filename - error_msg = "Every Contrib Rule must have associated tests. " + \ - f"Expected test file {os.path.join(contrib_tests_dir, expected_test_file)} not found." - 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/expected/cli/test_cli/test_contrib_1 b/gitlint/tests/expected/cli/test_cli/test_contrib_1 deleted file mode 100644 index b95433b..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_contrib_1 +++ /dev/null @@ -1,2 +0,0 @@ -1: CC1 Body does not contain a 'Signed-off-by' line -1: CT1 Title does not follow ConventionalCommits.org format 'type(optional-scope): description': "Test tïtle" diff --git a/gitlint/tests/expected/cli/test_cli/test_debug_1 b/gitlint/tests/expected/cli/test_cli/test_debug_1 deleted file mode 100644 index fcd5d7e..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_debug_1 +++ /dev/null @@ -1,124 +0,0 @@ -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 DEFAULT_ENCODING: {DEFAULT_ENCODING} -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 -fail-without-commits: False -verbosity: 1 -debug: True -target: {target} -[RULES] - I1: ignore-by-title - ignore=all - regex=None - I2: ignore-by-body - ignore=all - regex=None - I3: ignore-body-lines - regex=None - I4: ignore-by-author-name - 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=None - T8: title-min-length - min-length=5 - 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= - B8: body-match-regex - regex=None - 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.git ('rev-list', 'foo...bar') -DEBUG: gitlint.cli Linting 3 commit(s) -DEBUG: gitlint.git ('log', '6f29bf81a8322a04071bb794666e48c443a90360', '-1', '--pretty=%aN%x00%aE%x00%ai%x00%P%n%B') -DEBUG: gitlint.git ('config', '--get', 'core.commentchar') -DEBUG: gitlint.lint Linting commit 6f29bf81a8322a04071bb794666e48c443a90360 -DEBUG: gitlint.git ('branch', '--contains', '6f29bf81a8322a04071bb794666e48c443a90360') -DEBUG: gitlint.git ('diff-tree', '--no-commit-id', '--name-only', '-r', '--root', '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.git ('log', '25053ccec5e28e1bb8f7551fdbb5ab213ada2401', '-1', '--pretty=%aN%x00%aE%x00%ai%x00%P%n%B') -DEBUG: gitlint.lint Linting commit 25053ccec5e28e1bb8f7551fdbb5ab213ada2401 -DEBUG: gitlint.git ('branch', '--contains', '25053ccec5e28e1bb8f7551fdbb5ab213ada2401') -DEBUG: gitlint.git ('diff-tree', '--no-commit-id', '--name-only', '-r', '--root', '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.git ('log', '4da2656b0dadc76c7ee3fd0243a96cb64007f125', '-1', '--pretty=%aN%x00%aE%x00%ai%x00%P%n%B') -DEBUG: gitlint.lint Linting commit 4da2656b0dadc76c7ee3fd0243a96cb64007f125 -DEBUG: gitlint.git ('branch', '--contains', '4da2656b0dadc76c7ee3fd0243a96cb64007f125') -DEBUG: gitlint.git ('diff-tree', '--no-commit-id', '--name-only', '-r', '--root', '4da2656b0dadc76c7ee3fd0243a96cb64007f125') -DEBUG: gitlint.lint Commit Object ---- Commit Message ---- -föobar -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/cli/test_cli/test_input_stream_1 b/gitlint/tests/expected/cli/test_cli/test_input_stream_1 deleted file mode 100644 index 4326729..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_input_stream_1 +++ /dev/null @@ -1,3 +0,0 @@ -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/cli/test_cli/test_input_stream_debug_1 b/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_1 deleted file mode 100644 index 4326729..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_1 +++ /dev/null @@ -1,3 +0,0 @@ -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/cli/test_cli/test_input_stream_debug_2 b/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_2 deleted file mode 100644 index 7c94b45..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_2 +++ /dev/null @@ -1,83 +0,0 @@ -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 DEFAULT_ENCODING: {DEFAULT_ENCODING} -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 -fail-without-commits: False -verbosity: 3 -debug: True -target: {target} -[RULES] - I1: ignore-by-title - ignore=all - regex=None - I2: ignore-by-body - ignore=all - regex=None - I3: ignore-body-lines - regex=None - I4: ignore-by-author-name - 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=None - T8: title-min-length - min-length=5 - 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= - B8: body-match-regex - regex=None - 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.git ('config', '--get', 'core.commentchar') -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/cli/test_cli/test_lint_commit_1 b/gitlint/tests/expected/cli/test_cli/test_lint_commit_1 deleted file mode 100644 index b9f0742..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_lint_commit_1 +++ /dev/null @@ -1,2 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: commït-title1" -3: B5 Body message is too short (12<20): "commït-body1" diff --git a/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_1 b/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_1 deleted file mode 100644 index be3288b..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_1 +++ /dev/null @@ -1,8 +0,0 @@ -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/cli/test_cli/test_lint_multiple_commits_config_1 b/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_config_1 deleted file mode 100644 index 1bf0503..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_config_1 +++ /dev/null @@ -1,6 +0,0 @@ -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/cli/test_cli/test_lint_staged_msg_filename_1 b/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_1 deleted file mode 100644 index 9a9091b..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_1 +++ /dev/null @@ -1,2 +0,0 @@ -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/cli/test_cli/test_lint_staged_msg_filename_2 b/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_2 deleted file mode 100644 index f37ffa0..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_2 +++ /dev/null @@ -1,86 +0,0 @@ -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 DEFAULT_ENCODING: {DEFAULT_ENCODING} -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 -fail-without-commits: False -verbosity: 3 -debug: True -target: {target} -[RULES] - I1: ignore-by-title - ignore=all - regex=None - I2: ignore-by-body - ignore=all - regex=None - I3: ignore-body-lines - regex=None - I4: ignore-by-author-name - 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=None - T8: title-min-length - min-length=5 - 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= - B8: body-match-regex - regex=None - M1: author-valid-email - regex=[^@ ]+@[^@ ]+\.[^@ ]+ - -DEBUG: gitlint.cli Fetching additional meta-data from staged commit -DEBUG: gitlint.cli Using --msg-filename. -DEBUG: gitlint.git ('config', '--get', 'core.commentchar') -DEBUG: gitlint.cli Linting 1 commit(s) -DEBUG: gitlint.lint Linting commit [SHA UNKNOWN] -DEBUG: gitlint.git ('config', '--get', 'user.name') -DEBUG: gitlint.git ('config', '--get', 'user.email') -DEBUG: gitlint.git ('rev-parse', '--abbrev-ref', 'HEAD') -DEBUG: gitlint.git ('diff', '--staged', '--name-only', '-r') -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/cli/test_cli/test_lint_staged_stdin_1 b/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_1 deleted file mode 100644 index 4326729..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_1 +++ /dev/null @@ -1,3 +0,0 @@ -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/cli/test_cli/test_lint_staged_stdin_2 b/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_2 deleted file mode 100644 index 1d1020a..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_2 +++ /dev/null @@ -1,88 +0,0 @@ -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 DEFAULT_ENCODING: {DEFAULT_ENCODING} -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 -fail-without-commits: False -verbosity: 3 -debug: True -target: {target} -[RULES] - I1: ignore-by-title - ignore=all - regex=None - I2: ignore-by-body - ignore=all - regex=None - I3: ignore-body-lines - regex=None - I4: ignore-by-author-name - 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=None - T8: title-min-length - min-length=5 - 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= - B8: body-match-regex - regex=None - 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.git ('config', '--get', 'core.commentchar') -DEBUG: gitlint.cli Linting 1 commit(s) -DEBUG: gitlint.lint Linting commit [SHA UNKNOWN] -DEBUG: gitlint.git ('config', '--get', 'user.name') -DEBUG: gitlint.git ('config', '--get', 'user.email') -DEBUG: gitlint.git ('rev-parse', '--abbrev-ref', 'HEAD') -DEBUG: gitlint.git ('diff', '--staged', '--name-only', '-r') -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/expected/cli/test_cli/test_named_rules_1 b/gitlint/tests/expected/cli/test_cli/test_named_rules_1 deleted file mode 100644 index a581d05..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_named_rules_1 +++ /dev/null @@ -1,4 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tëst tïtle" -1: T5:even-more-wörds Title contains the word 'tïtle' (case-insensitive): "WIP: tëst tïtle" -1: T5:extra-wörds Title contains the word 'tëst' (case-insensitive): "WIP: tëst tïtle" -3: B6 Body message is missing diff --git a/gitlint/tests/expected/cli/test_cli/test_named_rules_2 b/gitlint/tests/expected/cli/test_cli/test_named_rules_2 deleted file mode 100644 index 83c4bf2..0000000 --- a/gitlint/tests/expected/cli/test_cli/test_named_rules_2 +++ /dev/null @@ -1,86 +0,0 @@ -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 DEFAULT_ENCODING: {DEFAULT_ENCODING} -DEBUG: gitlint.cli Configuration -config-path: {config_path} -[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 -fail-without-commits: False -verbosity: 3 -debug: True -target: {target} -[RULES] - I1: ignore-by-title - ignore=all - regex=None - I2: ignore-by-body - ignore=all - regex=None - I3: ignore-body-lines - regex=None - I4: ignore-by-author-name - 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,bögus - T7: title-match-regex - regex=None - T8: title-min-length - min-length=5 - 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= - B8: body-match-regex - regex=None - M1: author-valid-email - regex=[^@ ]+@[^@ ]+\.[^@ ]+ - T5:extra-wörds: title-must-not-contain-word:extra-wörds - words=hür,tëst - T5:even-more-wörds: title-must-not-contain-word:even-more-wörds - words=hür,tïtle - -DEBUG: gitlint.cli Stdin data: 'WIP: tëst tïtle' -DEBUG: gitlint.cli Stdin detected and not ignored. Using as input. -DEBUG: gitlint.git ('config', '--get', 'core.commentchar') -DEBUG: gitlint.cli Linting 1 commit(s) -DEBUG: gitlint.lint Linting commit [SHA UNKNOWN] -DEBUG: gitlint.lint Commit Object ---- Commit Message ---- -WIP: tëst 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 = 4
\ No newline at end of file diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stderr b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stderr deleted file mode 100644 index cfacd42..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stderr +++ /dev/null @@ -1,2 +0,0 @@ -1: T1 Title exceeds max length (27>5): "WIP: Test hook config tïtle" -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: Test hook config tïtle" diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stdout deleted file mode 100644 index bee014b..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stdout +++ /dev/null @@ -1,5 +0,0 @@ -gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] -Aborted! diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stderr b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stderr deleted file mode 100644 index 3eb8fca..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stderr +++ /dev/null @@ -1,6 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "{commit_msg}" -3: B6 Body message is missing -1: T5 Title contains the word 'WIP' (case-insensitive): "{commit_msg}" -3: B6 Body message is missing -1: T5 Title contains the word 'WIP' (case-insensitive): "{commit_msg}" -3: B6 Body message is missing diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stdout deleted file mode 100644 index b57a35a..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stdout +++ /dev/null @@ -1,14 +0,0 @@ -gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] Commit aborted. -Your commit message: ------------------------------------------------ -{commit_msg} ------------------------------------------------ diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stderr b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stderr deleted file mode 100644 index 11c3cd8..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stderr +++ /dev/null @@ -1,2 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: commït-title" -3: B5 Body message is too short (11<20): "commït-body" diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stdout deleted file mode 100644 index 0b8e90e..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stdout +++ /dev/null @@ -1,4 +0,0 @@ -gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] Editing only possible when --msg-filename is specified. diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stderr b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stderr deleted file mode 100644 index 6d0c9cf..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stderr +++ /dev/null @@ -1,2 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: höok no" -3: B6 Body message is missing diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stdout deleted file mode 100644 index 98a83b1..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stdout +++ /dev/null @@ -1,8 +0,0 @@ -gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] Commit aborted. -Your commit message: ------------------------------------------------ -WIP: höok no ------------------------------------------------ diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stderr b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stderr deleted file mode 100644 index a8d8760..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stderr +++ /dev/null @@ -1,2 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle" -3: B6 Body message is missing diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stdout deleted file mode 100644 index bee014b..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stdout +++ /dev/null @@ -1,5 +0,0 @@ -gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] -Aborted! diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_no_violations_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_no_violations_1_stdout deleted file mode 100644 index da1ef0b..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_no_violations_1_stdout +++ /dev/null @@ -1,2 +0,0 @@ -gitlint: checking commit message... -gitlint: OK (no violations in commit message) diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stderr b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stderr deleted file mode 100644 index 1404f4a..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stderr +++ /dev/null @@ -1,2 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: Test hook stdin tïtle" -3: B6 Body message is missing diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stdout deleted file mode 100644 index bee014b..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stdout +++ /dev/null @@ -1,5 +0,0 @@ -gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] -Aborted! diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stderr b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stderr deleted file mode 100644 index da6f874..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stderr +++ /dev/null @@ -1,2 +0,0 @@ -1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: höok yes" -3: B6 Body message is missing diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stdout b/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stdout deleted file mode 100644 index 0414712..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stdout +++ /dev/null @@ -1,4 +0,0 @@ -gitlint: checking commit message... ------------------------------------------------ -gitlint: Your commit message contains violations. -Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)]
\ No newline at end of file diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_1 b/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_1 deleted file mode 100644 index 9082830..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_1 +++ /dev/null @@ -1,2 +0,0 @@ -gitlint: checking commit message... -{git_repo} is not a git repository. diff --git a/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_2 b/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_2 deleted file mode 100644 index bafbf29..0000000 --- a/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_2 +++ /dev/null @@ -1,2 +0,0 @@ -gitlint: checking commit message... -Error: The 'staged' option (--staged) can only be used when using '--msg-filename' or when piping data to gitlint via stdin. diff --git a/gitlint/tests/git/test_git.py b/gitlint/tests/git/test_git.py deleted file mode 100644 index 7b9b7c6..0000000 --- a/gitlint/tests/git/test_git.py +++ /dev/null @@ -1,108 +0,0 @@ -# -*- coding: utf-8 -*- -import os - -from unittest.mock import patch - -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': "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.assertRaisesMessage(GitNotInstalledError, expected_msg): - GitContext.from_local_repository("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.assertRaisesMessage(GitContextError, "fåke/path is not a git repository."): - GitContext.from_local_repository("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 = f"An error occurred while executing 'git log -1 --pretty=%H': {err}" - with self.assertRaisesMessage(GitContextError, expected_msg): - GitContext.from_local_repository("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 = "Current branch has no commits. Gitlint requires at least one commit to function." - with self.assertRaisesMessage(GitContextError, expected_msg): - GitContext.from_local_repository("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 = [ - "#\n", # git config --get core.commentchar - ErrorReturnCode("rev-parse --abbrev-ref HEAD", b"", err) - ] - - with self.assertRaisesMessage(GitContextError, expected_msg): - context = GitContext.from_commit_msg("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 = "ä" - self.assertEqual(git_commentchar(), "ä") - - git.return_value = ';\n' - self.assertEqual(git_commentchar(os.path.join("/föo", "bar")), ';') - - git.assert_called_with("config", "--get", "core.commentchar", _ok_code=[0, 1], - _cwd=os.path.join("/föo", "bar")) - - @patch("gitlint.git._git") - def test_git_hooks_dir(self, git): - hooks_dir = os.path.join("föo", ".git", "hooks") - git.return_value = hooks_dir + "\n" - self.assertEqual(git_hooks_dir("/blä"), os.path.abspath(os.path.join("/blä", hooks_dir))) - - git.assert_called_once_with("rev-parse", "--git-path", "hooks", _cwd="/blä") diff --git a/gitlint/tests/git/test_git_commit.py b/gitlint/tests/git/test_git_commit.py deleted file mode 100644 index 02c5795..0000000 --- a/gitlint/tests/git/test_git_commit.py +++ /dev/null @@ -1,619 +0,0 @@ -# -*- coding: utf-8 -*- -import copy -import datetime - -import dateutil - -import arrow - -from unittest.mock import patch, call - -from gitlint.tests.base import BaseTestCase -from gitlint.git import GitContext, GitCommit, GitContextError, LocalGitCommit, StagedLocalGitCommit, GitCommitMessage -from gitlint.shell import ErrorReturnCode - - -class GitCommitTests(BaseTestCase): - - # Expected special_args passed to 'sh' - expected_sh_special_args = { - '_tty_out': False, - '_cwd': "fåke/path" - } - - @patch('gitlint.git.sh') - def test_get_latest_commit(self, sh): - sample_sha = "d8ac47e9f2923c7f22d8668e3a1ed04eb4cdbca9" - - sh.git.side_effect = [ - sample_sha, - "test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "cömmit-title\n\ncömmit-body", - "#", # git config --get core.commentchar - "file1.txt\npåth/to/file2.txt\n", - "foöbar\n* hürdur\n" - ] - - context = GitContext.from_local_repository("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, "cömmit-title") - self.assertEqual(last_commit.message.body, ["", "cömmit-body"]) - self.assertEqual(last_commit.author_name, "test åuthor") - self.assertEqual(last_commit.author_email, "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, ["å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", "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, ["foöbar", "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_refspec(self, sh): - sample_refspec = "åbc123..def456" - sample_sha = "åbc123" - - sh.git.side_effect = [ - sample_sha, # git rev-list <sample_refspec> - "test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "cömmit-title\n\ncömmit-body", - "#", # git config --get core.commentchar - "file1.txt\npåth/to/file2.txt\n", - "foöbar\n* hürdur\n" - ] - - context = GitContext.from_local_repository("fåke/path", refspec=sample_refspec) - # assert that commit info was read using git command - expected_calls = [ - call("rev-list", sample_refspec, **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, "cömmit-title") - self.assertEqual(last_commit.message.body, ["", "cömmit-body"]) - self.assertEqual(last_commit.author_name, "test åuthor") - self.assertEqual(last_commit.author_email, "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, ["å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", "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, ["foöbar", "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_commit_hash(self, sh): - sample_hash = "åbc123" - - sh.git.side_effect = [ - sample_hash, # git log -1 <sample_hash> - "test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - "cömmit-title\n\ncömmit-body", - "#", # git config --get core.commentchar - "file1.txt\npåth/to/file2.txt\n", - "foöbar\n* hürdur\n" - ] - - context = GitContext.from_local_repository("fåke/path", commit_hash=sample_hash) - # assert that commit info was read using git command - expected_calls = [ - call("log", "-1", sample_hash, "--pretty=%H", **self.expected_sh_special_args), - call("log", sample_hash, "-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_hash, - **self.expected_sh_special_args), - call('branch', '--contains', sample_hash, **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_hash) - self.assertEqual(last_commit.message.title, "cömmit-title") - self.assertEqual(last_commit.message.body, ["", "cömmit-body"]) - self.assertEqual(last_commit.author_name, "test åuthor") - self.assertEqual(last_commit.author_email, "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, ["å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", "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, ["foöbar", "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, - "test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc def\n" - "Merge \"foo bår commit\"", - "#", # git config --get core.commentchar - "file1.txt\npåth/to/file2.txt\n", - "foöbar\n* hürdur\n" - ] - - context = GitContext.from_local_repository("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, "Merge \"foo bår commit\"") - self.assertEqual(last_commit.message.body, []) - self.assertEqual(last_commit.author_name, "test åuthor") - self.assertEqual(last_commit.author_email, "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, ["å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", "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, ["foöbar", "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, - "test åuthor\x00test-emåil@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" - f"{commit_type}! \"foo bår commit\"", - "#", # git config --get core.commentchar - "file1.txt\npåth/to/file2.txt\n", - "foöbar\n* hürdur\n" - ] - - context = GitContext.from_local_repository("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, f"{commit_type}! \"foo bår commit\"") - self.assertEqual(last_commit.message.body, []) - self.assertEqual(last_commit.author_name, "test åuthor") - self.assertEqual(last_commit.author_email, "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, ["å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", "påth/to/file2.txt"]) - - self.assertListEqual(last_commit.changed_files, ["file1.txt", "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, ["foöbar", "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 = "#" - gitcontext = GitContext.from_commit_msg(self.get_sample("commit_message/sample1")) - - expected_title = "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.", - "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 + ( - "\n# This is a cömmented line\n" - "# ------------------------ >8 ------------------------\n" - "# Anything after this line should be cleaned up\n" - "# this line appears on `git commit -v` command\n" - "diff --git a/gitlint/tests/samples/commit_message/sample1 " - "b/gitlint/tests/samples/commit_message/sample1\n" - "index 82dbe7f..ae71a14 100644\n" - "--- a/gitlint/tests/samples/commit_message/sample1\n" - "+++ b/gitlint/tests/samples/commit_message/sample1\n" - "@@ -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, "Just a title contåining WIP") - self.assertEqual(commit.message.body, []) - self.assertEqual(commit.message.full, "Just a title contåining WIP") - self.assertEqual(commit.message.original, "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 = "#" - gitcontext = GitContext.from_commit_msg("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, "Tïtle") - self.assertEqual(commit.message.body, ["", "Bödy 1", "Body 2"]) - self.assertEqual(commit.message.full, "Tïtle\n\nBödy 1\nBody 2") - self.assertEqual(commit.message.original, "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 = f"{commit_type}! Test message" - 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 = [ - "#", # git config --get core.commentchar - "test åuthor\n", # git config --get user.name - "test-emåil@foo.com\n", # git config --get user.email - "my-brånch\n", # git rev-parse --abbrev-ref HEAD - "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("fixup! Foōbar 123\n\ncömmit-body\n", "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, "fixup! Foōbar 123") - self.assertEqual(last_commit.message.body, ["", "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, "test åuthor") - self.assertListEqual(sh.git.mock_calls, expected_calls[0:2]) - - self.assertEqual(last_commit.author_email, "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, ["my-brånch"]) - self.assertListEqual(sh.git.mock_calls, expected_calls[0:4]) - - self.assertListEqual(last_commit.changed_files, ["file1.txt", "påth/to/file2.txt"]) - self.assertListEqual(sh.git.mock_calls, expected_calls[0:5]) - - @patch('gitlint.git.sh') - def test_staged_commit_with_missing_username(self, sh): - # StagedLocalGitCommit() - - sh.git.side_effect = [ - "#", # git config --get core.commentchar - ErrorReturnCode('git config --get user.name', b"", b""), - ] - - expected_msg = "Missing git configuration: please set user.name" - with self.assertRaisesMessage(GitContextError, expected_msg): - ctx = GitContext.from_staged_commit("Foōbar 123\n\ncömmit-body\n", "fåke/path") - [str(commit) for commit in ctx.commits] - - @patch('gitlint.git.sh') - def test_staged_commit_with_missing_email(self, sh): - # StagedLocalGitCommit() - - sh.git.side_effect = [ - "#", # git config --get core.commentchar - "test åuthor\n", # git config --get user.name - ErrorReturnCode('git config --get user.name', b"", b""), - ] - - expected_msg = "Missing git configuration: please set user.email" - with self.assertRaisesMessage(GitContextError, expected_msg): - ctx = GitContext.from_staged_commit("Foōbar 123\n\ncömmit-body\n", "fåke/path") - [str(commit) for commit in ctx.commits] - - def test_gitcommitmessage_equality(self): - commit_message1 = GitCommitMessage(GitContext(), "tëst\n\nfoo", "tëst\n\nfoo", "tēst", ["", "föo"]) - attrs = ['original', 'full', 'title', 'body'] - self.object_equality_test(commit_message1, attrs, {"context": commit_message1.context}) - - @patch("gitlint.git._git") - def test_gitcommit_equality(self, git): - # git will be called to setup the context (commentchar and current_branch), just return the same value - # This only matters to test gitcontext equality, not gitcommit equality - git.return_value = "foöbar" - - # Test simple equality case - now = datetime.datetime.utcnow() - context1 = GitContext() - commit_message1 = GitCommitMessage(context1, "tëst\n\nfoo", "tëst\n\nfoo", "tēst", ["", "föo"]) - commit1 = GitCommit(context1, commit_message1, "shä", now, "Jöhn Smith", "jöhn.smith@test.com", None, - ["föo/bar"], ["brånch1", "brånch2"]) - context1.commits = [commit1] - - context2 = GitContext() - commit_message2 = GitCommitMessage(context2, "tëst\n\nfoo", "tëst\n\nfoo", "tēst", ["", "föo"]) - commit2 = GitCommit(context2, commit_message1, "shä", now, "Jöhn Smith", "jöhn.smith@test.com", None, - ["föo/bar"], ["brånch1", "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': "Merge: foöbar", 'is_fixup_commit': "fixup! foöbar", - 'is_squash_commit': "squash! foöbar", 'is_revert_commit': "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, "foöbar") - self.assertNotEqual(clone1, clone2) - - @patch("gitlint.git.git_commentchar") - def test_commit_msg_custom_commentchar(self, patched): - patched.return_value = "ä" - context = GitContext() - message = GitCommitMessage.from_full_message(context, "Tïtle\n\nBödy 1\näCömment\nBody 2") - - self.assertEqual(message.title, "Tïtle") - self.assertEqual(message.body, ["", "Bödy 1", "Body 2"]) - self.assertEqual(message.full, "Tïtle\n\nBödy 1\nBody 2") - self.assertEqual(message.original, "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 deleted file mode 100644 index bb05236..0000000 --- a/gitlint/tests/git/test_git_context.py +++ /dev/null @@ -1,84 +0,0 @@ -# -*- coding: utf-8 -*- - -from unittest.mock import patch, call - -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': "fåke/path" - } - - @patch('gitlint.git.sh') - def test_gitcontext(self, sh): - - sh.git.side_effect = [ - "#", # git config --get core.commentchar - "\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("fåke/path") - self.assertEqual(sh.git.mock_calls, []) - - # gitcontext.comment_branch - self.assertEqual(context.commentchar, "#") - self.assertEqual(sh.git.mock_calls, expected_calls[0:1]) - - # gitcontext.current_branch - self.assertEqual(context.current_branch, "foöbar") - self.assertEqual(sh.git.mock_calls, expected_calls) - - @patch('gitlint.git.sh') - def test_gitcontext_equality(self, sh): - - sh.git.side_effect = [ - "û\n", # context1: git config --get core.commentchar - "û\n", # context2: git config --get core.commentchar - "my-brånch\n", # context1: git rev-parse --abbrev-ref HEAD - "my-brånch\n", # context2: git rev-parse --abbrev-ref HEAD - ] - - context1 = GitContext("fåke/path") - context1.commits = ["fōo", "bår"] # we don't need real commits to check for equality - - context2 = GitContext("fåke/path") - context2.commits = ["fōo", "bår"] - self.assertEqual(context1, context2) - - # INEQUALITY - # Different commits - context2.commits = ["hür", "dür"] - self.assertNotEqual(context1, context2) - - # Different repository_path - context2.commits = context1.commits - context2.repository_path = "ōther/path" - self.assertNotEqual(context1, context2) - - # Different comment_char - context3 = GitContext("fåke/path") - context3.commits = ["fōo", "bår"] - sh.git.side_effect = ([ - "ç\n", # context3: git config --get core.commentchar - "my-brånch\n" # context3: git rev-parse --abbrev-ref HEAD - ]) - self.assertNotEqual(context1, context3) - - # Different current_branch - context4 = GitContext("fåke/path") - context4.commits = ["fōo", "bår"] - sh.git.side_effect = ([ - "û\n", # context4: git config --get core.commentchar - "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 deleted file mode 100644 index e69de29..0000000 --- a/gitlint/tests/rules/__init__.py +++ /dev/null diff --git a/gitlint/tests/rules/test_body_rules.py b/gitlint/tests/rules/test_body_rules.py deleted file mode 100644 index 812c74a..0000000 --- a/gitlint/tests/rules/test_body_rules.py +++ /dev/null @@ -1,236 +0,0 @@ -# -*- 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("å" * 80, None) - self.assertIsNone(violation) - - # assert error on line length > 80 - expected_violation = rules.RuleViolation("B1", "Line exceeds max length (81>80)", "å" * 81) - violations = rule.validate("å" * 81, None) - self.assertListEqual(violations, [expected_violation]) - - # set line length to 120, and check no violation on length 73 - rule = rules.BodyMaxLineLength({'line-length': 120}) - violations = rule.validate("å" * 73, None) - self.assertIsNone(violations) - - # assert raise on 121 - expected_violation = rules.RuleViolation("B1", "Line exceeds max length (121>120)", "å" * 121) - violations = rule.validate("å" * 121, None) - self.assertListEqual(violations, [expected_violation]) - - def test_trailing_whitespace(self): - rule = rules.BodyTrailingWhitespace() - - # assert no error - violations = rule.validate("å", None) - self.assertIsNone(violations) - - # trailing space - expected_violation = rules.RuleViolation("B2", "Line has trailing whitespace", "å ") - violations = rule.validate("å ", None) - self.assertListEqual(violations, [expected_violation]) - - # trailing tab - expected_violation = rules.RuleViolation("B2", "Line has trailing whitespace", "å\t") - violations = rule.validate("å\t", None) - self.assertListEqual(violations, [expected_violation]) - - def test_hard_tabs(self): - rule = rules.BodyHardTab() - - # assert no error - violations = rule.validate("This is ã test", None) - self.assertIsNone(violations) - - # contains hard tab - expected_violation = rules.RuleViolation("B3", "Line contains hard tab characters (\\t)", "This is å\ttest") - violations = rule.validate("This is å\ttest", None) - self.assertListEqual(violations, [expected_violation]) - - def test_body_first_line_empty(self): - rule = rules.BodyFirstLineEmpty() - - # assert no error - commit = self.gitcommit("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", "nöt empty", 2) - - commit = self.gitcommit("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("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)", "töoshort", 3) - - commit = self.gitcommit("Tïtle\n\ntöoshort\n") - violations = rule.validate(commit) - self.assertListEqual(violations, [expected_violation]) - - # assert error - short across multiple lines - expected_violation = rules.RuleViolation("B5", "Body message is too short (11<20)", "secöndthïrd", 3) - commit = self.gitcommit("Tïtle\n\nsecönd\nthïrd\n") - violations = rule.validate(commit) - self.assertListEqual(violations, [expected_violation]) - - # set line length to 120, and check violation on length 21 - expected_violation = rules.RuleViolation("B5", "Body message is too short (21<120)", "å" * 21, 3) - - rule = rules.BodyMinLength({'min-length': 120}) - commit = self.gitcommit("Title\n\n{0}\n".format("å" * 21)) # pylint: disable=consider-using-f-string - 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("Tïtle\n\n{0}\n".format("å" * 8)) # pylint: disable=consider-using-f-string - violations = rule.validate(commit) - self.assertIsNone(violations) - - def test_body_missing(self): - rule = rules.BodyMissing() - - # assert no error - body is present - commit = self.gitcommit("Tïtle\n\nThis ïs the first body line\n") - violations = rule.validate(commit) - self.assertIsNone(violations) - - # body is too short - expected_violation = rules.RuleViolation("B6", "Body message is missing", None, 3) - - commit = self.gitcommit("Tïtle\n") - violations = rule.validate(commit) - self.assertListEqual(violations, [expected_violation]) - - def test_body_missing_multiple_empty_new_lines(self): - rule = rules.BodyMissing() - - # body is too short - expected_violation = rules.RuleViolation("B6", "Body message is missing", None, 3) - - commit = self.gitcommit("Tïtle\n\n\n\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("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("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': "bar.txt,föo/test.py"}) - commit = self.gitcommit("This is a test\n\nHere is a mention of föo/test.py") - violations = rule.validate(commit) - self.assertIsNone(violations) - - # assert no error if a file has changed and is mentioned - commit = self.gitcommit("This is a test\n\nHere is a mention of föo/test.py", ["föo/test.py"]) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # assert no error if multiple files have changed and are mentioned - commit_msg = "This is a test\n\nHere is a mention of föo/test.py\nAnd here is a mention of bar.txt" - commit = self.gitcommit(commit_msg, ["föo/test.py", "bar.txt"]) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # assert error if file has changed and is not mentioned - commit_msg = "This is a test\n\nHere is å mention of\nAnd here is a mention of bar.txt" - commit = self.gitcommit(commit_msg, ["föo/test.py", "bar.txt"]) - violations = rule.validate(commit) - expected_violation = rules.RuleViolation("B7", "Body does not mention changed file 'föo/test.py'", None, 4) - self.assertEqual([expected_violation], violations) - - # assert multiple errors if multiple files have changed and are not mentioned - commit_msg = "This is å test\n\nHere is a mention of\nAnd here is a mention of" - commit = self.gitcommit(commit_msg, ["föo/test.py", "bar.txt"]) - violations = rule.validate(commit) - expected_violation_2 = rules.RuleViolation("B7", "Body does not mention changed file 'bar.txt'", None, 4) - self.assertEqual([expected_violation_2, expected_violation], violations) - - def test_body_match_regex(self): - # We intentionally add 2 newlines at the end of our commit message as that's how git will pass the - # message. This way we also test that the rule strips off the last line. - commit = self.gitcommit("US1234: åbc\nIgnored\nBödy\nFöo\nMy-Commit-Tag: föo\n\n") - - # assert no violation on default regex (=everything allowed) - rule = rules.BodyRegexMatches() - violations = rule.validate(commit) - self.assertIsNone(violations) - - # assert no violation on matching regex - # (also note that first body line - in between title and rest of body - is ignored) - rule = rules.BodyRegexMatches({'regex': "^Bödy(.*)"}) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # assert we can do end matching (and last empty line is ignored) - # (also note that first body line - in between title and rest of body - is ignored) - rule = rules.BodyRegexMatches({'regex': "My-Commit-Tag: föo$"}) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # common use-case: matching that a given line is present - rule = rules.BodyRegexMatches({'regex': "(.*)Föo(.*)"}) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # assert violation on non-matching body - rule = rules.BodyRegexMatches({'regex': "^Tëst(.*)Foo"}) - violations = rule.validate(commit) - expected_violation = rules.RuleViolation("B8", "Body does not match regex (^Tëst(.*)Foo)", None, 6) - self.assertListEqual(violations, [expected_violation]) - - # assert no violation on None regex - rule = rules.BodyRegexMatches({'regex': None}) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # Assert no issues when there's no body or a weird body variation - bodies = ["åbc", "åbc\n", "åbc\nföo\n", "åbc\n\n", "åbc\nföo\nblå", "åbc\nföo\nblå\n"] - for body in bodies: - commit = self.gitcommit(body) - rule = rules.BodyRegexMatches({'regex': ".*"}) - violations = rule.validate(commit) - self.assertIsNone(violations) diff --git a/gitlint/tests/rules/test_configuration_rules.py b/gitlint/tests/rules/test_configuration_rules.py deleted file mode 100644 index 9302da5..0000000 --- a/gitlint/tests/rules/test_configuration_rules.py +++ /dev/null @@ -1,140 +0,0 @@ -# -*- 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("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": "^Releäse(.*)"}) - expected_config = LintConfig() - expected_config.ignore = "all" - rule.apply(config, commit) - self.assertEqual(config, expected_config) - - expected_log_message = "DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + \ - "Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: all" - self.assert_log_contains(expected_log_message) - - # Matching regex with specific ignore - rule = rules.IgnoreByTitle({"regex": "^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 = "DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + \ - "Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: T1,B2" - - def test_ignore_by_body(self): - commit = self.gitcommit("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": "(.*)relëase(.*)"}) - expected_config = LintConfig() - expected_config.ignore = "all" - rule.apply(config, commit) - self.assertEqual(config, expected_config) - - expected_log_message = "DEBUG: gitlint.rules Ignoring commit because of rule 'I2': " + \ - "Commit message line ' a relëase body' matches the regex '(.*)relëase(.*)'," + \ - " ignoring rules: all" - self.assert_log_contains(expected_log_message) - - # Matching regex with specific ignore - rule = rules.IgnoreByBody({"regex": "(.*)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 = "DEBUG: gitlint.rules Ignoring commit because of rule 'I2': " + \ - "Commit message line ' a relëase body' matches the regex '(.*)relëase(.*)', ignoring rules: T1,B2" - self.assert_log_contains(expected_log_message) - - def test_ignore_by_author_name(self): - commit = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line", author_name="Tëst nåme") - - # No regex specified -> Config shouldn't be changed - rule = rules.IgnoreByAuthorName() - 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.IgnoreByAuthorName({"regex": "(.*)ëst(.*)"}) - expected_config = LintConfig() - expected_config.ignore = "all" - rule.apply(config, commit) - self.assertEqual(config, expected_config) - - expected_log_message = ("DEBUG: gitlint.rules Ignoring commit because of rule 'I4': " - "Commit Author Name 'Tëst nåme' matches the regex '(.*)ëst(.*)'," - " ignoring rules: all") - self.assert_log_contains(expected_log_message) - - # Matching regex with specific ignore - rule = rules.IgnoreByAuthorName({"regex": "(.*)nåme", "ignore": "T1,B2"}) - expected_config = LintConfig() - expected_config.ignore = "T1,B2" - rule.apply(config, commit) - self.assertEqual(config, expected_config) - - expected_log_message = ("DEBUG: gitlint.rules Ignoring commit because of rule 'I4': " - "Commit Author Name 'Tëst nåme' matches the regex '(.*)nåme', ignoring rules: T1,B2") - self.assert_log_contains(expected_log_message) - - def test_ignore_body_lines(self): - commit1 = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line") - commit2 = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line") - - # no regex specified, nothing should have happened: - # commit and config should remain identical, log should be empty - rule = rules.IgnoreBodyLines() - config = LintConfig() - rule.apply(config, commit1) - self.assertEqual(commit1, commit2) - self.assertEqual(config, LintConfig()) - self.assert_logged([]) - - # Matching regex - rule = rules.IgnoreBodyLines({"regex": "(.*)relëase(.*)"}) - config = LintConfig() - rule.apply(config, commit1) - # Our modified commit should be identical to a commit that doesn't contain the specific line - expected_commit = self.gitcommit("Tïtle\n\nThis is\n line") - # The original message isn't touched by this rule, this way we always have a way to reference back to it, - # so assert it's not modified by setting it to the same as commit1 - expected_commit.message.original = commit1.message.original - self.assertEqual(commit1, expected_commit) - self.assertEqual(config, LintConfig()) # config shouldn't have been modified - self.assert_log_contains("DEBUG: gitlint.rules Ignoring line ' a relëase body' because it " + - "matches '(.*)relëase(.*)'") - - # Non-Matching regex: no changes expected - commit1 = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line") - rule = rules.IgnoreBodyLines({"regex": "(.*)föobar(.*)"}) - config = LintConfig() - rule.apply(config, commit1) - self.assertEqual(commit1, commit2) - self.assertEqual(config, LintConfig()) # config shouldn't have been modified diff --git a/gitlint/tests/rules/test_meta_rules.py b/gitlint/tests/rules/test_meta_rules.py deleted file mode 100644 index 568ca3f..0000000 --- a/gitlint/tests/rules/test_meta_rules.py +++ /dev/null @@ -1,59 +0,0 @@ -# -*- 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 = ["föo@bar.com", "Jöhn.Doe@bar.com", "jöhn+doe@bar.com", "jöhn/doe@bar.com", - "jöhn.doe@subdomain.bar.com"] - for email in valid_email_addresses: - commit = self.gitcommit("", 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("") - 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 = ["föo@bar", "JöhnDoe", "Jöhn Doe", "Jöhn Doe@foo.com", " JöhnDoe@foo.com", - "JöhnDoe@ foo.com", "JöhnDoe@foo. com", "JöhnDoe@foo. com", "@bår.com", - "föo@.com"] - for email in invalid_email_addresses: - commit = self.gitcommit("", 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): - # regex=None -> the rule isn't applied - rule = AuthorValidEmail() - rule.options['regex'].set(None) - emailadresses = ["föo", None, "hür dür"] - for email in emailadresses: - commit = self.gitcommit("", author_email=email) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # Custom domain - rule = AuthorValidEmail({'regex': "[^@]+@bår.com"}) - valid_email_addresses = [ - "föo@bår.com", "Jöhn.Doe@bår.com", "jöhn+doe@bår.com", "jöhn/doe@bår.com"] - for email in valid_email_addresses: - commit = self.gitcommit("", author_email=email) - violations = rule.validate(commit) - self.assertIsNone(violations) - - # Invalid email addresses - invalid_email_addresses = ["föo@hur.com"] - for email in invalid_email_addresses: - commit = self.gitcommit("", author_email=email) - violations = rule.validate(commit) - self.assertListEqual(violations, - [RuleViolation("M1", "Author email for commit is invalid", email)]) diff --git a/gitlint/tests/rules/test_rules.py b/gitlint/tests/rules/test_rules.py deleted file mode 100644 index 6fcf9bc..0000000 --- a/gitlint/tests/rules/test_rules.py +++ /dev/null @@ -1,23 +0,0 @@ -# -*- 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, "åbc") - self.assertNotEqual(Rule(), rule) - - def test_rule_log(self): - rule = Rule() - rule.log.debug("Tēst message") - self.assert_log_contains("DEBUG: gitlint.rules Tēst message") - - def test_rule_violation_equality(self): - violation1 = RuleViolation("ïd1", "My messåge", "My cöntent", 1) - self.object_equality_test(violation1, ["rule_id", "message", "content", "line_nr"]) diff --git a/gitlint/tests/rules/test_title_rules.py b/gitlint/tests/rules/test_title_rules.py deleted file mode 100644 index 10b4aab..0000000 --- a/gitlint/tests/rules/test_title_rules.py +++ /dev/null @@ -1,186 +0,0 @@ -# -*- coding: utf-8 -*- -from gitlint.tests.base import BaseTestCase -from gitlint.rules import TitleMaxLength, TitleTrailingWhitespace, TitleHardTab, TitleMustNotContainWord, \ - TitleTrailingPunctuation, TitleLeadingWhitespace, TitleRegexMatches, RuleViolation, TitleMinLength - - -class TitleRuleTests(BaseTestCase): - def test_max_line_length(self): - rule = TitleMaxLength() - - # assert no error - violation = rule.validate("å" * 72, None) - self.assertIsNone(violation) - - # assert error on line length > 72 - expected_violation = RuleViolation("T1", "Title exceeds max length (73>72)", "å" * 73) - violations = rule.validate("å" * 73, None) - self.assertListEqual(violations, [expected_violation]) - - # set line length to 120, and check no violation on length 73 - rule = TitleMaxLength({'line-length': 120}) - violations = rule.validate("å" * 73, None) - self.assertIsNone(violations) - - # assert raise on 121 - expected_violation = RuleViolation("T1", "Title exceeds max length (121>120)", "å" * 121) - violations = rule.validate("å" * 121, None) - self.assertListEqual(violations, [expected_violation]) - - def test_trailing_whitespace(self): - rule = TitleTrailingWhitespace() - - # assert no error - violations = rule.validate("å", None) - self.assertIsNone(violations) - - # trailing space - expected_violation = RuleViolation("T2", "Title has trailing whitespace", "å ") - violations = rule.validate("å ", None) - self.assertListEqual(violations, [expected_violation]) - - # trailing tab - expected_violation = RuleViolation("T2", "Title has trailing whitespace", "å\t") - violations = rule.validate("å\t", None) - self.assertListEqual(violations, [expected_violation]) - - def test_hard_tabs(self): - rule = TitleHardTab() - - # assert no error - violations = rule.validate("This is å test", None) - self.assertIsNone(violations) - - # contains hard tab - expected_violation = RuleViolation("T4", "Title contains hard tab characters (\\t)", "This is å\ttest") - violations = rule.validate("This is å\ttest", None) - self.assertListEqual(violations, [expected_violation]) - - def test_trailing_punctuation(self): - rule = TitleTrailingPunctuation() - - # assert no error - violations = rule.validate("This is å test", None) - self.assertIsNone(violations) - - # assert errors for different punctuations - punctuation = "?:!.,;" - for char in punctuation: - line = "This is å test" + char # note that make sure to include some unicode! - gitcontext = self.gitcontext(line) - expected_violation = RuleViolation("T3", f"Title has trailing punctuation ({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("This is å test", None) - self.assertIsNone(violations) - - # no violation if WIP occurs inside a word - violations = rule.validate("This is å wiping test", None) - self.assertIsNone(violations) - - # match literally - violations = rule.validate("WIP This is å test", None) - expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", - "WIP This is å test") - self.assertListEqual(violations, [expected_violation]) - - # match case insensitive - violations = rule.validate("wip This is å test", None) - expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", - "wip This is å test") - self.assertListEqual(violations, [expected_violation]) - - # match if there is a colon after the word - violations = rule.validate("WIP:This is å test", None) - expected_violation = RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", - "WIP:This is å test") - self.assertListEqual(violations, [expected_violation]) - - # match multiple words - rule = TitleMustNotContainWord({'words': "wip,test,å"}) - violations = rule.validate("WIP:This is å test", None) - expected_violation = RuleViolation("T5", "Title contains the word 'wip' (case-insensitive)", - "WIP:This is å test") - expected_violation2 = RuleViolation("T5", "Title contains the word 'test' (case-insensitive)", - "WIP:This is å test") - expected_violation3 = RuleViolation("T5", "Title contains the word 'å' (case-insensitive)", - "WIP:This is å test") - self.assertListEqual(violations, [expected_violation, expected_violation2, expected_violation3]) - - def test_leading_whitespace(self): - 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", " ☺") - violations = rule.validate(" ☺", None) - self.assertListEqual(violations, [expected_violation]) - - def test_regex_matches(self): - commit = self.gitcommit("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': "^US[0-9]*: å"}) - violations = rule.validate(commit.message.title, commit) - self.assertIsNone(violations) - - # assert violation when no matching regex - rule = TitleRegexMatches({'regex': "^UÅ[0-9]*"}) - violations = rule.validate(commit.message.title, commit) - expected_violation = RuleViolation("T7", "Title does not match regex (^UÅ[0-9]*)", "US1234: åbc") - self.assertListEqual(violations, [expected_violation]) - - def test_min_line_length(self): - rule = TitleMinLength() - - # assert no error - violation = rule.validate("å" * 72, None) - self.assertIsNone(violation) - - # assert error on line length < 5 - expected_violation = RuleViolation("T8", "Title is too short (4<5)", "å" * 4, 1) - violations = rule.validate("å" * 4, None) - self.assertListEqual(violations, [expected_violation]) - - # set line length to 3, and check no violation on length 4 - rule = TitleMinLength({'min-length': 3}) - violations = rule.validate("å" * 4, None) - self.assertIsNone(violations) - - # assert no violations on length 3 (this asserts we've implemented a *strict* less than) - rule = TitleMinLength({'min-length': 3}) - violations = rule.validate("å" * 3, None) - self.assertIsNone(violations) - - # assert raise on 2 - expected_violation = RuleViolation("T8", "Title is too short (2<3)", "å" * 2, 1) - violations = rule.validate("å" * 2, None) - self.assertListEqual(violations, [expected_violation]) - - # assert raise on empty title - expected_violation = RuleViolation("T8", "Title is too short (0<3)", "", 1) - violations = rule.validate("", None) - self.assertListEqual(violations, [expected_violation]) diff --git a/gitlint/tests/rules/test_user_rules.py b/gitlint/tests/rules/test_user_rules.py deleted file mode 100644 index 5bf9b77..0000000 --- a/gitlint/tests/rules/test_user_rules.py +++ /dev/null @@ -1,256 +0,0 @@ -# -*- 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 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'>]", str(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, "my-üser-commit-rule") - expected_option = options.IntOption('violation-count', 1, "Number of violåtions to return") - self.assertListEqual(classes[0].options_spec, [expected_option]) - self.assertTrue(hasattr(classes[0], "validate")) - - # 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", "Commit violåtion 1", "Contënt 1", 1)]) - - # Have it return more violations - rule_class.options['violation-count'].value = 2 - violations = rule_class.validate("false-commit-object (ignored)") - self.assertListEqual(violations, [rules.RuleViolation("UC1", "Commit violåtion 1", "Contënt 1", 1), - rules.RuleViolation("UC1", "Commit violåtion 2", "Contënt 2", 2)]) - - def test_extra_path_specified_by_file(self): - # Test that find_rule_classes can handle an extra path given as a file name instead of a directory - 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", "Commit violåtion 1", "Contënt 1", 1)]) - - def test_rules_from_init_file(self): - # Test that we can import rules that are defined in __init__.py files - # 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([str(clazz) for clazz in classes]) - expected = ["<class 'my_commit_rules.MyUserCommitRule'>", "<class 'parent_package.InitFileRule'>"] - self.assertListEqual(class_strings, expected) - - def test_empty_user_classes(self): - # 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.assertRaisesMessage(UserRuleError, "Invalid extra-path: föo/bar"): - find_rule_classes("föo/bar") - - def test_assert_valid_rule_class(self): - class MyLineRuleClass(rules.LineRule): - id = 'UC1' - name = 'my-lïne-rule' - target = rules.CommitMessageTitle - - def validate(self): - pass - - class MyCommitRuleClass(rules.CommitRule): - id = 'UC2' - name = 'my-cömmit-rule' - - def validate(self): - pass - - class MyConfigurationRuleClass(rules.ConfigurationRule): - id = 'UC3' - name = 'my-cönfiguration-rule' - - def apply(self): - pass - - # Just assert that no error is raised - self.assertIsNone(assert_valid_rule_class(MyLineRuleClass)) - self.assertIsNone(assert_valid_rule_class(MyCommitRuleClass)) - self.assertIsNone(assert_valid_rule_class(MyConfigurationRuleClass)) - - 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.assertRaisesMessage(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: - pass - - expected_msg = "User-defined rule class 'MyRuleClass' must extend from gitlint.rules.LineRule, " + \ - "gitlint.rules.CommitRule or gitlint.rules.ConfigurationRule" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - def test_assert_valid_rule_class_negative_id(self): - - for parent_class in [rules.LineRule, rules.CommitRule]: - - class MyRuleClass(parent_class): - pass - - # Rule class must have an id - expected_msg = "User-defined rule class 'MyRuleClass' must have an 'id' attribute" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - # Rule ids must be non-empty - MyRuleClass.id = "" - with self.assertRaisesMessage(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", "I"]: - MyRuleClass.id = letter + "1" - expected_msg = f"The id '{letter}' of 'MyRuleClass' is invalid. " + \ - "Gitlint reserves ids starting with R,T,B,M,I" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - def test_assert_valid_rule_class_negative_name(self): - for parent_class in [rules.LineRule, rules.CommitRule]: - - class MyRuleClass(parent_class): - id = "UC1" - - # Rule class must have an name - expected_msg = "User-defined rule class 'MyRuleClass' must have a 'name' attribute" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - # Rule names must be non-empty - MyRuleClass.name = "" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - def test_assert_valid_rule_class_negative_option_spec(self): - - for parent_class in [rules.LineRule, rules.CommitRule]: - - class MyRuleClass(parent_class): - id = "UC1" - name = "my-rüle-class" - - # if set, option_spec must be a list of gitlint options - MyRuleClass.options_spec = "föo" - expected_msg = "The options_spec attribute of user-defined rule class 'MyRuleClass' must be a list " + \ - "of gitlint.options.RuleOption" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - # option_spec is a list, but not of gitlint options - MyRuleClass.options_spec = ["föo", 123] # pylint: disable=bad-option-value,redefined-variable-type - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - def test_assert_valid_rule_class_negative_validate(self): - - baseclasses = [rules.LineRule, rules.CommitRule] - for clazz in baseclasses: - class MyRuleClass(clazz): - id = "UC1" - name = "my-rüle-class" - - with self.assertRaisesMessage(UserRuleError, - "User-defined rule class 'MyRuleClass' must have a 'validate' method"): - assert_valid_rule_class(MyRuleClass) - - # validate attribute - not a method - MyRuleClass.validate = "föo" - with self.assertRaisesMessage(UserRuleError, - "User-defined rule class 'MyRuleClass' must have a 'validate' method"): - assert_valid_rule_class(MyRuleClass) - - def test_assert_valid_rule_class_negative_apply(self): - class MyRuleClass(rules.ConfigurationRule): - id = "UCR1" - name = "my-rüle-class" - - expected_msg = "User-defined Configuration rule class 'MyRuleClass' must have an 'apply' method" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - # validate attribute - not a method - MyRuleClass.validate = "föo" - with self.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - def test_assert_valid_rule_class_negative_target(self): - class MyRuleClass(rules.LineRule): - id = "UC1" - name = "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.assertRaisesMessage(UserRuleError, expected_msg): - assert_valid_rule_class(MyRuleClass) - - # invalid target - MyRuleClass.target = "föo" - with self.assertRaisesMessage(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 deleted file mode 100644 index 2539dd1..0000000 --- a/gitlint/tests/samples/commit_message/fixup +++ /dev/null @@ -1 +0,0 @@ -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 deleted file mode 100644 index 764e131..0000000 --- a/gitlint/tests/samples/commit_message/merge +++ /dev/null @@ -1,3 +0,0 @@ -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/no-violations b/gitlint/tests/samples/commit_message/no-violations deleted file mode 100644 index 33c73b9..0000000 --- a/gitlint/tests/samples/commit_message/no-violations +++ /dev/null @@ -1,6 +0,0 @@ -Normal Commit Tïtle - -Nörmal body that contains a few lines of text describing the changes in the -commit without violating any of gitlint's rules. - -Sïgned-Off-By: foo@bar.com diff --git a/gitlint/tests/samples/commit_message/revert b/gitlint/tests/samples/commit_message/revert deleted file mode 100644 index 6dc8368..0000000 --- a/gitlint/tests/samples/commit_message/revert +++ /dev/null @@ -1,3 +0,0 @@ -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 deleted file mode 100644 index 646c0cb..0000000 --- a/gitlint/tests/samples/commit_message/sample1 +++ /dev/null @@ -1,14 +0,0 @@ -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 deleted file mode 100644 index 356540c..0000000 --- a/gitlint/tests/samples/commit_message/sample2 +++ /dev/null @@ -1 +0,0 @@ -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 deleted file mode 100644 index d67d70b..0000000 --- a/gitlint/tests/samples/commit_message/sample3 +++ /dev/null @@ -1,6 +0,0 @@ - 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 deleted file mode 100644 index c858d89..0000000 --- a/gitlint/tests/samples/commit_message/sample4 +++ /dev/null @@ -1,7 +0,0 @@ - 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 deleted file mode 100644 index 77ccbe8..0000000 --- a/gitlint/tests/samples/commit_message/sample5 +++ /dev/null @@ -1,7 +0,0 @@ - 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 deleted file mode 100644 index 538a93a..0000000 --- a/gitlint/tests/samples/commit_message/squash +++ /dev/null @@ -1,3 +0,0 @@ -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 deleted file mode 100644 index 8c93f71..0000000 --- a/gitlint/tests/samples/config/gitlintconfig +++ /dev/null @@ -1,15 +0,0 @@ -[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 deleted file mode 100644 index 92015aa..0000000 --- a/gitlint/tests/samples/config/invalid-option-value +++ /dev/null @@ -1,11 +0,0 @@ -[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/named-rules b/gitlint/tests/samples/config/named-rules deleted file mode 100644 index 73ab0d2..0000000 --- a/gitlint/tests/samples/config/named-rules +++ /dev/null @@ -1,8 +0,0 @@ -[title-must-not-contain-word] -words=WIP,bögus - -[title-must-not-contain-word:extra-wörds] -words=hür,tëst - -[T5:even-more-wörds] -words=hür,tïtle
\ No newline at end of file diff --git a/gitlint/tests/samples/config/no-sections b/gitlint/tests/samples/config/no-sections deleted file mode 100644 index ec82b25..0000000 --- a/gitlint/tests/samples/config/no-sections +++ /dev/null @@ -1 +0,0 @@ -ignore=title-max-length, T3 diff --git a/gitlint/tests/samples/config/nonexisting-general-option b/gitlint/tests/samples/config/nonexisting-general-option deleted file mode 100644 index d5cfef2..0000000 --- a/gitlint/tests/samples/config/nonexisting-general-option +++ /dev/null @@ -1,13 +0,0 @@ -[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 deleted file mode 100644 index 6964c77..0000000 --- a/gitlint/tests/samples/config/nonexisting-option +++ /dev/null @@ -1,11 +0,0 @@ -[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 deleted file mode 100644 index c0f0d2b..0000000 --- a/gitlint/tests/samples/config/nonexisting-rule +++ /dev/null @@ -1,11 +0,0 @@ -[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 deleted file mode 100644 index 2a56650..0000000 --- a/gitlint/tests/samples/user_rules/bogus-file.txt +++ /dev/null @@ -1,2 +0,0 @@ -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 deleted file mode 100644 index e75fed3..0000000 --- a/gitlint/tests/samples/user_rules/import_exception/invalid_python.py +++ /dev/null @@ -1,3 +0,0 @@ -# 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 deleted file mode 100644 index 004ef9d..0000000 --- a/gitlint/tests/samples/user_rules/incorrect_linerule/my_line_rule.py +++ /dev/null @@ -1,10 +0,0 @@ -# -*- 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 deleted file mode 100644 index 605d704..0000000 --- a/gitlint/tests/samples/user_rules/my_commit_rules.foo +++ /dev/null @@ -1,16 +0,0 @@ -# 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 deleted file mode 100644 index 8b0907e..0000000 --- a/gitlint/tests/samples/user_rules/my_commit_rules.py +++ /dev/null @@ -1,26 +0,0 @@ -# -*- coding: utf-8 -*- - -from gitlint.rules import CommitRule, RuleViolation -from gitlint.options import IntOption - - -class MyUserCommitRule(CommitRule): - name = "my-üser-commit-rule" - id = "UC1" - options_spec = [IntOption('violation-count', 1, "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, "Commit violåtion %d" % i, "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 deleted file mode 100644 index 9ea5371..0000000 --- a/gitlint/tests/samples/user_rules/parent_package/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# -*- 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 = "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 deleted file mode 100644 index b143e62..0000000 --- a/gitlint/tests/samples/user_rules/parent_package/my_commit_rules.py +++ /dev/null @@ -1,12 +0,0 @@ -# -*- coding: utf-8 -*- - -from gitlint.rules import CommitRule - - -class MyUserCommitRule(CommitRule): - name = "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 deleted file mode 100644 index 4b1d47a..0000000 --- a/gitlint/tests/test_cache.py +++ /dev/null @@ -1,57 +0,0 @@ -# -*- 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 "bår" - - @property - @cache(cachekey="hür") - def bar(self): - self.counter += 1 - return "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, "bår") - self.assertEqual(myclass.counter, 1) - self.assertDictEqual(myclass._cache, {"foo": "bår"}) - - # After function is not called on subsequent access, cache is still set - self.assertEqual(myclass.foo, "bår") - self.assertEqual(myclass.counter, 1) - self.assertDictEqual(myclass._cache, {"foo": "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, "fōo") - self.assertEqual(myclass.counter, 1) - self.assertDictEqual(myclass._cache, {"hür": "fōo"}) - - # After function is not called on subsequent access, cache is still set - self.assertEqual(myclass.bar, "fōo") - self.assertEqual(myclass.counter, 1) - self.assertDictEqual(myclass._cache, {"hür": "fōo"}) diff --git a/gitlint/tests/test_display.py b/gitlint/tests/test_display.py deleted file mode 100644 index 167ef96..0000000 --- a/gitlint/tests/test_display.py +++ /dev/null @@ -1,63 +0,0 @@ -# -*- coding: utf-8 -*- - -from io import StringIO - -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("tëst") - display.vv("tëst2") - # vvvv should be ignored regardless - display.vvv("tëst3.1") - display.vvv("tëst3.2", exact=True) - self.assertEqual("tëst\ntëst2\n", stdout.getvalue()) - - # exact outputting, should only output v - with patch('gitlint.display.stdout', new=StringIO()) as stdout: - display.v("tëst", exact=True) - display.vv("tëst2", exact=True) - # vvvv should be ignored regardless - display.vvv("tëst3.1") - display.vvv("tëst3.2", exact=True) - self.assertEqual("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("tëst") - display.ee("tëst2") - # vvvv should be ignored regardless - display.eee("tëst3.1") - display.eee("tëst3.2", exact=True) - self.assertEqual("tëst\ntëst2\n", stderr.getvalue()) - - # exact outputting, should only output v - with patch('gitlint.display.stderr', new=StringIO()) as stderr: - display.e("tëst", exact=True) - display.ee("tëst2", exact=True) - # vvvv should be ignored regardless - display.eee("tëst3.1") - display.eee("tëst3.2", exact=True) - self.assertEqual("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 deleted file mode 100644 index 0ce5040..0000000 --- a/gitlint/tests/test_hooks.py +++ /dev/null @@ -1,131 +0,0 @@ -# -*- coding: utf-8 -*- - -import os - -from unittest.mock import patch, ANY, mock_open - -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("/föo", "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("/hür", "dur") - git_hooks_dir.return_value = os.path.join("/föo", "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("/hür", "dur") - git_hooks_dir.return_value = os.path.join("/föo", "bar", ".git", "hooks") - # mock that current dir is not a git repo - isdir.return_value = False - expected_msg = f"{lint_config.target} is not a git repository." - with self.assertRaisesMessage(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 = f"There is already a commit-msg hook file present in {expected_dst}.\n" + \ - "gitlint currently does not support appending to an existing commit-msg file." - with self.assertRaisesMessage(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("/föo", "bar", ".git", "hooks") - lint_config.target = os.path.join("/hür", "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("/hür", "dur") - git_hooks_dir.return_value = os.path.join("/föo", "bar", ".git", "hooks") - - # mock that the current directory is not a git repo - isdir.return_value = False - expected_msg = f"{lint_config.target} is not a git repository." - with self.assertRaisesMessage(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 = f"There is no commit-msg hook present in {expected_dst}." - with self.assertRaisesMessage(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 = f"The commit-msg hook in {expected_dst} was not installed by gitlint " + \ - "(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.assertRaisesMessage(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 deleted file mode 100644 index b743389..0000000 --- a/gitlint/tests/test_lint.py +++ /dev/null @@ -1,277 +0,0 @@ -# -*- coding: utf-8 -*- - -from io import StringIO - -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, TitleMustNotContainWord -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 (.)", - "Commit title contåining 'WIP', as well as trailing punctuation.", 1), - RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", - "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", "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)", - "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 = " 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)", - "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", "This line has a tråiling tab.\t", 5), - RuleViolation("B3", "Line contains hard tab characters (\\t)", - "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 = " 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", "This line should be ëmpty", 2), - RuleViolation("B2", "Line has trailing whitespace", "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 gets linted as well """ - linter = GitLinter(LintConfig()) - gitcontext = self.gitcontext(self.get_sample("commit_message/sample2")) - gitcontext.commits[0].author_email = "foo bår" - violations = linter.lint(gitcontext.commits[-1]) - expected = [RuleViolation("M1", "Author email for commit is invalid", "foo bår", None), - RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", - "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)", - "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)", - "Just a title contåining WIP", 1)] - - self.assertListEqual(violations, expected) - - # Test ignoring body lines - lint_config = LintConfig() - linter = GitLinter(lint_config) - lint_config.set_rule_option("I3", "regex", "(.*)tråiling(.*)") - violations = linter.lint(self.gitcommit(self.get_sample("commit_message/sample1"))) - expected_errors = [RuleViolation("T3", "Title has trailing punctuation (.)", - "Commit title contåining 'WIP', as well as trailing punctuation.", 1), - RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", - "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", "This line has a trailing tab.\t", 4), - RuleViolation("B3", "Line contains hard tab characters (\\t)", - "This line has a trailing tab.\t", 4)] - - self.assertListEqual(violations, expected_errors) - - def test_lint_special_commit(self): - for commit_type in ["merge", "revert", "squash", "fixup"]: - commit = self.gitcommit(self.get_sample(f"commit_message/{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, f"ignore_{commit_type}_commits", False) - linter = GitLinter(lintconfig) - violations = linter.lint(commit) - self.assertTrue(len(violations) > 0) - - def test_lint_regex_rules(self): - """ Additional test for title-match-regex, body-match-regex """ - commit = self.gitcommit(self.get_sample("commit_message/no-violations")) - lintconfig = LintConfig() - linter = GitLinter(lintconfig) - violations = linter.lint(commit) - # No violations by default - self.assertListEqual(violations, []) - - # Matching regexes shouldn't be a problem - rule_regexes = [("title-match-regex", "Tïtle$"), ("body-match-regex", "Sïgned-Off-By: (.*)$")] - for rule_regex in rule_regexes: - lintconfig.set_rule_option(rule_regex[0], "regex", rule_regex[1]) - violations = linter.lint(commit) - self.assertListEqual(violations, []) - - # Non-matching regexes should return violations - rule_regexes = [("title-match-regex", ), ("body-match-regex",)] - lintconfig.set_rule_option("title-match-regex", "regex", "^Tïtle") - lintconfig.set_rule_option("body-match-regex", "regex", "Sügned-Off-By: (.*)$") - expected_violations = [RuleViolation("T7", "Title does not match regex (^Tïtle)", "Normal Commit Tïtle", 1), - RuleViolation("B8", "Body does not match regex (Sügned-Off-By: (.*)$)", None, 6)] - violations = linter.lint(commit) - self.assertListEqual(violations, expected_violations) - - def test_print_violations(self): - violations = [RuleViolation("RULE_ID_1", "Error Messåge 1", "Violating Content 1", None), - RuleViolation("RULE_ID_2", "Error Message 2", "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 = "-: 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 = "-: 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 = "-: RULE_ID_1 Error Messåge 1: \"Violating Content 1\"\n" + \ - "2: RULE_ID_2 Error Message 2: \"Violåting Content 2\"\n" - self.assertEqual(expected, stderr.getvalue()) - - def test_named_rules(self): - """ Test that when named rules are present, both them and the original (non-named) rules executed """ - - lint_config = LintConfig() - for rule_name in ["my-ïd", "another-rule-ïd"]: - rule_id = TitleMustNotContainWord.id + ":" + rule_name - lint_config.rules.add_rule(TitleMustNotContainWord, rule_id) - lint_config.set_rule_option(rule_id, "words", ["Föo"]) - linter = GitLinter(lint_config) - - violations = [RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", "WIP: Föo bar", 1), - RuleViolation("T5:another-rule-ïd", "Title contains the word 'Föo' (case-insensitive)", - "WIP: Föo bar", 1), - RuleViolation("T5:my-ïd", "Title contains the word 'Föo' (case-insensitive)", - "WIP: Föo bar", 1)] - self.assertListEqual(violations, linter.lint(self.gitcommit("WIP: Föo bar\n\nFoo bår hur dur bla bla"))) - - def test_ignore_named_rules(self): - """ Test that named rules can be ignored """ - - # Add named rule to lint config - config_builder = LintConfigBuilder() - rule_id = TitleMustNotContainWord.id + ":my-ïd" - config_builder.set_option(rule_id, "words", ["Föo"]) - lint_config = config_builder.build() - linter = GitLinter(lint_config) - commit = self.gitcommit("WIP: Föo bar\n\nFoo bår hur dur bla bla") - - # By default, we expect both the violations of the regular rule as well as the named rule to show up - violations = [RuleViolation("T5", "Title contains the word 'WIP' (case-insensitive)", "WIP: Föo bar", 1), - RuleViolation("T5:my-ïd", "Title contains the word 'Föo' (case-insensitive)", - "WIP: Föo bar", 1)] - self.assertListEqual(violations, linter.lint(commit)) - - # ignore regular rule: only named rule violations show up - lint_config.ignore = ["T5"] - self.assertListEqual(violations[1:], linter.lint(commit)) - - # ignore named rule by id: only regular rule violations show up - lint_config.ignore = [rule_id] - self.assertListEqual(violations[:-1], linter.lint(commit)) - - # ignore named rule by name: only regular rule violations show up - lint_config.ignore = [TitleMustNotContainWord.name + ":my-ïd"] - self.assertListEqual(violations[:-1], linter.lint(commit)) diff --git a/gitlint/tests/test_options.py b/gitlint/tests/test_options.py deleted file mode 100644 index eabcfe1..0000000 --- a/gitlint/tests/test_options.py +++ /dev/null @@ -1,224 +0,0 @@ -# -*- coding: utf-8 -*- -import os -import re - -from gitlint.tests.base import BaseTestCase - -from gitlint.options import IntOption, BoolOption, StrOption, ListOption, PathOption, RegexOption, RuleOptionError - - -class RuleOptionTests(BaseTestCase): - def test_option_equality(self): - options = {IntOption: 123, StrOption: "foöbar", BoolOption: False, ListOption: ["a", "b"], - PathOption: ".", RegexOption: "^foöbar(.*)"} - for clazz, val in options.items(): - # 2 options are equal if their name, value and description match - option1 = clazz("test-öption", val, "Test Dëscription") - option2 = clazz("test-öption", val, "Test Dëscription") - self.assertEqual(option1, option2) - - # Not equal: class, name, description, value are different - self.assertNotEqual(option1, IntOption("tëst-option1", 123, "Test Dëscription")) - self.assertNotEqual(option1, StrOption("tëst-option1", "åbc", "Test Dëscription")) - self.assertNotEqual(option1, StrOption("tëst-option", "åbcd", "Test Dëscription")) - self.assertNotEqual(option1, StrOption("tëst-option", "åbc", "Test Dëscription2")) - - def test_int_option(self): - # normal behavior - option = IntOption("tëst-name", 123, "Tëst Description") - self.assertEqual(option.name, "tëst-name") - self.assertEqual(option.description, "Tëst Description") - self.assertEqual(option.value, 123) - - # re-set value - option.set(456) - self.assertEqual(option.value, 456) - - # set to None - option.set(None) - self.assertEqual(option.value, None) - - # error on negative int when not allowed - expected_error = "Option 'tëst-name' must be a positive integer (current value: '-123')" - with self.assertRaisesMessage(RuleOptionError, expected_error): - option.set(-123) - - # error on non-int value - expected_error = "Option 'tëst-name' must be a positive integer (current value: 'foo')" - with self.assertRaisesMessage(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 = "Option 'test-name' must be an integer (current value: 'foo')" - with self.assertRaisesMessage(RuleOptionError, expected_error): - option.set("foo") - - def test_str_option(self): - # normal behavior - option = StrOption("tëst-name", "föo", "Tëst Description") - self.assertEqual(option.name, "tëst-name") - self.assertEqual(option.description, "Tëst Description") - self.assertEqual(option.value, "föo") - - # re-set value - option.set("bår") - self.assertEqual(option.value, "bår") - - # conversion to str - option.set(123) - self.assertEqual(option.value, "123") - - # conversion to str - option.set(-123) - self.assertEqual(option.value, "-123") - - # None value - option.set(None) - self.assertEqual(option.value, None) - - def test_boolean_option(self): - # normal behavior - option = BoolOption("tëst-name", "true", "Tëst Description") - self.assertEqual(option.name, "tëst-name") - self.assertEqual(option.description, "Tëst 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", "bår", ["foo"], {'foo': "bar"}, None] - for value in incorrect_values: - with self.assertRaisesMessage(RuleOptionError, "Option 'tëst-name' must be either 'true' or 'false'"): - option.set(value) - - def test_list_option(self): - # normal behavior - option = ListOption("tëst-name", "å,b,c,d", "Tëst Description") - self.assertEqual(option.name, "tëst-name") - self.assertEqual(option.description, "Tëst Description") - self.assertListEqual(option.value, ["å", "b", "c", "d"]) - - # re-set value - option.set("1,2,3,4") - self.assertListEqual(option.value, ["1", "2", "3", "4"]) - - # set list - option.set(["foo", "bår", "test"]) - self.assertListEqual(option.value, ["foo", "bår", "test"]) - - # None - option.set(None) - self.assertIsNone(option.value) - - # 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("ë,f,g,") - self.assertListEqual(option.value, ["ë", "f", "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("tëst-directory", ".", "Tëst Description", type="dir") - self.assertEqual(option.name, "tëst-directory") - self.assertEqual(option.description, "Tëst Description") - self.assertEqual(option.value, os.getcwd()) - self.assertEqual(option.type, "dir") - - # re-set value - option.set(self.SAMPLES_DIR) - self.assertEqual(option.value, self.SAMPLES_DIR) - - # set to None - option.set(None) - self.assertIsNone(option.value) - - # set to int - expected = "Option tëst-directory must be an existing directory (current value: '1234')" - with self.assertRaisesMessage(RuleOptionError, expected): - option.set(1234) - - # set to non-existing directory - non_existing_path = os.path.join("/föo", "bar") - expected = f"Option tëst-directory must be an existing directory (current value: '{non_existing_path}')" - with self.assertRaisesMessage(RuleOptionError, expected): - 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 = f"Option tëst-directory must be an existing directory (current value: '{sample_path}')" - with self.assertRaisesMessage(RuleOptionError, expected): - option.set(sample_path) - - # set option.type = file, file should now be accepted, directories not - option.type = "file" - option.set(sample_path) - self.assertEqual(option.value, sample_path) - expected = f"Option tëst-directory must be an existing file (current value: '{self.get_sample_path()}')" - with self.assertRaisesMessage(RuleOptionError, expected): - option.set(self.get_sample_path()) - - # set option.type = both, files and directories should now be accepted - option.type = "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 = 'föo' - expected = "Option tëst-directory type must be one of: 'file', 'dir', 'both' (current: 'föo')" - with self.assertRaisesMessage(RuleOptionError, expected): - option.set("haha") - - def test_regex_option(self): - # normal behavior - option = RegexOption("tëst-regex", "^myrëgex(.*)foo$", "Tëst Regex Description") - self.assertEqual(option.name, "tëst-regex") - self.assertEqual(option.description, "Tëst Regex Description") - self.assertEqual(option.value, re.compile("^myrëgex(.*)foo$", re.UNICODE)) - - # re-set value - option.set("[0-9]föbar.*") - self.assertEqual(option.value, re.compile("[0-9]föbar.*", re.UNICODE)) - - # set None - option.set(None) - self.assertIsNone(option.value) - - # error on invalid regex - incorrect_values = ["foo(", 123, -1] - for value in incorrect_values: - with self.assertRaisesRegex(RuleOptionError, "Invalid regular expression"): - option.set(value) diff --git a/gitlint/tests/test_utils.py b/gitlint/tests/test_utils.py deleted file mode 100644 index 4ec8bda..0000000 --- a/gitlint/tests/test_utils.py +++ /dev/null @@ -1,77 +0,0 @@ -# -*- coding: utf-8 -*- - -from unittest.mock import patch - -from gitlint import utils -from gitlint.tests.base import BaseTestCase - - -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", "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 = "foöbar" - self.assertEqual(utils.getpreferredencoding(), "foöbar") - mocked_locale.getpreferredencoding.assert_called_once() - - mocked_locale.getpreferredencoding.return_value = False - self.assertEqual(utils.getpreferredencoding(), "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": "ASCII", "LC_CTYPE": "UTF-16", "LANG": "CP1251"} - self.assertEqual(utils.getpreferredencoding(), "ASCII") - mock_env = {"LC_CTYPE": "UTF-16", "LANG": "CP1251"} - self.assertEqual(utils.getpreferredencoding(), "UTF-16") - mock_env = {"LANG": "CP1251"} - self.assertEqual(utils.getpreferredencoding(), "CP1251") - - # Assert split on dot - mock_env = {"LANG": "foo.UTF-16"} - self.assertEqual(utils.getpreferredencoding(), "UTF-16") - - # assert default encoding is UTF-8 - mock_env = {} - self.assertEqual(utils.getpreferredencoding(), "UTF-8") - mock_env = {"FOO": "föo"} - self.assertEqual(utils.getpreferredencoding(), "UTF-8") - - # assert fallback encoding is UTF-8 in case we set an unavailable encoding - mock_env = {"LC_ALL": "foo"} - self.assertEqual(utils.getpreferredencoding(), "UTF-8") |