summaryrefslogtreecommitdiffstats
path: root/gitlint-core/gitlint/tests/cli
diff options
context:
space:
mode:
Diffstat (limited to 'gitlint-core/gitlint/tests/cli')
-rw-r--r--gitlint-core/gitlint/tests/cli/test_cli.py593
-rw-r--r--gitlint-core/gitlint/tests/cli/test_cli_hooks.py281
2 files changed, 874 insertions, 0 deletions
diff --git a/gitlint-core/gitlint/tests/cli/test_cli.py b/gitlint-core/gitlint/tests/cli/test_cli.py
new file mode 100644
index 0000000..59ec7af
--- /dev/null
+++ b/gitlint-core/gitlint/tests/cli/test_cli.py
@@ -0,0 +1,593 @@
+# -*- 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-core/gitlint/tests/cli/test_cli_hooks.py b/gitlint-core/gitlint/tests/cli/test_cli_hooks.py
new file mode 100644
index 0000000..825345f
--- /dev/null
+++ b/gitlint-core/gitlint/tests/cli/test_cli_hooks.py
@@ -0,0 +1,281 @@
+# -*- 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)
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-20 07:24:17 +0000