diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-09 13:38:02 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-09 13:38:02 +0000 |
commit | 6f442e774b9236c999f36c2d7af17640f49bff99 (patch) | |
tree | 47e73755bffd41bdde2d59d76cc595f5a1fa75d4 /gitlint-core | |
parent | Initial commit. (diff) | |
download | gitlint-6f442e774b9236c999f36c2d7af17640f49bff99.tar.xz gitlint-6f442e774b9236c999f36c2d7af17640f49bff99.zip |
Adding upstream version 0.19.1.upstream/0.19.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
116 files changed, 9289 insertions, 0 deletions
diff --git a/gitlint-core/LICENSE b/gitlint-core/LICENSE new file mode 100644 index 0000000..122bd28 --- /dev/null +++ b/gitlint-core/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Joris Roovers + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/gitlint-core/README.md b/gitlint-core/README.md new file mode 100644 index 0000000..dfbbe7f --- /dev/null +++ b/gitlint-core/README.md @@ -0,0 +1,26 @@ +# Gitlint-core + +# gitlint: [jorisroovers.github.io/gitlint](http://jorisroovers.github.io/gitlint/) # + +[![Tests](https://github.com/jorisroovers/gitlint/workflows/Tests%20and%20Checks/badge.svg)](https://github.com/jorisroovers/gitlint/actions?query=workflow%3A%22Tests+and+Checks%22) +[![Coverage Status](https://coveralls.io/repos/github/jorisroovers/gitlint/badge.svg?branch=fix-coveralls)](https://coveralls.io/github/jorisroovers/gitlint?branch=fix-coveralls) +[![PyPi Package](https://img.shields.io/pypi/v/gitlint.png)](https://pypi.python.org/pypi/gitlint) +![Supported Python Versions](https://img.shields.io/pypi/pyversions/gitlint.svg) + +Git commit message linter written in python, checks your commit messages for style. + +**See [jorisroovers.github.io/gitlint](http://jorisroovers.github.io/gitlint/) for full documentation.** + +<a href="http://jorisroovers.github.io/gitlint/" target="_blank"> +<img src="https://raw.githubusercontent.com/jorisroovers/gitlint/main/docs/images/readme-gitlint.png" /> +</a> + +## Contributing ## +All contributions are welcome and very much appreciated! + +**I'm [looking for contributors](https://github.com/jorisroovers/gitlint/issues/134) that are interested in taking a more active co-maintainer role as it's becoming increasingly difficult for me to find time to maintain gitlint. Please leave a comment in [#134](https://github.com/jorisroovers/gitlint/issues/134) if you're interested!** + +See [jorisroovers.github.io/gitlint/contributing](http://jorisroovers.github.io/gitlint/contributing) for details on +how to get started - it's easy! + +We maintain a [loose project plan on Github Projects](https://github.com/users/jorisroovers/projects/1/views/1). diff --git a/gitlint-core/gitlint/__init__.py b/gitlint-core/gitlint/__init__.py new file mode 100644 index 0000000..a2339fd --- /dev/null +++ b/gitlint-core/gitlint/__init__.py @@ -0,0 +1,8 @@ +import sys + +if sys.version_info >= (3, 8): + from importlib import metadata # pragma: nocover +else: + import importlib_metadata as metadata # pragma: nocover + +__version__ = metadata.version("gitlint-core") diff --git a/gitlint-core/gitlint/cache.py b/gitlint-core/gitlint/cache.py new file mode 100644 index 0000000..a3dd0c8 --- /dev/null +++ b/gitlint-core/gitlint/cache.py @@ -0,0 +1,54 @@ +class PropertyCache: + """Mixin class providing a simple cache.""" + + def __init__(self): + self._cache = {} + + def _try_cache(self, cache_key, cache_populate_func): + """Tries to get a value from the cache identified by `cache_key`. + If no value is found in the cache, do a function call to `cache_populate_func` to populate the cache + and then return the value from the cache.""" + if cache_key not in self._cache: + cache_populate_func() + return self._cache[cache_key] + + +def cache(original_func=None, cachekey=None): + """Cache decorator. Caches function return values. + Requires the parent class to extend and initialize PropertyCache. + Usage: + # Use function name as cache key + @cache + def myfunc(args): + ... + + # Specify cache key + @cache(cachekey="foobar") + def myfunc(args): + ... + """ + + # Decorators with optional arguments are a bit convoluted in python, see some of the links below for details. + + def cache_decorator(func): + # Use 'nonlocal' keyword to access parent function variable: + # https://stackoverflow.com/a/14678445/381010 + nonlocal cachekey + if not cachekey: + cachekey = func.__name__ + + def wrapped(*args): + def cache_func_result(): + # Call decorated function and store its result in the cache + args[0]._cache[cachekey] = func(*args) + + return args[0]._try_cache(cachekey, cache_func_result) + + return wrapped + + # To support optional kwargs for decorators, we need to check if a function is passed as first argument or not. + # https://stackoverflow.com/a/24617244/381010 + if original_func: + return cache_decorator(original_func) + + return cache_decorator diff --git a/gitlint-core/gitlint/cli.py b/gitlint-core/gitlint/cli.py new file mode 100644 index 0000000..619f006 --- /dev/null +++ b/gitlint-core/gitlint/cli.py @@ -0,0 +1,499 @@ +import copy +import logging +import os +import platform +import stat +import sys + +import click + +import gitlint +from gitlint import hooks +from gitlint.config import LintConfigBuilder, LintConfigError, LintConfigGenerator +from gitlint.deprecation import DEPRECATED_LOG_FORMAT +from gitlint.deprecation import LOG as DEPRECATED_LOG +from gitlint.exception import GitlintError +from gitlint.git import GitContext, GitContextError, git_version +from gitlint.lint import GitLinter +from gitlint.shell import shell +from gitlint.utils import LOG_FORMAT + +# Error codes +GITLINT_SUCCESS = 0 +MAX_VIOLATION_ERROR_CODE = 252 +USAGE_ERROR_CODE = 253 +GIT_CONTEXT_ERROR_CODE = 254 +CONFIG_ERROR_CODE = 255 + +DEFAULT_CONFIG_FILE = ".gitlint" +# -n: disable swap files. This fixes a vim error on windows (E303: Unable to open swap file for <path>) +DEFAULT_COMMIT_MSG_EDITOR = "vim -n" + +# Since we use the return code to denote the amount of errors, we need to change the default click usage error code +click.UsageError.exit_code = USAGE_ERROR_CODE + +# We don't use logging.getLogger(__main__) here because that will cause DEBUG output to be lost +# when invoking gitlint as a python module (python -m gitlint.cli) +LOG = logging.getLogger("gitlint.cli") + + +class GitLintUsageError(GitlintError): + """Exception indicating there is an issue with how gitlint is used.""" + + +def setup_logging(): + """Setup gitlint logging""" + + # Root log, mostly used for debug + root_log = logging.getLogger("gitlint") + root_log.propagate = False # Don't propagate to child loggers, the gitlint root logger handles everything + root_log.setLevel(logging.WARN) + handler = logging.StreamHandler() + formatter = logging.Formatter(LOG_FORMAT) + handler.setFormatter(formatter) + root_log.addHandler(handler) + + # Deprecated log, to log deprecation warnings + DEPRECATED_LOG.propagate = False # Don't propagate to child logger + DEPRECATED_LOG.setLevel(logging.WARNING) + deprecated_log_handler = logging.StreamHandler() + deprecated_log_handler.setFormatter(logging.Formatter(DEPRECATED_LOG_FORMAT)) + DEPRECATED_LOG.addHandler(deprecated_log_handler) + + +def log_system_info(): + LOG.debug("Platform: %s", platform.platform()) + LOG.debug("Python version: %s", sys.version) + LOG.debug("Git version: %s", git_version()) + LOG.debug("Gitlint version: %s", gitlint.__version__) + LOG.debug("GITLINT_USE_SH_LIB: %s", os.environ.get("GITLINT_USE_SH_LIB", "[NOT SET]")) + LOG.debug("TERMINAL_ENCODING: %s", gitlint.utils.TERMINAL_ENCODING) + LOG.debug("FILE_ENCODING: %s", gitlint.utils.FILE_ENCODING) + + +def build_config( + target, + config_path, + c, + extra_path, + ignore, + contrib, + ignore_stdin, + staged, + fail_without_commits, + verbose, + silent, + debug, +): + """Creates a LintConfig object based on a set of commandline parameters.""" + config_builder = LintConfigBuilder() + # Config precedence: + # First, load default config or config from configfile + if config_path: + config_builder.set_from_config_file(config_path) + elif os.path.exists(DEFAULT_CONFIG_FILE): + config_builder.set_from_config_file(DEFAULT_CONFIG_FILE) + + # Then process any commandline configuration flags + config_builder.set_config_from_string_list(c) + + # Finally, overwrite with any convenience commandline flags + if ignore: + config_builder.set_option("general", "ignore", ignore) + + if contrib: + config_builder.set_option("general", "contrib", contrib) + + if ignore_stdin: + config_builder.set_option("general", "ignore-stdin", ignore_stdin) + + if silent: + config_builder.set_option("general", "verbosity", 0) + elif verbose > 0: + config_builder.set_option("general", "verbosity", verbose) + + if extra_path: + config_builder.set_option("general", "extra-path", extra_path) + + if target: + config_builder.set_option("general", "target", target) + + if debug: + config_builder.set_option("general", "debug", debug) + + if staged: + config_builder.set_option("general", "staged", staged) + + if fail_without_commits: + config_builder.set_option("general", "fail-without-commits", fail_without_commits) + + config = config_builder.build() + + return config, config_builder + + +def get_stdin_data(): + """Helper function that returns data sent to stdin or False if nothing is sent""" + # STDIN can only be 3 different types of things ("modes") + # 1. An interactive terminal device (i.e. a TTY -> sys.stdin.isatty() or stat.S_ISCHR) + # 2. A (named) pipe (stat.S_ISFIFO) + # 3. A regular file (stat.S_ISREG) + # Technically, STDIN can also be other device type like a named unix socket (stat.S_ISSOCK), but we don't + # support that in gitlint (at least not today). + # + # Now, the behavior that we want is the following: + # If someone sends something directly to gitlint via a pipe or a regular file, read it. If not, read from the + # local repository. + # Note that we don't care about whether STDIN is a TTY or not, we only care whether data is via a pipe or regular + # file. + # However, in case STDIN is not a TTY, it HAS to be one of the 2 other things (pipe or regular file), even if + # no-one is actually sending anything to gitlint over them. In this case, we still want to read from the local + # repository. + # To support this use-case (which is common in CI runners such as Jenkins and Gitlab), we need to actually attempt + # to read from STDIN in case it's a pipe or regular file. In case that fails, then we'll fall back to reading + # from the local repo. + + mode = os.fstat(sys.stdin.fileno()).st_mode + stdin_is_pipe_or_file = stat.S_ISFIFO(mode) or stat.S_ISREG(mode) + if stdin_is_pipe_or_file: + input_data = sys.stdin.read() + # Only return the input data if there's actually something passed + # i.e. don't consider empty piped data + if input_data: + return str(input_data) + return False + + +def build_git_context(lint_config, msg_filename, commit_hash, refspec): + """Builds a git context based on passed parameters and order of precedence""" + + # Determine which GitContext method to use if a custom message is passed + from_commit_msg = GitContext.from_commit_msg + if lint_config.staged: + LOG.debug("Fetching additional meta-data from staged commit") + + def from_commit_msg(message): + return GitContext.from_staged_commit(message, lint_config.target) + + # Order of precedence: + # 1. Any data specified via --msg-filename + if msg_filename: + LOG.debug("Using --msg-filename.") + return from_commit_msg(str(msg_filename.read())) + + # 2. Any data sent to stdin (unless stdin is being ignored) + if not lint_config.ignore_stdin: + stdin_input = get_stdin_data() + if stdin_input: + LOG.debug("Stdin data: '%s'", stdin_input) + LOG.debug("Stdin detected and not ignored. Using as input.") + return from_commit_msg(stdin_input) + + if lint_config.staged: + raise GitLintUsageError( + "The 'staged' option (--staged) can only be used when using '--msg-filename' or " + "when piping data to gitlint via stdin." + ) + + # 3. Fallback to reading from local repository + LOG.debug("No --msg-filename flag, no or empty data passed to stdin. Using the local repo.") + + if commit_hash and refspec: + raise GitLintUsageError("--commit and --commits are mutually exclusive, use one or the other.") + + # 3.1 Linting a range of commits + if refspec: + # 3.1.1 Not real refspec, but comma-separated list of commit hashes + if "," in refspec: + commit_hashes = [hash.strip() for hash in refspec.split(",") if hash] + return GitContext.from_local_repository(lint_config.target, commit_hashes=commit_hashes) + # 3.1.2 Real refspec + return GitContext.from_local_repository(lint_config.target, refspec=refspec) + + # 3.2 Linting a specific commit + if commit_hash: + return GitContext.from_local_repository(lint_config.target, commit_hashes=[commit_hash]) + + # 3.3 Fallback to linting the current HEAD + return GitContext.from_local_repository(lint_config.target) + + +def handle_gitlint_error(ctx, exc): + """Helper function to handle exceptions""" + if isinstance(exc, GitContextError): + click.echo(exc) + ctx.exit(GIT_CONTEXT_ERROR_CODE) + elif isinstance(exc, GitLintUsageError): + click.echo(f"Error: {exc}") + ctx.exit(USAGE_ERROR_CODE) + elif isinstance(exc, LintConfigError): + click.echo(f"Config Error: {exc}") + ctx.exit(CONFIG_ERROR_CODE) + + +class ContextObj: + """Simple class to hold data that is passed between Click commands via the Click context.""" + + def __init__(self, config, config_builder, commit_hash, refspec, msg_filename, gitcontext=None): + self.config = config + self.config_builder = config_builder + self.commit_hash = commit_hash + self.refspec = refspec + self.msg_filename = msg_filename + self.gitcontext = gitcontext + + +# fmt: off +@click.group(invoke_without_command=True, context_settings={"max_content_width": 120}, + epilog="When no COMMAND is specified, gitlint defaults to 'gitlint lint'.") +@click.option("--target", envvar="GITLINT_TARGET", + type=click.Path(exists=True, resolve_path=True, file_okay=False, readable=True), + help="Path of the target git repository. [default: current working directory]") +@click.option("-C", "--config", envvar="GITLINT_CONFIG", + type=click.Path(exists=True, dir_okay=False, readable=True, resolve_path=True), + help=f"Config file location [default: {DEFAULT_CONFIG_FILE}]") +@click.option("-c", multiple=True, + help="Config flags in format <rule>.<option>=<value> (e.g.: -c T1.line-length=80). " + + "Flag can be used multiple times to set multiple config values.") +@click.option("--commit", envvar="GITLINT_COMMIT", default=None, help="Hash (SHA) of specific commit to lint.") +@click.option("--commits", envvar="GITLINT_COMMITS", default=None, + help="The range of commits (refspec or comma-separated hashes) to lint. [default: HEAD]") +@click.option("-e", "--extra-path", envvar="GITLINT_EXTRA_PATH", + help="Path to a directory or python module with extra user-defined rules", + type=click.Path(exists=True, resolve_path=True, readable=True)) +@click.option("--ignore", envvar="GITLINT_IGNORE", default="", help="Ignore rules (comma-separated by id or name).") +@click.option("--contrib", envvar="GITLINT_CONTRIB", default="", + help="Contrib rules to enable (comma-separated by id or name).") +@click.option("--msg-filename", type=click.File(encoding=gitlint.utils.FILE_ENCODING), + help="Path to a file containing a commit-msg.") +@click.option("--ignore-stdin", envvar="GITLINT_IGNORE_STDIN", is_flag=True, + help="Ignore any stdin data. Useful for running in CI server.") +@click.option("--staged", envvar="GITLINT_STAGED", is_flag=True, + help="Attempt smart guesses about meta info (like author name, email, branch, changed files, etc) " + + "for staged commits.") +@click.option("--fail-without-commits", envvar="GITLINT_FAIL_WITHOUT_COMMITS", is_flag=True, + help="Hard fail when the target commit range is empty.") +@click.option("-v", "--verbose", envvar="GITLINT_VERBOSITY", count=True, default=0, + help="Verbosity, use multiple times for more verbose output (e.g.: -v, -vv, -vvv). [default: -vvv]", ) +@click.option("-s", "--silent", envvar="GITLINT_SILENT", is_flag=True, + help="Silent mode (no output). Takes precedence over -v, -vv, -vvv.") +@click.option("-d", "--debug", envvar="GITLINT_DEBUG", help="Enable debugging output.", is_flag=True) +@click.version_option(version=gitlint.__version__) +@click.pass_context +def cli( + ctx, target, config, c, commit, commits, extra_path, ignore, contrib, + msg_filename, ignore_stdin, staged, fail_without_commits, verbose, + silent, debug, +): + """ Git lint tool, checks your git commit messages for styling issues + + Documentation: http://jorisroovers.github.io/gitlint + """ + try: + if debug: + logging.getLogger("gitlint").setLevel(logging.DEBUG) + DEPRECATED_LOG.setLevel(logging.DEBUG) + LOG.debug("To report issues, please visit https://github.com/jorisroovers/gitlint/issues") + + log_system_info() + + # Get the lint config from the commandline parameters and + # store it in the context (click allows storing an arbitrary object in ctx.obj). + config, config_builder = build_config(target, config, c, extra_path, ignore, contrib, ignore_stdin, + staged, fail_without_commits, verbose, silent, debug) + LOG.debug("Configuration\n%s", config) + + ctx.obj = ContextObj(config, config_builder, commit, commits, msg_filename) + + # If no subcommand is specified, then just lint + if ctx.invoked_subcommand is None: + ctx.invoke(lint) + + except GitlintError as e: + handle_gitlint_error(ctx, e) +# fmt: on + + +@cli.command("lint") +@click.pass_context +def lint(ctx): + """Lints a git repository [default command]""" + lint_config = ctx.obj.config + refspec = ctx.obj.refspec + commit_hash = ctx.obj.commit_hash + msg_filename = ctx.obj.msg_filename + + gitcontext = build_git_context(lint_config, msg_filename, commit_hash, refspec) + # Set gitcontext in the click context, so we can use it in command that are ran after this + # in particular, this is used by run-hook + ctx.obj.gitcontext = gitcontext + + number_of_commits = len(gitcontext.commits) + # Exit if we don't have commits in the specified range. Use a 0 exit code, since a popular use-case is one + # where users are using --commits in a check job to check the commit messages inside a CI job. By returning 0, we + # ensure that these jobs don't fail if for whatever reason the specified commit range is empty. + # This behavior can be overridden by using the --fail-without-commits flag. + if number_of_commits == 0: + LOG.debug('No commits in range "%s"', refspec) + if lint_config.fail_without_commits: + raise GitLintUsageError(f'No commits in range "{refspec}"') + ctx.exit(GITLINT_SUCCESS) + + LOG.debug("Linting %d commit(s)", number_of_commits) + general_config_builder = ctx.obj.config_builder + last_commit = gitcontext.commits[-1] + + # Let's get linting! + first_violation = True + exit_code = GITLINT_SUCCESS + for commit in gitcontext.commits: + # Build a config_builder taking into account the commit specific config (if any) + config_builder = general_config_builder.clone() + config_builder.set_config_from_commit(commit) + + # Create a deepcopy from the original config, so we have a unique config object per commit + # This is important for configuration rules to be able to modifying the config on a per commit basis + commit_config = config_builder.build(copy.deepcopy(lint_config)) + + # Actually do the linting + linter = GitLinter(commit_config) + violations = linter.lint(commit) + # exit code equals the total number of violations in all commits + exit_code += len(violations) + if violations: + # Display the commit hash & new lines intelligently + if number_of_commits > 1 and commit.sha: + commit_separator = "\n" if not first_violation or commit is last_commit else "" + linter.display.e(f"{commit_separator}Commit {commit.sha[:10]}:") + linter.print_violations(violations) + first_violation = False + + # cap actual max exit code because bash doesn't like exit codes larger than 255: + # http://tldp.org/LDP/abs/html/exitcodes.html + exit_code = min(MAX_VIOLATION_ERROR_CODE, exit_code) + LOG.debug("Exit Code = %s", exit_code) + ctx.exit(exit_code) + + +@cli.command("install-hook") +@click.pass_context +def install_hook(ctx): + """Install gitlint as a git commit-msg hook.""" + try: + hooks.GitHookInstaller.install_commit_msg_hook(ctx.obj.config) + hook_path = hooks.GitHookInstaller.commit_msg_hook_path(ctx.obj.config) + click.echo(f"Successfully installed gitlint commit-msg hook in {hook_path}") + ctx.exit(GITLINT_SUCCESS) + except hooks.GitHookInstallerError as e: + click.echo(e, err=True) + ctx.exit(GIT_CONTEXT_ERROR_CODE) + + +@cli.command("uninstall-hook") +@click.pass_context +def uninstall_hook(ctx): + """Uninstall gitlint commit-msg hook.""" + try: + hooks.GitHookInstaller.uninstall_commit_msg_hook(ctx.obj.config) + hook_path = hooks.GitHookInstaller.commit_msg_hook_path(ctx.obj.config) + click.echo(f"Successfully uninstalled gitlint commit-msg hook from {hook_path}") + ctx.exit(GITLINT_SUCCESS) + except hooks.GitHookInstallerError as e: + click.echo(e, err=True) + ctx.exit(GIT_CONTEXT_ERROR_CODE) + + +@cli.command("run-hook") +@click.pass_context +def run_hook(ctx): + """Runs the gitlint commit-msg hook.""" + + exit_code = 1 + while exit_code > 0: + try: + click.echo("gitlint: checking commit message...") + ctx.invoke(lint) + except GitlintError as e: + handle_gitlint_error(ctx, e) + except click.exceptions.Exit as e: + # Flush stderr andstdout, this resolves an issue with output ordering in Cygwin + sys.stderr.flush() + sys.stdout.flush() + + exit_code = e.exit_code + if exit_code == GITLINT_SUCCESS: + click.echo("gitlint: " + click.style("OK", fg="green") + " (no violations in commit message)") + continue + + click.echo("-----------------------------------------------") + click.echo("gitlint: " + click.style("Your commit message contains violations.", fg="red")) + + value = None + while value not in ["y", "n", "e"]: + click.echo( + "Continue with commit anyways (this keeps the current commit message)? [y(es)/n(no)/e(dit)] ", + nl=False, + ) + + # Ideally, we'd want to use click.getchar() or click.prompt() to get user's input here instead of + # input(). However, those functions currently don't support getting answers from stdin. + # This wouldn't be a huge issue since this is unlikely to occur in the real world, + # were it not that we use a stdin to pipe answers into gitlint in our integration tests. + # If that ever changes, we can revisit this. + # Related click pointers: + # - https://github.com/pallets/click/issues/1370 + # - https://github.com/pallets/click/pull/1372 + # - From https://click.palletsprojects.com/en/7.x/utils/#getting-characters-from-terminal + # Note that this function will always read from the terminal, even if stdin is instead a pipe. + value = input() + + if value == "y": + LOG.debug("run-hook: commit message accepted") + exit_code = GITLINT_SUCCESS + elif value == "e": + LOG.debug("run-hook: editing commit message") + msg_filename = ctx.obj.msg_filename + if msg_filename: + msg_filename.seek(0) + editor = os.environ.get("EDITOR", DEFAULT_COMMIT_MSG_EDITOR) + msg_filename_path = os.path.realpath(msg_filename.name) + LOG.debug("run-hook: %s %s", editor, msg_filename_path) + shell(editor + " " + msg_filename_path) + else: + click.echo("Editing only possible when --msg-filename is specified.") + ctx.exit(exit_code) + elif value == "n": + LOG.debug("run-hook: commit message declined") + click.echo("Commit aborted.") + click.echo("Your commit message: ") + click.echo("-----------------------------------------------") + click.echo(ctx.obj.gitcontext.commits[0].message.full) + click.echo("-----------------------------------------------") + ctx.exit(exit_code) + + ctx.exit(exit_code) + + +@cli.command("generate-config") +@click.pass_context +def generate_config(ctx): + """Generates a sample gitlint config file.""" + path = click.prompt("Please specify a location for the sample gitlint config file", default=DEFAULT_CONFIG_FILE) + path = os.path.realpath(path) + dir_name = os.path.dirname(path) + if not os.path.exists(dir_name): + click.echo(f"Error: Directory '{dir_name}' does not exist.", err=True) + ctx.exit(USAGE_ERROR_CODE) + elif os.path.exists(path): + click.echo(f'Error: File "{path}" already exists.', err=True) + ctx.exit(USAGE_ERROR_CODE) + + LintConfigGenerator.generate_config(path) + click.echo(f"Successfully generated {path}") + ctx.exit(GITLINT_SUCCESS) + + +# Let's Party! +setup_logging() +if __name__ == "__main__": + cli() # pragma: no cover diff --git a/gitlint-core/gitlint/config.py b/gitlint-core/gitlint/config.py new file mode 100644 index 0000000..4b38d90 --- /dev/null +++ b/gitlint-core/gitlint/config.py @@ -0,0 +1,561 @@ +import copy +import os +import re +import shutil +from collections import OrderedDict +from configparser import ConfigParser +from configparser import Error as ConfigParserError + +from gitlint import ( + options, + rule_finder, + rules, +) +from gitlint.contrib import rules as contrib_rules +from gitlint.exception import GitlintError +from gitlint.utils import FILE_ENCODING + + +def handle_option_error(func): + """Decorator that calls given method/function and handles any RuleOptionError gracefully by converting it to a + LintConfigError.""" + + def wrapped(*args): + try: + return func(*args) + except options.RuleOptionError as e: + raise LintConfigError(str(e)) from e + + return wrapped + + +class LintConfigError(GitlintError): + pass + + +class LintConfig: + """Class representing gitlint configuration. + Contains active config as well as number of methods to easily get/set the config. + """ + + # Default tuple of rule classes (tuple because immutable). + default_rule_classes = ( + rules.IgnoreByTitle, + rules.IgnoreByBody, + rules.IgnoreBodyLines, + rules.IgnoreByAuthorName, + rules.TitleMaxLength, + rules.TitleTrailingWhitespace, + rules.TitleLeadingWhitespace, + rules.TitleTrailingPunctuation, + rules.TitleHardTab, + rules.TitleMustNotContainWord, + rules.TitleRegexMatches, + rules.TitleMinLength, + rules.BodyMaxLineLength, + rules.BodyMinLength, + rules.BodyMissing, + rules.BodyTrailingWhitespace, + rules.BodyHardTab, + rules.BodyFirstLineEmpty, + rules.BodyChangedFileMention, + rules.BodyRegexMatches, + rules.AuthorValidEmail, + ) + + def __init__(self): + self.rules = RuleCollection(self.default_rule_classes) + self._verbosity = options.IntOption("verbosity", 3, "Verbosity") + self._ignore_merge_commits = options.BoolOption("ignore-merge-commits", True, "Ignore merge commits") + self._ignore_fixup_commits = options.BoolOption("ignore-fixup-commits", True, "Ignore fixup commits") + self._ignore_fixup_amend_commits = options.BoolOption( + "ignore-fixup-amend-commits", True, "Ignore fixup amend commits" + ) + self._ignore_squash_commits = options.BoolOption("ignore-squash-commits", True, "Ignore squash commits") + self._ignore_revert_commits = options.BoolOption("ignore-revert-commits", True, "Ignore revert commits") + self._debug = options.BoolOption("debug", False, "Enable debug mode") + self._extra_path = None + target_description = "Path of the target git repository (default=current working directory)" + self._target = options.PathOption("target", os.path.realpath(os.getcwd()), target_description) + self._ignore = options.ListOption("ignore", [], "List of rule-ids to ignore") + self._contrib = options.ListOption("contrib", [], "List of contrib-rules to enable") + self._config_path = None + ignore_stdin_description = "Ignore any stdin data. Useful for running in CI server." + self._ignore_stdin = options.BoolOption("ignore-stdin", False, ignore_stdin_description) + self._staged = options.BoolOption("staged", False, "Read staged commit meta-info from the local repository.") + self._fail_without_commits = options.BoolOption( + "fail-without-commits", False, "Hard fail when the target commit range is empty" + ) + self._regex_style_search = options.BoolOption( + "regex-style-search", False, "Use `search` instead of `match` semantics for regex rules" + ) + + @property + def target(self): + return self._target.value if self._target else None + + @target.setter + @handle_option_error + def target(self, value): + return self._target.set(value) + + @property + def verbosity(self): + return self._verbosity.value + + @verbosity.setter + @handle_option_error + def verbosity(self, value): + self._verbosity.set(value) + if self.verbosity < 0 or self.verbosity > 3: # noqa: PLR2004 (Magic value used in comparison) + raise LintConfigError("Option 'verbosity' must be set between 0 and 3") + + @property + def ignore_merge_commits(self): + return self._ignore_merge_commits.value + + @ignore_merge_commits.setter + @handle_option_error + def ignore_merge_commits(self, value): + return self._ignore_merge_commits.set(value) + + @property + def ignore_fixup_commits(self): + return self._ignore_fixup_commits.value + + @ignore_fixup_commits.setter + @handle_option_error + def ignore_fixup_commits(self, value): + return self._ignore_fixup_commits.set(value) + + @property + def ignore_fixup_amend_commits(self): + return self._ignore_fixup_amend_commits.value + + @ignore_fixup_amend_commits.setter + @handle_option_error + def ignore_fixup_amend_commits(self, value): + return self._ignore_fixup_amend_commits.set(value) + + @property + def ignore_squash_commits(self): + return self._ignore_squash_commits.value + + @ignore_squash_commits.setter + @handle_option_error + def ignore_squash_commits(self, value): + return self._ignore_squash_commits.set(value) + + @property + def ignore_revert_commits(self): + return self._ignore_revert_commits.value + + @ignore_revert_commits.setter + @handle_option_error + def ignore_revert_commits(self, value): + return self._ignore_revert_commits.set(value) + + @property + def debug(self): + return self._debug.value + + @debug.setter + @handle_option_error + def debug(self, value): + return self._debug.set(value) + + @property + def ignore(self): + return self._ignore.value + + @ignore.setter + def ignore(self, value): + if value == "all": + value = [rule.id for rule in self.rules] + return self._ignore.set(value) + + @property + def ignore_stdin(self): + return self._ignore_stdin.value + + @ignore_stdin.setter + @handle_option_error + def ignore_stdin(self, value): + return self._ignore_stdin.set(value) + + @property + def staged(self): + return self._staged.value + + @staged.setter + @handle_option_error + def staged(self, value): + return self._staged.set(value) + + @property + def fail_without_commits(self): + return self._fail_without_commits.value + + @fail_without_commits.setter + @handle_option_error + def fail_without_commits(self, value): + return self._fail_without_commits.set(value) + + @property + def regex_style_search(self): + return self._regex_style_search.value + + @regex_style_search.setter + @handle_option_error + def regex_style_search(self, value): + return self._regex_style_search.set(value) + + @property + def extra_path(self): + return self._extra_path.value if self._extra_path else None + + @extra_path.setter + def extra_path(self, value): + try: + if self.extra_path: + self._extra_path.set(value) + else: + self._extra_path = options.PathOption( + "extra-path", value, "Path to a directory or module with extra user-defined rules", type="both" + ) + + # Make sure we unload any previously loaded extra-path rules + self.rules.delete_rules_by_attr("is_user_defined", True) + + # Find rules in the new extra-path and add them to the existing rules + rule_classes = rule_finder.find_rule_classes(self.extra_path) + self.rules.add_rules(rule_classes, {"is_user_defined": True}) + + except (options.RuleOptionError, rules.UserRuleError) as e: + raise LintConfigError(str(e)) from e + + @property + def contrib(self): + return self._contrib.value + + @contrib.setter + def contrib(self, value): + try: + self._contrib.set(value) + + # Make sure we unload any previously loaded contrib rules when re-setting the value + self.rules.delete_rules_by_attr("is_contrib", True) + + # Load all classes from the contrib directory + contrib_dir_path = os.path.dirname(os.path.realpath(contrib_rules.__file__)) + rule_classes = rule_finder.find_rule_classes(contrib_dir_path) + + # For each specified contrib rule, check whether it exists among the contrib classes + for rule_id_or_name in self.contrib: + rule_class = next((rc for rc in rule_classes if rule_id_or_name in (rc.id, rc.name)), False) + + # If contrib rule exists, instantiate it and add it to the rules list + if rule_class: + self.rules.add_rule(rule_class, rule_class.id, {"is_contrib": True}) + else: + raise LintConfigError(f"No contrib rule with id or name '{rule_id_or_name}' found.") + + except (options.RuleOptionError, rules.UserRuleError) as e: + raise LintConfigError(str(e)) from e + + def _get_option(self, rule_name_or_id, option_name): + rule = self.rules.find_rule(rule_name_or_id) + if not rule: + raise LintConfigError(f"No such rule '{rule_name_or_id}'") + + option = rule.options.get(option_name) + if not option: + raise LintConfigError(f"Rule '{rule_name_or_id}' has no option '{option_name}'") + + return option + + def get_rule_option(self, rule_name_or_id, option_name): + """Returns the value of a given option for a given rule. LintConfigErrors will be raised if the + rule or option don't exist.""" + option = self._get_option(rule_name_or_id, option_name) + return option.value + + def set_rule_option(self, rule_name_or_id, option_name, option_value): + """Attempts to set a given value for a given option for a given rule. + LintConfigErrors will be raised if the rule or option don't exist or if the value is invalid.""" + option = self._get_option(rule_name_or_id, option_name) + try: + option.set(option_value) + except options.RuleOptionError as e: + msg = f"'{option_value}' is not a valid value for option '{rule_name_or_id}.{option_name}'. {e}." + raise LintConfigError(msg) from e + + def set_general_option(self, option_name, option_value): + attr_name = option_name.replace("-", "_") + # only allow setting general options that exist and don't start with an underscore + if not hasattr(self, attr_name) or attr_name[0] == "_": + raise LintConfigError(f"'{option_name}' is not a valid gitlint option") + + # else + setattr(self, attr_name, option_value) + + def __eq__(self, other): + return ( + isinstance(other, LintConfig) + and self.rules == other.rules + and self.verbosity == other.verbosity + and self.target == other.target + and self.extra_path == other.extra_path + and self.contrib == other.contrib + and self.ignore_merge_commits == other.ignore_merge_commits + and self.ignore_fixup_commits == other.ignore_fixup_commits + and self.ignore_fixup_amend_commits == other.ignore_fixup_amend_commits + and self.ignore_squash_commits == other.ignore_squash_commits + and self.ignore_revert_commits == other.ignore_revert_commits + and self.ignore_stdin == other.ignore_stdin + and self.staged == other.staged + and self.fail_without_commits == other.fail_without_commits + and self.regex_style_search == other.regex_style_search + and self.debug == other.debug + and self.ignore == other.ignore + and self._config_path == other._config_path + ) + + def __str__(self): + # config-path is not a user exposed variable, so don't print it under the general section + return ( + f"config-path: {self._config_path}\n" + "[GENERAL]\n" + f"extra-path: {self.extra_path}\n" + f"contrib: {self.contrib}\n" + f"ignore: {','.join(self.ignore)}\n" + f"ignore-merge-commits: {self.ignore_merge_commits}\n" + f"ignore-fixup-commits: {self.ignore_fixup_commits}\n" + f"ignore-fixup-amend-commits: {self.ignore_fixup_amend_commits}\n" + f"ignore-squash-commits: {self.ignore_squash_commits}\n" + f"ignore-revert-commits: {self.ignore_revert_commits}\n" + f"ignore-stdin: {self.ignore_stdin}\n" + f"staged: {self.staged}\n" + f"fail-without-commits: {self.fail_without_commits}\n" + f"regex-style-search: {self.regex_style_search}\n" + f"verbosity: {self.verbosity}\n" + f"debug: {self.debug}\n" + f"target: {self.target}\n" + f"[RULES]\n{self.rules}" + ) + + +class RuleCollection: + """Class representing an ordered list of rules. Methods are provided to easily retrieve, add or delete rules.""" + + def __init__(self, rule_classes=None, rule_attrs=None): + # Use an ordered dict so that the order in which rules are applied is always the same + self._rules = OrderedDict() + if rule_classes: + self.add_rules(rule_classes, rule_attrs) + + def find_rule(self, rule_id_or_name): + rule = self._rules.get(rule_id_or_name) + # if not found, try finding rule by name + if not rule: + rule = next((rule for rule in self._rules.values() if rule.name == rule_id_or_name), None) + return rule + + def add_rule(self, rule_class, rule_id, rule_attrs=None): + """Instantiates and adds a rule to RuleCollection. + Note: There can be multiple instantiations of the same rule_class in the RuleCollection, as long as the + rule_id is unique. + :param rule_class python class representing the rule + :param rule_id unique identifier for the rule. If not unique, it will + overwrite the existing rule with that id + :param rule_attrs dictionary of attributes to set on the instantiated rule obj + """ + rule_obj = rule_class() + rule_obj.id = rule_id + if rule_attrs: + for key, val in rule_attrs.items(): + setattr(rule_obj, key, val) + self._rules[rule_obj.id] = rule_obj + + def add_rules(self, rule_classes, rule_attrs=None): + """Convenience method to add multiple rules at once based on a list of rule classes.""" + for rule_class in rule_classes: + self.add_rule(rule_class, rule_class.id, rule_attrs) + + def delete_rules_by_attr(self, attr_name, attr_val): + """Deletes all rules from the collection that match a given attribute name and value""" + # Create a new list based on _rules.values() because in python 3, values() is a ValuesView as opposed to a list + # This means you can't modify the ValueView while iterating over it. + for rule in list(self._rules.values()): + if hasattr(rule, attr_name) and (getattr(rule, attr_name) == attr_val): + del self._rules[rule.id] + + def __iter__(self): + yield from self._rules.values() + + def __eq__(self, other): + return isinstance(other, RuleCollection) and self._rules == other._rules + + def __len__(self): + return len(self._rules) + + def __str__(self): + return_str = "" + for rule in self._rules.values(): + return_str += f" {rule.id}: {rule.name}\n" + for option_name, option_value in sorted(rule.options.items()): + if option_value.value is None: + option_val_repr = None + elif isinstance(option_value.value, list): + option_val_repr = ",".join(option_value.value) + elif isinstance(option_value, options.RegexOption): + option_val_repr = option_value.value.pattern + else: + option_val_repr = option_value.value + return_str += f" {option_name}={option_val_repr}\n" + return return_str + + +class LintConfigBuilder: + """Factory class that can build gitlint config. + This is primarily useful to deal with complex configuration scenarios where configuration can be set and overridden + from various sources (typically according to certain precedence rules) before the actual config should be + normalized, validated and build. Example usage can be found in gitlint.cli. + """ + + RULE_QUALIFIER_SYMBOL = ":" + + def __init__(self): + self._config_blueprint = OrderedDict() + self._config_path = None + + def set_option(self, section, option_name, option_value): + if section not in self._config_blueprint: + self._config_blueprint[section] = OrderedDict() + self._config_blueprint[section][option_name] = option_value + + def set_config_from_commit(self, commit): + """Given a git commit, applies config specified in the commit message. + Supported: + - gitlint-ignore: all + """ + for line in commit.message.body: + pattern = re.compile(r"^gitlint-ignore:\s*(.*)") + matches = pattern.match(line) + if matches and len(matches.groups()) == 1: + self.set_option("general", "ignore", matches.group(1)) + + def set_config_from_string_list(self, config_options): + """Given a list of config options of the form "<rule>.<option>=<value>", parses out the correct rule and option + and sets the value accordingly in this factory object.""" + for config_option in config_options: + try: + config_name, option_value = config_option.split("=", 1) + if not option_value: + raise ValueError() + rule_name, option_name = config_name.split(".", 1) + self.set_option(rule_name, option_name, option_value) + except ValueError as e: # raised if the config string is invalid + raise LintConfigError( + f"'{config_option}' is an invalid configuration option. Use '<rule>.<option>=<value>'" + ) from e + + def set_from_config_file(self, filename): + """Loads lint config from an ini-style config file""" + if not os.path.exists(filename): + raise LintConfigError(f"Invalid file path: {filename}") + self._config_path = os.path.realpath(filename) + try: + parser = ConfigParser() + + with open(filename, encoding=FILE_ENCODING) as config_file: + parser.read_file(config_file, filename) + + for section_name in parser.sections(): + for option_name, option_value in parser.items(section_name): + self.set_option(section_name, option_name, str(option_value)) + + except ConfigParserError as e: + raise LintConfigError(str(e)) from e + + def _add_named_rule(self, config, qualified_rule_name): + """Adds a Named Rule to a given LintConfig object. + IMPORTANT: This method does *NOT* overwrite existing Named Rules with the same canonical id. + """ + + # Split up named rule in its parts: the name/id that specifies the parent rule, + # And the name of the rule instance itself + rule_name_parts = qualified_rule_name.split(self.RULE_QUALIFIER_SYMBOL, 1) + rule_name = rule_name_parts[1].strip() + parent_rule_specifier = rule_name_parts[0].strip() + + # assert that the rule name is valid: + # - not empty + # - no whitespace or colons + if rule_name == "" or bool(re.search("\\s|:", rule_name, re.UNICODE)): + msg = f"The rule-name part in '{qualified_rule_name}' cannot contain whitespace, colons or be empty" + raise LintConfigError(msg) + + # find parent rule + parent_rule = config.rules.find_rule(parent_rule_specifier) + if not parent_rule: + msg = f"No such rule '{parent_rule_specifier}' (named rule: '{qualified_rule_name}')" + raise LintConfigError(msg) + + # Determine canonical id and name by recombining the parent id/name and instance name parts. + canonical_id = parent_rule.__class__.id + self.RULE_QUALIFIER_SYMBOL + rule_name + canonical_name = parent_rule.__class__.name + self.RULE_QUALIFIER_SYMBOL + rule_name + + # Add the rule to the collection of rules if it's not there already + if not config.rules.find_rule(canonical_id): + config.rules.add_rule(parent_rule.__class__, canonical_id, {"is_named": True, "name": canonical_name}) + + return canonical_id + + def build(self, config=None): + """Build a real LintConfig object by normalizing and validating the options that were previously set on this + factory.""" + # If we are passed a config object, then rebuild that object instead of building a new lintconfig object from + # scratch + if not config: + config = LintConfig() + + config._config_path = self._config_path + + # Set general options first as this might change the behavior or validity of the other options + general_section = self._config_blueprint.get("general") + if general_section: + for option_name, option_value in general_section.items(): + config.set_general_option(option_name, option_value) + + for section_name, section_dict in self._config_blueprint.items(): + for option_name, option_value in section_dict.items(): + qualified_section_name = section_name + # Skip over the general section, as we've already done that above + if qualified_section_name != "general": + # If the section name contains a colon (:), then this section is defining a Named Rule + # Which means we need to instantiate that Named Rule in the config. + if self.RULE_QUALIFIER_SYMBOL in section_name: + qualified_section_name = self._add_named_rule(config, qualified_section_name) + + config.set_rule_option(qualified_section_name, option_name, option_value) + + return config + + def clone(self): + """Creates an exact copy of a LintConfigBuilder.""" + builder = LintConfigBuilder() + builder._config_blueprint = copy.deepcopy(self._config_blueprint) + builder._config_path = self._config_path + return builder + + +GITLINT_CONFIG_TEMPLATE_SRC_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "files/gitlint") + + +class LintConfigGenerator: + @staticmethod + def generate_config(dest): + """Generates a gitlint config file at the given destination location. + Expects that the given ```dest``` points to a valid destination.""" + shutil.copyfile(GITLINT_CONFIG_TEMPLATE_SRC_PATH, dest) diff --git a/gitlint-core/gitlint/contrib/__init__.py b/gitlint-core/gitlint/contrib/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint-core/gitlint/contrib/__init__.py diff --git a/gitlint-core/gitlint/contrib/rules/__init__.py b/gitlint-core/gitlint/contrib/rules/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint-core/gitlint/contrib/rules/__init__.py diff --git a/gitlint-core/gitlint/contrib/rules/authors_commit.py b/gitlint-core/gitlint/contrib/rules/authors_commit.py new file mode 100644 index 0000000..5c4a150 --- /dev/null +++ b/gitlint-core/gitlint/contrib/rules/authors_commit.py @@ -0,0 +1,45 @@ +import re +from pathlib import Path +from typing import Tuple + +from gitlint.rules import CommitRule, RuleViolation + + +class AllowedAuthors(CommitRule): + """Enforce that only authors listed in the AUTHORS file are allowed to commit.""" + + authors_file_names = ("AUTHORS", "AUTHORS.txt", "AUTHORS.md") + parse_authors = re.compile(r"^(?P<name>.*) <(?P<email>.*)>$", re.MULTILINE) + + name = "contrib-allowed-authors" + + id = "CC3" + + @classmethod + def _read_authors_from_file(cls, git_ctx) -> Tuple[str, str]: + for file_name in cls.authors_file_names: + path = Path(git_ctx.repository_path) / file_name + if path.exists(): + authors_file = path + break + else: + raise FileNotFoundError("No AUTHORS file found!") + + authors_file_content = authors_file.read_text("utf-8") + authors = re.findall(cls.parse_authors, authors_file_content) + + return set(authors), authors_file.name + + def validate(self, commit): + registered_authors, authors_file_name = AllowedAuthors._read_authors_from_file(commit.message.context) + + author = (commit.author_name, commit.author_email.lower()) + + if author not in registered_authors: + return [ + RuleViolation( + self.id, + f"Author not in '{authors_file_name}' file: " f'"{commit.author_name} <{commit.author_email}>"', + ) + ] + return [] diff --git a/gitlint-core/gitlint/contrib/rules/conventional_commit.py b/gitlint-core/gitlint/contrib/rules/conventional_commit.py new file mode 100644 index 0000000..705b083 --- /dev/null +++ b/gitlint-core/gitlint/contrib/rules/conventional_commit.py @@ -0,0 +1,37 @@ +import re + +from gitlint.options import ListOption +from gitlint.rules import CommitMessageTitle, LineRule, RuleViolation + +RULE_REGEX = re.compile(r"([^(]+?)(\([^)]+?\))?!?: .+") + + +class ConventionalCommit(LineRule): + """This rule enforces the spec at https://www.conventionalcommits.org/.""" + + name = "contrib-title-conventional-commits" + id = "CT1" + target = CommitMessageTitle + + options_spec = [ + ListOption( + "types", + ["fix", "feat", "chore", "docs", "style", "refactor", "perf", "test", "revert", "ci", "build"], + "Comma separated list of allowed commit types.", + ) + ] + + def validate(self, line, _commit): + violations = [] + match = RULE_REGEX.match(line) + + if not match: + msg = "Title does not follow ConventionalCommits.org format 'type(optional-scope): description'" + violations.append(RuleViolation(self.id, msg, line)) + else: + line_commit_type = match.group(1) + if line_commit_type not in self.options["types"].value: + opt_str = ", ".join(self.options["types"].value) + violations.append(RuleViolation(self.id, f"Title does not start with one of {opt_str}", line)) + + return violations diff --git a/gitlint-core/gitlint/contrib/rules/disallow_cleanup_commits.py b/gitlint-core/gitlint/contrib/rules/disallow_cleanup_commits.py new file mode 100644 index 0000000..7f62dee --- /dev/null +++ b/gitlint-core/gitlint/contrib/rules/disallow_cleanup_commits.py @@ -0,0 +1,22 @@ +from gitlint.rules import CommitRule, RuleViolation + + +class DisallowCleanupCommits(CommitRule): + """This rule checks the commits for "fixup!"/"squash!"/"amend!" commits + and rejects them. + """ + + name = "contrib-disallow-cleanup-commits" + id = "CC2" + + def validate(self, commit): + if commit.is_fixup_commit: + return [RuleViolation(self.id, "Fixup commits are not allowed", line_nr=1)] + + if commit.is_squash_commit: + return [RuleViolation(self.id, "Squash commits are not allowed", line_nr=1)] + + if commit.is_fixup_amend_commit: + return [RuleViolation(self.id, "Amend commits are not allowed", line_nr=1)] + + return [] diff --git a/gitlint-core/gitlint/contrib/rules/signedoff_by.py b/gitlint-core/gitlint/contrib/rules/signedoff_by.py new file mode 100644 index 0000000..5ea8217 --- /dev/null +++ b/gitlint-core/gitlint/contrib/rules/signedoff_by.py @@ -0,0 +1,17 @@ +from gitlint.rules import CommitRule, RuleViolation + + +class SignedOffBy(CommitRule): + """This rule will enforce that each commit body contains a "Signed-off-by" line. + We keep things simple here and just check whether the commit body contains a line that starts with "Signed-off-by". + """ + + name = "contrib-body-requires-signed-off-by" + id = "CC1" + + def validate(self, commit): + for line in commit.message.body: + if line.lower().startswith("signed-off-by"): + return [] + + return [RuleViolation(self.id, "Body does not contain a 'Signed-off-by' line", line_nr=1)] diff --git a/gitlint-core/gitlint/deprecation.py b/gitlint-core/gitlint/deprecation.py new file mode 100644 index 0000000..b7c2f42 --- /dev/null +++ b/gitlint-core/gitlint/deprecation.py @@ -0,0 +1,39 @@ +import logging + +LOG = logging.getLogger("gitlint.deprecated") +DEPRECATED_LOG_FORMAT = "%(levelname)s: %(message)s" + + +class Deprecation: + """Singleton class that handles deprecation warnings and behavior.""" + + # LintConfig class that is used to determine deprecation behavior + config = None + + # Set of warning messages that have already been logged, to prevent duplicate warnings + warning_msgs = set() + + @classmethod + def get_regex_method(cls, rule, regex_option): + """Returns the regex method to be used for a given rule based on general.regex-style-search option. + Logs a warning if the deprecated re.match method is returned.""" + + # if general.regex-style-search is set, just return re.search + if cls.config.regex_style_search: + return regex_option.value.search + + warning_msg = ( + f"{rule.id} - {rule.name}: gitlint will be switching from using Python regex 'match' (match beginning) to " + "'search' (match anywhere) semantics. " + f"Please review your {rule.name}.regex option accordingly. " + "To remove this warning, set general.regex-style-search=True. " + "More details: https://jorisroovers.github.io/gitlint/configuration/#regex-style-search" + ) + + # Only log warnings once + if warning_msg not in cls.warning_msgs: + log = logging.getLogger("gitlint.deprecated.regex_style_search") + log.warning(warning_msg) + cls.warning_msgs.add(warning_msg) + + return regex_option.value.match diff --git a/gitlint-core/gitlint/display.py b/gitlint-core/gitlint/display.py new file mode 100644 index 0000000..1de8d08 --- /dev/null +++ b/gitlint-core/gitlint/display.py @@ -0,0 +1,36 @@ +from sys import stderr, stdout + + +class Display: + """Utility class to print stuff to an output stream (stdout by default) based on the config's verbosity""" + + def __init__(self, lint_config): + self.config = lint_config + + def _output(self, message, verbosity, exact, stream): + """Output a message if the config's verbosity is >= to the given verbosity. If exact == True, the message + will only be outputted if the given verbosity exactly matches the config's verbosity.""" + if exact: + if self.config.verbosity == verbosity: + stream.write(message + "\n") + else: + if self.config.verbosity >= verbosity: + stream.write(message + "\n") + + def v(self, message, exact=False): + self._output(message, 1, exact, stdout) + + def vv(self, message, exact=False): + self._output(message, 2, exact, stdout) + + def vvv(self, message, exact=False): + self._output(message, 3, exact, stdout) + + def e(self, message, exact=False): + self._output(message, 1, exact, stderr) + + def ee(self, message, exact=False): + self._output(message, 2, exact, stderr) + + def eee(self, message, exact=False): + self._output(message, 3, exact, stderr) diff --git a/gitlint-core/gitlint/exception.py b/gitlint-core/gitlint/exception.py new file mode 100644 index 0000000..d1e8c9c --- /dev/null +++ b/gitlint-core/gitlint/exception.py @@ -0,0 +1,2 @@ +class GitlintError(Exception): + """Based Exception class for all gitlint exceptions""" diff --git a/gitlint-core/gitlint/files/commit-msg b/gitlint-core/gitlint/files/commit-msg new file mode 100644 index 0000000..e754e8d --- /dev/null +++ b/gitlint-core/gitlint/files/commit-msg @@ -0,0 +1,35 @@ +#!/bin/sh +### gitlint commit-msg hook start ### + +# Determine whether we have a tty available by trying to access it. +# This allows us to deal with UI based gitclient's like Atlassian SourceTree. +# NOTE: "exec < /dev/tty" sets stdin to the keyboard +stdin_available=1 +(exec < /dev/tty) 2> /dev/null || stdin_available=0 + +if [ $stdin_available -eq 1 ]; then + # Now that we know we have a functional tty, set stdin to it so we can ask the user questions :-) + exec < /dev/tty + + # On Windows, we need to explicitly set our stdout to the tty to make terminal editing work (e.g. vim) + # See SO for windows detection in bash (slight modified to work on plain shell (not bash)): + # https://stackoverflow.com/questions/394230/how-to-detect-the-os-from-a-bash-script + if [ "$OSTYPE" = "cygwin" ] || [ "$OSTYPE" = "msys" ] || [ "$OSTYPE" = "win32" ]; then + exec > /dev/tty + fi +fi + +gitlint --staged --msg-filename "$1" run-hook +exit_code=$? + +# If we fail to find the gitlint binary (command not found), let's retry by executing as a python module. +# This is the case for Atlassian SourceTree, where $PATH deviates from the user's shell $PATH. +if [ $exit_code -eq 127 ]; then + echo "Fallback to python module execution" + python -m gitlint.cli --staged --msg-filename "$1" run-hook + exit_code=$? +fi + +exit $exit_code + +### gitlint commit-msg hook end ### diff --git a/gitlint-core/gitlint/files/gitlint b/gitlint-core/gitlint/files/gitlint new file mode 100644 index 0000000..3d9f273 --- /dev/null +++ b/gitlint-core/gitlint/files/gitlint @@ -0,0 +1,140 @@ +# Edit this file as you like. +# +# All these sections are optional. Each section with the exception of [general] represents +# one rule and each key in it is an option for that specific rule. +# +# Rules and sections can be referenced by their full name or by id. For example +# section "[body-max-line-length]" could also be written as "[B1]". Full section names are +# used in here for clarity. +# +# [general] +# Ignore certain rules, this example uses both full name and id +# ignore=title-trailing-punctuation, T3 + +# verbosity should be a value between 1 and 3, the commandline -v flags take precedence over this +# verbosity = 2 + +# By default gitlint will ignore merge, revert, fixup, fixup=amend, and squash commits. +# ignore-merge-commits=true +# ignore-revert-commits=true +# ignore-fixup-commits=true +# ignore-fixup-amend-commits=true +# ignore-squash-commits=true + +# Ignore any data sent to gitlint via stdin +# ignore-stdin=true + +# Fetch additional meta-data from the local repository when manually passing a +# commit message to gitlint via stdin or --commit-msg. Disabled by default. +# staged=true + +# Hard fail when the target commit range is empty. Note that gitlint will +# already fail by default on invalid commit ranges. This option is specifically +# to tell gitlint to fail on *valid but empty* commit ranges. +# Disabled by default. +# fail-without-commits=true + +# Whether to use Python `search` instead of `match` semantics in rules that use +# regexes. Context: https://github.com/jorisroovers/gitlint/issues/254 +# Disabled by default, but will be enabled by default in the future. +# regex-style-search=true + +# Enable debug mode (prints more output). Disabled by default. +# debug=true + +# Enable community contributed rules +# See http://jorisroovers.github.io/gitlint/contrib_rules for details +# contrib=contrib-title-conventional-commits,CC1 + +# Set the extra-path where gitlint will search for user defined rules +# See http://jorisroovers.github.io/gitlint/user_defined_rules for details +# extra-path=examples/ + +# This is an example of how to configure the "title-max-length" rule and +# set the line-length it enforces to 50 +# [title-max-length] +# line-length=50 + +# Conversely, you can also enforce minimal length of a title with the +# "title-min-length" rule: +# [title-min-length] +# min-length=5 + +# [title-must-not-contain-word] +# Comma-separated list of words that should not occur in the title. Matching is case +# insensitive. It's fine if the keyword occurs as part of a larger word (so "WIPING" +# will not cause a violation, but "WIP: my title" will. +# words=wip + +# [title-match-regex] +# python-style regex that the commit-msg title must match +# Note that the regex can contradict with other rules if not used correctly +# (e.g. title-must-not-contain-word). +# regex=^US[0-9]* + +# [body-max-line-length] +# line-length=72 + +# [body-min-length] +# min-length=5 + +# [body-is-missing] +# Whether to ignore this rule on merge commits (which typically only have a title) +# default = True +# ignore-merge-commits=false + +# [body-changed-file-mention] +# List of files that need to be explicitly mentioned in the body when they are changed +# This is useful for when developers often erroneously edit certain files or git submodules. +# By specifying this rule, developers can only change the file when they explicitly reference +# it in the commit message. +# files=gitlint-core/gitlint/rules.py,README.md + +# [body-match-regex] +# python-style regex that the commit-msg body must match. +# E.g. body must end in My-Commit-Tag: foo +# regex=My-Commit-Tag: foo$ + +# [author-valid-email] +# python-style regex that the commit author email address must match. +# For example, use the following regex if you only want to allow email addresses from foo.com +# regex=[^@]+@foo.com + +# [ignore-by-title] +# Ignore certain rules for commits of which the title matches a regex +# E.g. Match commit titles that start with "Release" +# regex=^Release(.*) + +# Ignore certain rules, you can reference them by their id or by their full name +# Use 'all' to ignore all rules +# ignore=T1,body-min-length + +# [ignore-by-body] +# Ignore certain rules for commits of which the body has a line that matches a regex +# E.g. Match bodies that have a line that that contain "release" +# regex=(.*)release(.*) +# +# Ignore certain rules, you can reference them by their id or by their full name +# Use 'all' to ignore all rules +# ignore=T1,body-min-length + +# [ignore-body-lines] +# Ignore certain lines in a commit body that match a regex. +# E.g. Ignore all lines that start with 'Co-Authored-By' +# regex=^Co-Authored-By + +# [ignore-by-author-name] +# Ignore certain rules for commits of which the author name matches a regex +# E.g. Match commits made by dependabot +# regex=(.*)dependabot(.*) +# +# Ignore certain rules, you can reference them by their id or by their full name +# Use 'all' to ignore all rules +# ignore=T1,body-min-length + +# This is a contrib rule - a community contributed rule. These are disabled by default. +# You need to explicitly enable them one-by-one by adding them to the "contrib" option +# under [general] section above. +# [contrib-title-conventional-commits] +# Specify allowed commit types. For details see: https://www.conventionalcommits.org/ +# types = bugfix,user-story,epic diff --git a/gitlint-core/gitlint/git.py b/gitlint-core/gitlint/git.py new file mode 100644 index 0000000..6612a7d --- /dev/null +++ b/gitlint-core/gitlint/git.py @@ -0,0 +1,510 @@ +import logging +import os +from pathlib import Path + +import arrow + +from gitlint import shell as sh +from gitlint.cache import PropertyCache, cache +from gitlint.exception import GitlintError + +# import exceptions separately, this makes it a little easier to mock them out in the unit tests +from gitlint.shell import CommandNotFound, ErrorReturnCode + +# For now, the git date format we use is fixed, but technically this format is determined by `git config log.date` +# We should fix this at some point :-) +GIT_TIMEFORMAT = "YYYY-MM-DD HH:mm:ss Z" + +LOG = logging.getLogger(__name__) + + +class GitContextError(GitlintError): + """Exception indicating there is an issue with the git context""" + + +class GitNotInstalledError(GitContextError): + def __init__(self): + super().__init__( + "'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." + ) + + +class GitExitCodeError(GitContextError): + def __init__(self, command, stderr): + self.command = command + self.stderr = stderr + super().__init__(f"An error occurred while executing '{command}': {stderr}") + + +def _git(*command_parts, **kwargs): + """Convenience function for running git commands. Automatically deals with exceptions and unicode.""" + git_kwargs = {"_tty_out": False} + git_kwargs.update(kwargs) + try: + LOG.debug(command_parts) + result = sh.git(*command_parts, **git_kwargs) + # If we reach this point and the result has an exit_code that is larger than 0, this means that we didn't + # get an exception (which is the default sh behavior for non-zero exit codes) and so the user is expecting + # a non-zero exit code -> just return the entire result + if hasattr(result, "exit_code") and result.exit_code > 0: + return result + return str(result) + except CommandNotFound as e: + raise GitNotInstalledError from e + except ErrorReturnCode as e: # Something went wrong while executing the git command + error_msg = e.stderr.strip() + error_msg_lower = error_msg.lower() + if "_cwd" in git_kwargs and b"not a git repository" in error_msg_lower: + raise GitContextError(f"{git_kwargs['_cwd']} is not a git repository.") from e + + if ( + b"does not have any commits yet" in error_msg_lower + or b"ambiguous argument 'head': unknown revision" in error_msg_lower + ): + msg = "Current branch has no commits. Gitlint requires at least one commit to function." + raise GitContextError(msg) from e + + raise GitExitCodeError(e.full_cmd, error_msg) from e + + +def git_version(): + """Determine the git version installed on this host by calling git --version""" + return _git("--version").replace("\n", "") + + +def git_commentchar(repository_path=None): + """Shortcut for retrieving comment char from git config""" + commentchar = _git("config", "--get", "core.commentchar", _cwd=repository_path, _ok_code=[0, 1]) + # git will return an exit code of 1 if it can't find a config value, in this case we fall-back to # as commentchar + if hasattr(commentchar, "exit_code") and commentchar.exit_code == 1: + commentchar = "#" + return commentchar.replace("\n", "") + + +def git_hooks_dir(repository_path): + """Determine hooks directory for a given target dir""" + hooks_dir = _git("rev-parse", "--git-path", "hooks", _cwd=repository_path) + hooks_dir = hooks_dir.replace("\n", "") + return os.path.realpath(os.path.join(repository_path, hooks_dir)) + + +def _parse_git_changed_file_stats(changed_files_stats_raw): + """Parse the output of git diff --numstat and return a dict of: + dict[filename: GitChangedFileStats(filename, additions, deletions)]""" + changed_files_stats_lines = changed_files_stats_raw.split("\n") + changed_files_stats = {} + for line in changed_files_stats_lines[:-1]: # drop last empty line + line_stats = line.split() + + # If the file is binary, numstat will show "-" + # See https://git-scm.com/docs/git-diff#Documentation/git-diff.txt---numstat + additions = int(line_stats[0]) if line_stats[0] != "-" else None + deletions = int(line_stats[1]) if line_stats[1] != "-" else None + + changed_file_stat = GitChangedFileStats(line_stats[2], additions, deletions) + changed_files_stats[line_stats[2]] = changed_file_stat + + return changed_files_stats + + +class GitCommitMessage: + """Class representing a git commit message. A commit message consists of the following: + - context: The `GitContext` this commit message is part of + - original: The actual commit message as returned by `git log` + - full: original, but stripped of any comments + - title: the first line of full + - body: all lines following the title + """ + + def __init__(self, context, original=None, full=None, title=None, body=None): + self.context = context + self.original = original + self.full = full + self.title = title + self.body = body + + @staticmethod + def from_full_message(context, commit_msg_str): + """Parses a full git commit message by parsing a given string into the different parts of a commit message""" + all_lines = commit_msg_str.splitlines() + cutline = f"{context.commentchar} ------------------------ >8 ------------------------" + try: + cutline_index = all_lines.index(cutline) + except ValueError: + cutline_index = None + lines = [line for line in all_lines[:cutline_index] if not line.startswith(context.commentchar)] + full = "\n".join(lines) + title = lines[0] if lines else "" + body = lines[1:] if len(lines) > 1 else [] + return GitCommitMessage(context=context, original=commit_msg_str, full=full, title=title, body=body) + + def __str__(self): + return self.full + + def __eq__(self, other): + return ( + isinstance(other, GitCommitMessage) + and self.original == other.original + and self.full == other.full + and self.title == other.title + and self.body == other.body + ) + + +class GitChangedFileStats: + """Class representing the stats for a changed file in git""" + + def __init__(self, filepath, additions, deletions): + self.filepath = Path(filepath) + self.additions = additions + self.deletions = deletions + + def __eq__(self, other): + return ( + isinstance(other, GitChangedFileStats) + and self.filepath == other.filepath + and self.additions == other.additions + and self.deletions == other.deletions + ) + + def __str__(self) -> str: + return f"{self.filepath}: {self.additions} additions, {self.deletions} deletions" + + +class GitCommit: + """Class representing a git commit. + A commit consists of: context, message, author name, author email, date, list of parent commit shas, + list of changed files, list of branch names. + In the context of gitlint, only the git context and commit message are required. + """ + + def __init__( + self, + context, + message, + sha=None, + date=None, + author_name=None, + author_email=None, + parents=None, + changed_files_stats=None, + branches=None, + ): + self.context = context + self.message = message + self.sha = sha + self.date = date + self.author_name = author_name + self.author_email = author_email + self.parents = parents or [] # parent commit hashes + self.changed_files_stats = changed_files_stats or {} + self.branches = branches or [] + + @property + def is_merge_commit(self): + return self.message.title.startswith("Merge") + + @property + def is_fixup_commit(self): + return self.message.title.startswith("fixup!") + + @property + def is_squash_commit(self): + return self.message.title.startswith("squash!") + + @property + def is_fixup_amend_commit(self): + return self.message.title.startswith("amend!") + + @property + def is_revert_commit(self): + return self.message.title.startswith("Revert") + + @property + def changed_files(self): + return list(self.changed_files_stats.keys()) + + def __str__(self): + date_str = arrow.get(self.date).format(GIT_TIMEFORMAT) if self.date else None + + if len(self.changed_files_stats) > 0: + changed_files_stats_str = "\n " + "\n ".join([str(stats) for stats in self.changed_files_stats.values()]) + else: + changed_files_stats_str = " {}" + + return ( + f"--- Commit Message ----\n{self.message}\n" + "--- Meta info ---------\n" + f"Author: {self.author_name} <{self.author_email}>\n" + f"Date: {date_str}\n" + f"is-merge-commit: {self.is_merge_commit}\n" + f"is-fixup-commit: {self.is_fixup_commit}\n" + f"is-fixup-amend-commit: {self.is_fixup_amend_commit}\n" + f"is-squash-commit: {self.is_squash_commit}\n" + f"is-revert-commit: {self.is_revert_commit}\n" + f"Parents: {self.parents}\n" + f"Branches: {self.branches}\n" + f"Changed Files: {self.changed_files}\n" + f"Changed Files Stats:{changed_files_stats_str}\n" + "-----------------------" + ) + + def __eq__(self, other): + # skip checking the context as context refers back to this obj, this will trigger a cyclic dependency + return ( + isinstance(other, GitCommit) + and self.message == other.message + and self.sha == other.sha + and self.author_name == other.author_name + and self.author_email == other.author_email + and self.date == other.date + and self.parents == other.parents + and self.is_merge_commit == other.is_merge_commit + and self.is_fixup_commit == other.is_fixup_commit + and self.is_fixup_amend_commit == other.is_fixup_amend_commit + and self.is_squash_commit == other.is_squash_commit + and self.is_revert_commit == other.is_revert_commit + and self.changed_files == other.changed_files + and self.changed_files_stats == other.changed_files_stats + and self.branches == other.branches + ) + + +class LocalGitCommit(GitCommit, PropertyCache): + """Class representing a git commit that exists in the local git repository. + This class uses lazy loading: it defers reading information from the local git repository until the associated + property is accessed for the first time. Properties are then cached for subsequent access. + + This approach ensures that we don't do 'expensive' git calls when certain properties are not actually used. + In addition, reading the required info when it's needed rather than up front avoids adding delay during gitlint + startup time and reduces gitlint's memory footprint. + """ + + def __init__(self, context, sha): + PropertyCache.__init__(self) + self.context = context + self.sha = sha + + def _log(self): + """Does a call to `git log` to determine a bunch of information about the commit.""" + long_format = "--pretty=%aN%x00%aE%x00%ai%x00%P%n%B" + raw_commit = _git("log", self.sha, "-1", long_format, _cwd=self.context.repository_path).split("\n") + + (name, email, date, parents), commit_msg = raw_commit[0].split("\x00"), "\n".join(raw_commit[1:]) + + commit_parents = [] if parents == "" else parents.split(" ") + commit_is_merge_commit = len(commit_parents) > 1 + + # "YYYY-MM-DD HH:mm:ss Z" -> ISO 8601-like format + # Use arrow for datetime parsing, because apparently python is quirky around ISO-8601 dates: + # http://stackoverflow.com/a/30696682/381010 + commit_date = arrow.get(date, GIT_TIMEFORMAT).datetime + + # Create Git commit object with the retrieved info + commit_msg_obj = GitCommitMessage.from_full_message(self.context, commit_msg) + + self._cache.update( + { + "message": commit_msg_obj, + "author_name": name, + "author_email": email, + "date": commit_date, + "parents": commit_parents, + "is_merge_commit": commit_is_merge_commit, + } + ) + + @property + def message(self): + return self._try_cache("message", self._log) + + @property + def author_name(self): + return self._try_cache("author_name", self._log) + + @property + def author_email(self): + return self._try_cache("author_email", self._log) + + @property + def date(self): + return self._try_cache("date", self._log) + + @property + def parents(self): + return self._try_cache("parents", self._log) + + @property + def branches(self): + def cache_branches(): + # We have to parse 'git branch --contains <sha>' instead of 'git for-each-ref' to be compatible with + # git versions < 2.7.0 + # https://stackoverflow.com/questions/45173979/can-i-force-git-branch-contains-tag-to-not-print-the-asterisk + branches = _git("branch", "--contains", self.sha, _cwd=self.context.repository_path).split("\n") + + # This means that we need to remove any leading * that indicates the current branch. Note that we can + # safely do this since git branches cannot contain '*' anywhere, so if we find an '*' we know it's output + # from the git CLI and not part of the branch name. See https://git-scm.com/docs/git-check-ref-format + # We also drop the last empty line from the output. + self._cache["branches"] = [branch.replace("*", "").strip() for branch in branches[:-1]] + + return self._try_cache("branches", cache_branches) + + @property + def is_merge_commit(self): + return self._try_cache("is_merge_commit", self._log) + + @property + def changed_files_stats(self): + def cache_changed_files_stats(): + changed_files_stats_raw = _git( + "diff-tree", "--no-commit-id", "--numstat", "-r", "--root", self.sha, _cwd=self.context.repository_path + ) + self._cache["changed_files_stats"] = _parse_git_changed_file_stats(changed_files_stats_raw) + + return self._try_cache("changed_files_stats", cache_changed_files_stats) + + +class StagedLocalGitCommit(GitCommit, PropertyCache): + """Class representing a git commit that has been staged, but not committed. + + Other than the commit message itself (and changed files), a lot of information is actually not known at staging + time, since the commit hasn't happened yet. However, we can make educated guesses based on existing repository + information. + """ + + def __init__(self, context, commit_message): + PropertyCache.__init__(self) + self.context = context + self.message = commit_message + self.sha = None + self.parents = [] # Not really possible to determine before a commit + + @property + @cache + def author_name(self): + try: + return _git("config", "--get", "user.name", _cwd=self.context.repository_path).strip() + except GitExitCodeError as e: + raise GitContextError("Missing git configuration: please set user.name") from e + + @property + @cache + def author_email(self): + try: + return _git("config", "--get", "user.email", _cwd=self.context.repository_path).strip() + except GitExitCodeError as e: + raise GitContextError("Missing git configuration: please set user.email") from e + + @property + @cache + def date(self): + # We don't know the actual commit date yet, but we make a pragmatic trade-off here by providing the current date + # We get current date from arrow, reformat in git date format, then re-interpret it as a date. + # This ensure we capture the same precision and timezone information that git does. + return arrow.get(arrow.now().format(GIT_TIMEFORMAT), GIT_TIMEFORMAT).datetime + + @property + @cache + def branches(self): + # We don't know the branch this commit will be part of yet, but we're pragmatic here and just return the + # current branch, as for all intents and purposes, this will be what the user is looking for. + return [self.context.current_branch] + + @property + def changed_files_stats(self): + def cache_changed_files_stats(): + changed_files_stats_raw = _git("diff", "--staged", "--numstat", "-r", _cwd=self.context.repository_path) + self._cache["changed_files_stats"] = _parse_git_changed_file_stats(changed_files_stats_raw) + + return self._try_cache("changed_files_stats", cache_changed_files_stats) + + +class GitContext(PropertyCache): + """Class representing the git context in which gitlint is operating: a data object storing information about + the git repository that gitlint is linting. + """ + + def __init__(self, repository_path=None): + PropertyCache.__init__(self) + self.commits = [] + self.repository_path = repository_path + + @property + @cache + def commentchar(self): + return git_commentchar(self.repository_path) + + @property + @cache + def current_branch(self): + try: + current_branch = _git("rev-parse", "--abbrev-ref", "HEAD", _cwd=self.repository_path).strip() + except GitContextError: + # Maybe there is no commit. Try another way to get current branch (need Git 2.22+) + current_branch = _git("branch", "--show-current", _cwd=self.repository_path).strip() + return current_branch + + @staticmethod + def from_commit_msg(commit_msg_str): + """Determines git context based on a commit message. + :param commit_msg_str: Full git commit message. + """ + context = GitContext() + commit_msg_obj = GitCommitMessage.from_full_message(context, commit_msg_str) + commit = GitCommit(context, commit_msg_obj) + context.commits.append(commit) + return context + + @staticmethod + def from_staged_commit(commit_msg_str, repository_path): + """Determines git context based on a commit message that is a staged commit for a local git repository. + :param commit_msg_str: Full git commit message. + :param repository_path: Path to the git repository to retrieve the context from + """ + context = GitContext(repository_path=repository_path) + commit_msg_obj = GitCommitMessage.from_full_message(context, commit_msg_str) + commit = StagedLocalGitCommit(context, commit_msg_obj) + context.commits.append(commit) + return context + + @staticmethod + def from_local_repository(repository_path, refspec=None, commit_hashes=None): + """Retrieves the git context from a local git repository. + :param repository_path: Path to the git repository to retrieve the context from + :param refspec: The commit(s) to retrieve (mutually exclusive with `commit_hash`) + :param commit_hash: Hash of the commit to retrieve (mutually exclusive with `refspec`) + """ + + context = GitContext(repository_path=repository_path) + + if refspec: + sha_list = _git("rev-list", refspec, _cwd=repository_path).split() + elif commit_hashes: # One or more commit hashes, just pass it to `git log -1` + # Even though we have already been passed the commit hash, we ask git to retrieve this hash and + # return it to us. This way we verify that the passed hash is a valid hash for the target repo and we + # also convert it to the full hash format (we might have been passed a short hash). + sha_list = [] + for commit_hash in commit_hashes: + sha_list.append(_git("log", "-1", commit_hash, "--pretty=%H", _cwd=repository_path).replace("\n", "")) + else: # If no refspec is defined, fallback to the last commit on the current branch + # We tried many things here e.g.: defaulting to e.g. HEAD or HEAD^... (incl. dealing with + # repos that only have a single commit - HEAD^... doesn't work there), but then we still get into + # problems with e.g. merge commits. Easiest solution is just taking the SHA from `git log -1`. + sha_list = [_git("log", "-1", "--pretty=%H", _cwd=repository_path).replace("\n", "")] + + for sha in sha_list: + commit = LocalGitCommit(context, sha) + context.commits.append(commit) + + return context + + def __eq__(self, other): + return ( + isinstance(other, GitContext) + and self.commits == other.commits + and self.repository_path == other.repository_path + and self.commentchar == other.commentchar + and self.current_branch == other.current_branch + ) diff --git a/gitlint-core/gitlint/hooks.py b/gitlint-core/gitlint/hooks.py new file mode 100644 index 0000000..98ded18 --- /dev/null +++ b/gitlint-core/gitlint/hooks.py @@ -0,0 +1,65 @@ +import os +import shutil +import stat + +from gitlint.exception import GitlintError +from gitlint.git import git_hooks_dir +from gitlint.utils import FILE_ENCODING + +COMMIT_MSG_HOOK_SRC_PATH = os.path.join(os.path.dirname(os.path.realpath(__file__)), "files", "commit-msg") +COMMIT_MSG_HOOK_DST_PATH = "commit-msg" +GITLINT_HOOK_IDENTIFIER = "### gitlint commit-msg hook start ###\n" + + +class GitHookInstallerError(GitlintError): + pass + + +class GitHookInstaller: + """Utility class that provides methods for installing and uninstalling the gitlint commitmsg hook.""" + + @staticmethod + def commit_msg_hook_path(lint_config): + return os.path.join(git_hooks_dir(lint_config.target), COMMIT_MSG_HOOK_DST_PATH) + + @staticmethod + def _assert_git_repo(target): + """Asserts that a given target directory is a git repository""" + hooks_dir = git_hooks_dir(target) + if not os.path.isdir(hooks_dir): + raise GitHookInstallerError(f"{target} is not a git repository.") + + @staticmethod + def install_commit_msg_hook(lint_config): + GitHookInstaller._assert_git_repo(lint_config.target) + dest_path = GitHookInstaller.commit_msg_hook_path(lint_config) + if os.path.exists(dest_path): + raise GitHookInstallerError( + f"There is already a commit-msg hook file present in {dest_path}.\n" + "gitlint currently does not support appending to an existing commit-msg file." + ) + + # copy hook file + shutil.copy(COMMIT_MSG_HOOK_SRC_PATH, dest_path) + # make hook executable + st = os.stat(dest_path) + os.chmod(dest_path, st.st_mode | stat.S_IEXEC) + + @staticmethod + def uninstall_commit_msg_hook(lint_config): + GitHookInstaller._assert_git_repo(lint_config.target) + dest_path = GitHookInstaller.commit_msg_hook_path(lint_config) + if not os.path.exists(dest_path): + raise GitHookInstallerError(f"There is no commit-msg hook present in {dest_path}.") + + with open(dest_path, encoding=FILE_ENCODING) as fp: + lines = fp.readlines() + if len(lines) < 2 or lines[1] != GITLINT_HOOK_IDENTIFIER: # noqa: PLR2004 (Magic value used in comparison) + msg = ( + f"The commit-msg hook in {dest_path} was not installed by gitlint (or it was modified).\n" + "Uninstallation of 3th party or modified gitlint hooks is not supported." + ) + raise GitHookInstallerError(msg) + + # If we are sure it's a gitlint hook, go ahead and remove it + os.remove(dest_path) diff --git a/gitlint-core/gitlint/lint.py b/gitlint-core/gitlint/lint.py new file mode 100644 index 0000000..420d3ad --- /dev/null +++ b/gitlint-core/gitlint/lint.py @@ -0,0 +1,123 @@ +import logging + +from gitlint import display +from gitlint import rules as gitlint_rules +from gitlint.deprecation import Deprecation + +LOG = logging.getLogger(__name__) +logging.basicConfig() + + +class GitLinter: + """Main linter class. This is where rules actually get applied. See the lint() method.""" + + def __init__(self, config): + self.config = config + + self.display = display.Display(config) + + def should_ignore_rule(self, rule): + """Determines whether a rule should be ignored based on the general list of commits to ignore""" + return rule.id in self.config.ignore or rule.name in self.config.ignore + + @property + def configuration_rules(self): + return [ + rule + for rule in self.config.rules + if isinstance(rule, gitlint_rules.ConfigurationRule) and not self.should_ignore_rule(rule) + ] + + @property + def title_line_rules(self): + return [ + rule + for rule in self.config.rules + if isinstance(rule, gitlint_rules.LineRule) + and rule.target == gitlint_rules.CommitMessageTitle + and not self.should_ignore_rule(rule) + ] + + @property + def body_line_rules(self): + return [ + rule + for rule in self.config.rules + if isinstance(rule, gitlint_rules.LineRule) + and rule.target == gitlint_rules.CommitMessageBody + and not self.should_ignore_rule(rule) + ] + + @property + def commit_rules(self): + return [ + rule + for rule in self.config.rules + if isinstance(rule, gitlint_rules.CommitRule) and not self.should_ignore_rule(rule) + ] + + @staticmethod + def _apply_line_rules(lines, commit, rules, line_nr_start): + """Iterates over the lines in a given list of lines and validates a given list of rules against each line""" + all_violations = [] + line_nr = line_nr_start + for line in lines: + for rule in rules: + violations = rule.validate(line, commit) + if violations: + for violation in violations: + violation.line_nr = line_nr + all_violations.append(violation) + line_nr += 1 + return all_violations + + @staticmethod + def _apply_commit_rules(rules, commit): + """Applies a set of rules against a given commit and gitcontext""" + all_violations = [] + for rule in rules: + violations = rule.validate(commit) + if violations: + all_violations.extend(violations) + return all_violations + + def lint(self, commit): + """Lint the last commit in a given git context by applying all ignore, title, body and commit rules.""" + LOG.debug("Linting commit %s", commit.sha or "[SHA UNKNOWN]") + LOG.debug("Commit Object\n" + str(commit)) + + # Ensure the Deprecation class has a reference to the config currently being used + Deprecation.config = self.config + + # Apply config rules + for rule in self.configuration_rules: + rule.apply(self.config, commit) + + # Skip linting if this is a special commit type that is configured to be ignored + ignore_commit_types = ["merge", "squash", "fixup", "fixup_amend", "revert"] + for commit_type in ignore_commit_types: + if getattr(commit, f"is_{commit_type}_commit") and getattr(self.config, f"ignore_{commit_type}_commits"): + return [] + + violations = [] + # determine violations by applying all rules + violations.extend(self._apply_line_rules([commit.message.title], commit, self.title_line_rules, 1)) + violations.extend(self._apply_line_rules(commit.message.body, commit, self.body_line_rules, 2)) + violations.extend(self._apply_commit_rules(self.commit_rules, commit)) + + # Sort violations by line number and rule_id. If there's no line nr specified (=common certain commit rules), + # we replace None with -1 so that it always get's placed first. Note that we need this to do this to support + # python 3, as None is not allowed in a list that is being sorted. + violations.sort(key=lambda v: (-1 if v.line_nr is None else v.line_nr, v.rule_id)) + return violations + + def print_violations(self, violations): + """Print a given set of violations to the standard error output""" + for v in violations: + line_nr = v.line_nr if v.line_nr else "-" + self.display.e(f"{line_nr}: {v.rule_id}", exact=True) + self.display.ee(f"{line_nr}: {v.rule_id} {v.message}", exact=True) + if v.content: + self.display.eee(f'{line_nr}: {v.rule_id} {v.message}: "{v.content}"', exact=True) + else: + self.display.eee(f"{line_nr}: {v.rule_id} {v.message}", exact=True) diff --git a/gitlint-core/gitlint/options.py b/gitlint-core/gitlint/options.py new file mode 100644 index 0000000..ff7d9f1 --- /dev/null +++ b/gitlint-core/gitlint/options.py @@ -0,0 +1,146 @@ +import os +import re +from abc import abstractmethod + +from gitlint.exception import GitlintError + + +def allow_none(func): + """Decorator that sets option value to None if the passed value is None, otherwise calls the regular set method""" + + def wrapped(obj, value): + if value is None: + obj.value = None + else: + func(obj, value) + + return wrapped + + +class RuleOptionError(GitlintError): + pass + + +class RuleOption: + """Base class representing a configurable part (i.e. option) of a rule (e.g. the max-length of the title-max-line + rule). + This class should not be used directly. Instead, use on the derived classes like StrOption, IntOption to set + options of a particular type like int, str, etc. + """ + + def __init__(self, name, value, description): + self.name = name + self.description = description + self.value = None + self.set(value) + + @abstractmethod + def set(self, value): + """Validates and sets the option's value""" + + def __str__(self): + return f"({self.name}: {self.value} ({self.description}))" + + def __eq__(self, other): + return self.name == other.name and self.description == other.description and self.value == other.value + + +class StrOption(RuleOption): + @allow_none + def set(self, value): + self.value = str(value) + + +class IntOption(RuleOption): + def __init__(self, name, value, description, allow_negative=False): + self.allow_negative = allow_negative + super().__init__(name, value, description) + + def _raise_exception(self, value): + if self.allow_negative: + error_msg = f"Option '{self.name}' must be an integer (current value: '{value}')" + else: + error_msg = f"Option '{self.name}' must be a positive integer (current value: '{value}')" + raise RuleOptionError(error_msg) + + @allow_none + def set(self, value): + try: + self.value = int(value) + except ValueError: + self._raise_exception(value) + + if not self.allow_negative and self.value < 0: + self._raise_exception(value) + + +class BoolOption(RuleOption): + # explicit choice to not annotate with @allow_none: Booleans must be False or True, they cannot be unset. + def set(self, value): + value = str(value).strip().lower() + if value not in ["true", "false"]: + raise RuleOptionError(f"Option '{self.name}' must be either 'true' or 'false'") + self.value = value == "true" + + +class ListOption(RuleOption): + """Option that is either a given list or a comma-separated string that can be split into a list when being set.""" + + @allow_none + def set(self, value): + if isinstance(value, list): + the_list = value + else: + the_list = str(value).split(",") + + self.value = [str(item.strip()) for item in the_list if item.strip() != ""] + + +class PathOption(RuleOption): + """Option that accepts either a directory or both a directory and a file.""" + + def __init__(self, name, value, description, type="dir"): + self.type = type + super().__init__(name, value, description) + + @allow_none + def set(self, value): + value = str(value) + + error_msg = "" + + if self.type == "dir": + if not os.path.isdir(value): + error_msg = f"Option {self.name} must be an existing directory (current value: '{value}')" + elif self.type == "file": + if not os.path.isfile(value): + error_msg = f"Option {self.name} must be an existing file (current value: '{value}')" + elif self.type == "both": + if not os.path.isdir(value) and not os.path.isfile(value): + error_msg = ( + f"Option {self.name} must be either an existing directory or file (current value: '{value}')" + ) + else: + error_msg = f"Option {self.name} type must be one of: 'file', 'dir', 'both' (current: '{self.type}')" + + if error_msg: + raise RuleOptionError(error_msg) + + self.value = os.path.realpath(value) + + +class RegexOption(RuleOption): + @allow_none + def set(self, value): + try: + self.value = re.compile(value, re.UNICODE) + except (re.error, TypeError) as exc: + raise RuleOptionError(f"Invalid regular expression: '{exc}'") from exc + + def __deepcopy__(self, _): + # copy.deepcopy() - used in rules.py - doesn't support copying regex objects prior to Python 3.7 + # To work around this, we have to implement this __deepcopy__ magic method + # Relevant SO thread: + # https://stackoverflow.com/questions/6279305/typeerror-cannot-deepcopy-this-pattern-object + value = None if self.value is None else self.value.pattern + return RegexOption(self.name, value, self.description) diff --git a/gitlint-core/gitlint/rule_finder.py b/gitlint-core/gitlint/rule_finder.py new file mode 100644 index 0000000..810faa9 --- /dev/null +++ b/gitlint-core/gitlint/rule_finder.py @@ -0,0 +1,155 @@ +import fnmatch +import importlib +import inspect +import os +import sys + +from gitlint import options, rules + + +def find_rule_classes(extra_path): + """ + Searches a given directory or python module for rule classes. This is done by + adding the directory path to the python path, importing the modules and then finding + any Rule class in those modules. + + :param extra_path: absolute directory or file path to search for rule classes + :return: The list of rule classes that are found in the given directory or module + """ + + files = [] + modules = [] + + if os.path.isfile(extra_path): + files = [os.path.basename(extra_path)] + directory = os.path.dirname(extra_path) + elif os.path.isdir(extra_path): + files = os.listdir(extra_path) + directory = extra_path + else: + raise rules.UserRuleError(f"Invalid extra-path: {extra_path}") + + # Filter out files that are not python modules + for filename in files: + if fnmatch.fnmatch(filename, "*.py"): + # We have to treat __init__ files a bit special: add the parent dir instead of the filename, and also + # add their parent dir to the sys.path (this fixes import issues with pypy2). + if filename == "__init__.py": + modules.append(os.path.basename(directory)) + sys.path.append(os.path.dirname(directory)) + else: + modules.append(os.path.splitext(filename)[0]) + + # No need to continue if there are no modules specified + if not modules: + return [] + + # Append the extra rules path to python path so that we can import them + sys.path.append(directory) + + # Find all the rule classes in the found python files + rule_classes = [] + for module in modules: + # Import the module + try: + importlib.import_module(module) + + except Exception as e: + raise rules.UserRuleError(f"Error while importing extra-path module '{module}': {e}") from e + + # Find all rule classes in the module. We do this my inspecting all members of the module and checking + # 1) is it a class, if not, skip + # 2) is the parent path the current module. If not, we are dealing with an imported class, skip + # 3) is it a subclass of rule + rule_classes.extend( + [ + clazz + for _, clazz in inspect.getmembers(sys.modules[module]) + if inspect.isclass(clazz) # check isclass to ensure clazz.__module__ exists + and clazz.__module__ == module # ignore imported classes + and (issubclass(clazz, (rules.LineRule, rules.CommitRule, rules.ConfigurationRule))) + ] + ) + + # validate that the rule classes are valid user-defined rules + for rule_class in rule_classes: + assert_valid_rule_class(rule_class) + + return rule_classes + + +def assert_valid_rule_class(clazz, rule_type="User-defined"): # noqa: PLR0912 (too many branches) + """ + Asserts that a given rule clazz is valid by checking a number of its properties: + - Rules must extend from LineRule, CommitRule or ConfigurationRule + - Rule classes must have id and name string attributes. + The options_spec is optional, but if set, it must be a list of gitlint Options. + - Rule classes must have a validate method. In case of a CommitRule, validate must take a single commit parameter. + In case of LineRule, validate must take line and commit as first and second parameters. + - LineRule classes must have a target class attributes that is set to either + - ConfigurationRule classes must have an apply method that take `config` and `commit` as parameters. + CommitMessageTitle or CommitMessageBody. + - Rule id's cannot start with R, T, B, M or I as these rule ids are reserved for gitlint itself. + """ + + # Rules must extend from LineRule, CommitRule or ConfigurationRule + if not issubclass(clazz, (rules.LineRule, rules.CommitRule, rules.ConfigurationRule)): + msg = ( + f"{rule_type} rule class '{clazz.__name__}' " + f"must extend from {rules.CommitRule.__module__}.{rules.LineRule.__name__}, " + f"{rules.CommitRule.__module__}.{rules.CommitRule.__name__} or " + f"{rules.CommitRule.__module__}.{rules.ConfigurationRule.__name__}" + ) + raise rules.UserRuleError(msg) + + # Rules must have an id attribute + if not hasattr(clazz, "id") or clazz.id is None or not clazz.id: + raise rules.UserRuleError(f"{rule_type} rule class '{clazz.__name__}' must have an 'id' attribute") + + # Rule id's cannot start with gitlint reserved letters + if clazz.id[0].upper() in ["R", "T", "B", "M", "I"]: + msg = f"The id '{clazz.id[0]}' of '{clazz.__name__}' is invalid. Gitlint reserves ids starting with R,T,B,M,I" + raise rules.UserRuleError(msg) + + # Rules must have a name attribute + if not hasattr(clazz, "name") or clazz.name is None or not clazz.name: + raise rules.UserRuleError(f"{rule_type} rule class '{clazz.__name__}' must have a 'name' attribute") + + # if set, options_spec must be a list of RuleOption + if not isinstance(clazz.options_spec, list): + msg = ( + f"The options_spec attribute of {rule_type.lower()} rule class '{clazz.__name__}' " + f"must be a list of {options.RuleOption.__module__}.{options.RuleOption.__name__}" + ) + raise rules.UserRuleError(msg) + + # check that all items in options_spec are actual gitlint options + for option in clazz.options_spec: + if not isinstance(option, options.RuleOption): + msg = ( + f"The options_spec attribute of {rule_type.lower()} rule class '{clazz.__name__}' " + f"must be a list of {options.RuleOption.__module__}.{options.RuleOption.__name__}" + ) + raise rules.UserRuleError(msg) + + # Line/Commit rules must have a `validate` method + # We use isroutine() as it's both python 2 and 3 compatible. Details: http://stackoverflow.com/a/17019998/381010 + if issubclass(clazz, (rules.LineRule, rules.CommitRule)): + if not hasattr(clazz, "validate") or not inspect.isroutine(clazz.validate): + raise rules.UserRuleError(f"{rule_type} rule class '{clazz.__name__}' must have a 'validate' method") + + # Configuration rules must have an `apply` method + elif issubclass(clazz, rules.ConfigurationRule): # noqa: SIM102 + if not hasattr(clazz, "apply") or not inspect.isroutine(clazz.apply): + msg = f"{rule_type} Configuration rule class '{clazz.__name__}' must have an 'apply' method" + raise rules.UserRuleError(msg) + + # LineRules must have a valid target: rules.CommitMessageTitle or rules.CommitMessageBody + if issubclass(clazz, rules.LineRule): # noqa: SIM102 + if clazz.target not in [rules.CommitMessageTitle, rules.CommitMessageBody]: + msg = ( + f"The target attribute of the {rule_type.lower()} LineRule class '{clazz.__name__}' " + f"must be either {rules.CommitMessageTitle.__module__}.{rules.CommitMessageTitle.__name__} " + f"or {rules.CommitMessageTitle.__module__}.{rules.CommitMessageBody.__name__}" + ) + raise rules.UserRuleError(msg) diff --git a/gitlint-core/gitlint/rules.py b/gitlint-core/gitlint/rules.py new file mode 100644 index 0000000..ca4a05b --- /dev/null +++ b/gitlint-core/gitlint/rules.py @@ -0,0 +1,485 @@ +import copy +import logging +import re + +from gitlint.deprecation import Deprecation +from gitlint.exception import GitlintError +from gitlint.options import BoolOption, IntOption, ListOption, RegexOption, StrOption + + +class Rule: + """Class representing gitlint rules.""" + + options_spec = [] + id = None + name = None + target = None + _log = None + _log_deprecated_regex_style_search = None + + def __init__(self, opts=None): + if not opts: + opts = {} + self.options = {} + for op_spec in self.options_spec: + self.options[op_spec.name] = copy.deepcopy(op_spec) + actual_option = opts.get(op_spec.name) + if actual_option is not None: + self.options[op_spec.name].set(actual_option) + + @property + def log(self): + if not self._log: + self._log = logging.getLogger(__name__) + logging.basicConfig() + return self._log + + def __eq__(self, other): + return ( + self.id == other.id + and self.name == other.name + and self.options == other.options + and self.target == other.target + ) + + def __str__(self): + return f"{self.id} {self.name}" # pragma: no cover + + +class ConfigurationRule(Rule): + """Class representing rules that can dynamically change the configuration of gitlint during runtime.""" + + +class CommitRule(Rule): + """Class representing rules that act on an entire commit at once""" + + +class LineRule(Rule): + """Class representing rules that act on a line by line basis""" + + +class LineRuleTarget: + """Base class for LineRule targets. A LineRuleTarget specifies where a given rule will be applied + (e.g. commit message title, commit message body). + Each LineRule MUST have a target specified.""" + + +class CommitMessageTitle(LineRuleTarget): + """Target class used for rules that apply to a commit message title""" + + +class CommitMessageBody(LineRuleTarget): + """Target class used for rules that apply to a commit message body""" + + +class RuleViolation: + """Class representing a violation of a rule. I.e.: When a rule is broken, the rule will instantiate this class + to indicate how and where the rule was broken.""" + + def __init__(self, rule_id, message, content=None, line_nr=None): + self.rule_id = rule_id + self.line_nr = line_nr + self.message = message + self.content = content + + def __eq__(self, other): + equal = self.rule_id == other.rule_id and self.message == other.message + equal = equal and self.content == other.content and self.line_nr == other.line_nr + return equal + + def __str__(self): + return f'{self.line_nr}: {self.rule_id} {self.message}: "{self.content}"' + + +class UserRuleError(GitlintError): + """Error used to indicate that an error occurred while trying to load a user rule""" + + +class MaxLineLength(LineRule): + name = "max-line-length" + id = "R1" + options_spec = [IntOption("line-length", 80, "Max line length")] + violation_message = "Line exceeds max length ({0}>{1})" + + def validate(self, line, _commit): + max_length = self.options["line-length"].value + if len(line) > max_length: + return [RuleViolation(self.id, self.violation_message.format(len(line), max_length), line)] + + +class TrailingWhiteSpace(LineRule): + name = "trailing-whitespace" + id = "R2" + violation_message = "Line has trailing whitespace" + pattern = re.compile(r"\s$", re.UNICODE) + + def validate(self, line, _commit): + if self.pattern.search(line): + return [RuleViolation(self.id, self.violation_message, line)] + + +class HardTab(LineRule): + name = "hard-tab" + id = "R3" + violation_message = "Line contains hard tab characters (\\t)" + + def validate(self, line, _commit): + if "\t" in line: + return [RuleViolation(self.id, self.violation_message, line)] + + +class LineMustNotContainWord(LineRule): + """Violation if a line contains one of a list of words (NOTE: using a word in the list inside another word is not + a violation, e.g: WIPING is not a violation if 'WIP' is a word that is not allowed.)""" + + name = "line-must-not-contain" + id = "R5" + options_spec = [ListOption("words", [], "Comma separated list of words that should not be found")] + violation_message = "Line contains {0}" + + def validate(self, line, _commit): + strings = self.options["words"].value + violations = [] + for string in strings: + regex = re.compile(rf"\b{string.lower()}\b", re.IGNORECASE | re.UNICODE) + match = regex.search(line.lower()) + if match: + violations.append(RuleViolation(self.id, self.violation_message.format(string), line)) + return violations if violations else None + + +class LeadingWhiteSpace(LineRule): + name = "leading-whitespace" + id = "R6" + violation_message = "Line has leading whitespace" + + def validate(self, line, _commit): + pattern = re.compile(r"^\s", re.UNICODE) + if pattern.search(line): + return [RuleViolation(self.id, self.violation_message, line)] + + +class TitleMaxLength(MaxLineLength): + name = "title-max-length" + id = "T1" + target = CommitMessageTitle + options_spec = [IntOption("line-length", 72, "Max line length")] + violation_message = "Title exceeds max length ({0}>{1})" + + +class TitleTrailingWhitespace(TrailingWhiteSpace): + name = "title-trailing-whitespace" + id = "T2" + target = CommitMessageTitle + violation_message = "Title has trailing whitespace" + + +class TitleTrailingPunctuation(LineRule): + name = "title-trailing-punctuation" + id = "T3" + target = CommitMessageTitle + + def validate(self, title, _commit): + punctuation_marks = "?:!.,;" + for punctuation_mark in punctuation_marks: + if title.endswith(punctuation_mark): + return [RuleViolation(self.id, f"Title has trailing punctuation ({punctuation_mark})", title)] + + +class TitleHardTab(HardTab): + name = "title-hard-tab" + id = "T4" + target = CommitMessageTitle + violation_message = "Title contains hard tab characters (\\t)" + + +class TitleMustNotContainWord(LineMustNotContainWord): + name = "title-must-not-contain-word" + id = "T5" + target = CommitMessageTitle + options_spec = [ListOption("words", ["WIP"], "Must not contain word")] + violation_message = "Title contains the word '{0}' (case-insensitive)" + + +class TitleLeadingWhitespace(LeadingWhiteSpace): + name = "title-leading-whitespace" + id = "T6" + target = CommitMessageTitle + violation_message = "Title has leading whitespace" + + +class TitleRegexMatches(LineRule): + name = "title-match-regex" + id = "T7" + target = CommitMessageTitle + options_spec = [RegexOption("regex", None, "Regex the title should match")] + + def validate(self, title, _commit): + # If no regex is specified, immediately return + if not self.options["regex"].value: + return + + if not self.options["regex"].value.search(title): + violation_msg = f"Title does not match regex ({self.options['regex'].value.pattern})" + return [RuleViolation(self.id, violation_msg, title)] + + +class TitleMinLength(LineRule): + name = "title-min-length" + id = "T8" + target = CommitMessageTitle + options_spec = [IntOption("min-length", 5, "Minimum required title length")] + + def validate(self, title, _commit): + min_length = self.options["min-length"].value + actual_length = len(title) + if actual_length < min_length: + violation_message = f"Title is too short ({actual_length}<{min_length})" + return [RuleViolation(self.id, violation_message, title, 1)] + + +class BodyMaxLineLength(MaxLineLength): + name = "body-max-line-length" + id = "B1" + target = CommitMessageBody + + +class BodyTrailingWhitespace(TrailingWhiteSpace): + name = "body-trailing-whitespace" + id = "B2" + target = CommitMessageBody + + +class BodyHardTab(HardTab): + name = "body-hard-tab" + id = "B3" + target = CommitMessageBody + + +class BodyFirstLineEmpty(CommitRule): + name = "body-first-line-empty" + id = "B4" + + def validate(self, commit): + if len(commit.message.body) >= 1: + first_line = commit.message.body[0] + if first_line != "": + return [RuleViolation(self.id, "Second line is not empty", first_line, 2)] + + +class BodyMinLength(CommitRule): + name = "body-min-length" + id = "B5" + options_spec = [IntOption("min-length", 20, "Minimum body length")] + + def validate(self, commit): + min_length = self.options["min-length"].value + body_message_no_newline = "".join([line for line in commit.message.body if line is not None]) + actual_length = len(body_message_no_newline) + if 0 < actual_length < min_length: + violation_message = f"Body message is too short ({actual_length}<{min_length})" + return [RuleViolation(self.id, violation_message, body_message_no_newline, 3)] + + +class BodyMissing(CommitRule): + name = "body-is-missing" + id = "B6" + options_spec = [BoolOption("ignore-merge-commits", True, "Ignore merge commits")] + + def validate(self, commit): + # ignore merges when option tells us to, which may have no body + if self.options["ignore-merge-commits"].value and commit.is_merge_commit: + return + if len(commit.message.body) < 2 or not "".join(commit.message.body).strip(): # noqa: PLR2004 (Magic value) + return [RuleViolation(self.id, "Body message is missing", None, 3)] + + +class BodyChangedFileMention(CommitRule): + name = "body-changed-file-mention" + id = "B7" + options_spec = [ListOption("files", [], "Files that need to be mentioned")] + + def validate(self, commit): + violations = [] + for needs_mentioned_file in self.options["files"].value: + # if a file that we need to look out for is actually changed, then check whether it occurs + # in the commit msg body + if needs_mentioned_file in commit.changed_files: # noqa: SIM102 + if needs_mentioned_file not in " ".join(commit.message.body): + violation_message = f"Body does not mention changed file '{needs_mentioned_file}'" + violations.append(RuleViolation(self.id, violation_message, None, len(commit.message.body) + 1)) + return violations if violations else None + + +class BodyRegexMatches(CommitRule): + name = "body-match-regex" + id = "B8" + options_spec = [RegexOption("regex", None, "Regex the body should match")] + + def validate(self, commit): + # If no regex is specified, immediately return + if not self.options["regex"].value: + return + + # We intentionally ignore the first line in the body as that's the empty line after the title, + # which most users are not going to expect to be part of the body when matching a regex. + # If this causes contention, we can always introduce an option to change the behavior in a backward- + # compatible way. + body_lines = commit.message.body[1:] if len(commit.message.body) > 1 else [] + + # Similarly, the last line is often empty, this has to do with how git returns commit messages + # User's won't expect this, so prune it off by default + if body_lines and body_lines[-1] == "": + body_lines.pop() + + full_body = "\n".join(body_lines) + + if not self.options["regex"].value.search(full_body): + violation_msg = f"Body does not match regex ({self.options['regex'].value.pattern})" + return [RuleViolation(self.id, violation_msg, None, len(commit.message.body) + 1)] + + +class AuthorValidEmail(CommitRule): + name = "author-valid-email" + id = "M1" + DEFAULT_AUTHOR_VALID_EMAIL_REGEX = r"^[^@ ]+@[^@ ]+\.[^@ ]+" + options_spec = [ + RegexOption("regex", DEFAULT_AUTHOR_VALID_EMAIL_REGEX, "Regex that author email address should match") + ] + + def validate(self, commit): + # If no regex is specified, immediately return + if not self.options["regex"].value: + return + + # We're replacing regex match with search semantics, see https://github.com/jorisroovers/gitlint/issues/254 + # In case the user is using the default regex, we can silently change to using search + # If not, it depends on config (handled by Deprecation class) + if self.options["regex"].value.pattern == self.DEFAULT_AUTHOR_VALID_EMAIL_REGEX: + regex_method = self.options["regex"].value.search + else: + regex_method = Deprecation.get_regex_method(self, self.options["regex"]) + + if commit.author_email and not regex_method(commit.author_email): + return [RuleViolation(self.id, "Author email for commit is invalid", commit.author_email)] + + +class IgnoreByTitle(ConfigurationRule): + name = "ignore-by-title" + id = "I1" + options_spec = [ + RegexOption("regex", None, "Regex matching the titles of commits this rule should apply to"), + StrOption("ignore", "all", "Comma-separated list of rules to ignore"), + ] + + def apply(self, config, commit): + # If no regex is specified, immediately return + if not self.options["regex"].value: + return + + # We're replacing regex match with search semantics, see https://github.com/jorisroovers/gitlint/issues/254 + regex_method = Deprecation.get_regex_method(self, self.options["regex"]) + + if regex_method(commit.message.title): + config.ignore = self.options["ignore"].value + + message = ( + f"Commit title '{commit.message.title}' matches the regex " + f"'{self.options['regex'].value.pattern}', ignoring rules: {self.options['ignore'].value}" + ) + + self.log.debug("Ignoring commit because of rule '%s': %s", self.id, message) + + +class IgnoreByBody(ConfigurationRule): + name = "ignore-by-body" + id = "I2" + options_spec = [ + RegexOption("regex", None, "Regex matching lines of the body of commits this rule should apply to"), + StrOption("ignore", "all", "Comma-separated list of rules to ignore"), + ] + + def apply(self, config, commit): + # If no regex is specified, immediately return + if not self.options["regex"].value: + return + + # We're replacing regex match with search semantics, see https://github.com/jorisroovers/gitlint/issues/254 + regex_method = Deprecation.get_regex_method(self, self.options["regex"]) + + for line in commit.message.body: + if regex_method(line): + config.ignore = self.options["ignore"].value + + message = ( + f"Commit message line '{line}' matches the regex '{self.options['regex'].value.pattern}'," + f" ignoring rules: {self.options['ignore'].value}" + ) + + self.log.debug("Ignoring commit because of rule '%s': %s", self.id, message) + # No need to check other lines if we found a match + return + + +class IgnoreBodyLines(ConfigurationRule): + name = "ignore-body-lines" + id = "I3" + options_spec = [RegexOption("regex", None, "Regex matching lines of the body that should be ignored")] + + def apply(self, _, commit): + # If no regex is specified, immediately return + if not self.options["regex"].value: + return + + # We're replacing regex match with search semantics, see https://github.com/jorisroovers/gitlint/issues/254 + regex_method = Deprecation.get_regex_method(self, self.options["regex"]) + + new_body = [] + for line in commit.message.body: + if regex_method(line): + debug_msg = "Ignoring line '%s' because it matches '%s'" + self.log.debug(debug_msg, line, self.options["regex"].value.pattern) + else: + new_body.append(line) + + commit.message.body = new_body + commit.message.full = "\n".join([commit.message.title, *new_body]) + + +class IgnoreByAuthorName(ConfigurationRule): + name = "ignore-by-author-name" + id = "I4" + options_spec = [ + RegexOption("regex", None, "Regex matching the author name of commits this rule should apply to"), + StrOption("ignore", "all", "Comma-separated list of rules to ignore"), + ] + + def apply(self, config, commit): + # If no regex is specified, immediately return + if not self.options["regex"].value: + return + + # If commit.author_name is not available, log warning and return + if commit.author_name is None: + warning_msg = ( + "%s - %s: skipping - commit.author_name unknown. " + "Suggested fix: Use the --staged flag (or set general.staged=True in .gitlint). " + "More details: https://jorisroovers.com/gitlint/configuration/#staged" + ) + + self.log.warning(warning_msg, self.name, self.id) + return + + regex_method = Deprecation.get_regex_method(self, self.options["regex"]) + + if regex_method(commit.author_name): + config.ignore = self.options["ignore"].value + + message = ( + f"Commit Author Name '{commit.author_name}' matches the regex " + f"'{self.options['regex'].value.pattern}', ignoring rules: {self.options['ignore'].value}" + ) + + self.log.debug("Ignoring commit because of rule '%s': %s", self.id, message) + # No need to check other lines if we found a match + return diff --git a/gitlint-core/gitlint/shell.py b/gitlint-core/gitlint/shell.py new file mode 100644 index 0000000..fddece0 --- /dev/null +++ b/gitlint-core/gitlint/shell.py @@ -0,0 +1,78 @@ +""" +This module implements a shim for the 'sh' library, mainly for use on Windows (sh is not supported on Windows). +We might consider removing the 'sh' dependency altogether in the future, but 'sh' does provide a few +capabilities wrt dealing with more edge-case environments on *nix systems that are useful. +""" + +import subprocess + +from gitlint.utils import TERMINAL_ENCODING, USE_SH_LIB + + +def shell(cmd): + """Convenience function that opens a given command in a shell. Does not use 'sh' library.""" + with subprocess.Popen(cmd, shell=True) as p: + p.communicate() + + +if USE_SH_LIB: + # import exceptions separately, this makes it a little easier to mock them out in the unit tests + from sh import ( + CommandNotFound, + ErrorReturnCode, + git, + ) +else: + + class CommandNotFound(Exception): + """Exception indicating a command was not found during execution""" + + class ShResult: + """Result wrapper class. We use this to more easily migrate from using https://amoffat.github.io/sh/ to using + the builtin subprocess module""" + + def __init__(self, full_cmd, stdout, stderr="", exitcode=0): + self.full_cmd = full_cmd + self.stdout = stdout + self.stderr = stderr + self.exit_code = exitcode + + def __str__(self): + return self.stdout + + class ErrorReturnCode(ShResult, Exception): + """ShResult subclass for unexpected results (acts as an exception).""" + + def git(*command_parts, **kwargs): + """Git shell wrapper. + Implemented as separate function here, so we can do a 'sh' style imports: + `from shell import git` + """ + args = ["git", *list(command_parts)] + return _exec(*args, **kwargs) + + def _exec(*args, **kwargs): + pipe = subprocess.PIPE + popen_kwargs = {"stdout": pipe, "stderr": pipe, "shell": kwargs.get("_tty_out", False)} + if "_cwd" in kwargs: + popen_kwargs["cwd"] = kwargs["_cwd"] + + try: + with subprocess.Popen(args, **popen_kwargs) as p: + result = p.communicate() + except FileNotFoundError as e: + raise CommandNotFound from e + + exit_code = p.returncode + stdout = result[0].decode(TERMINAL_ENCODING) + stderr = result[1] # 'sh' does not decode the stderr bytes to unicode + full_cmd = "" if args is None else " ".join(args) + + # If not _ok_code is specified, then only a 0 exit code is allowed + ok_exit_codes = kwargs.get("_ok_code", [0]) + + if exit_code in ok_exit_codes: + return ShResult(full_cmd, stdout, stderr, exit_code) + + # Unexpected error code => raise ErrorReturnCode + raise ErrorReturnCode(full_cmd, stdout, stderr, p.returncode) diff --git a/gitlint-core/gitlint/tests/__init__.py b/gitlint-core/gitlint/tests/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint-core/gitlint/tests/__init__.py diff --git a/gitlint-core/gitlint/tests/base.py b/gitlint-core/gitlint/tests/base.py new file mode 100644 index 0000000..3899a5f --- /dev/null +++ b/gitlint-core/gitlint/tests/base.py @@ -0,0 +1,227 @@ +import contextlib +import copy +import logging +import os +import re +import shutil +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +from gitlint.config import LintConfig +from gitlint.deprecation import LOG as DEPRECATION_LOG +from gitlint.deprecation import Deprecation +from gitlint.git import GitChangedFileStats, GitContext +from gitlint.utils import FILE_ENCODING, LOG_FORMAT + +EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING = ( + "WARNING: gitlint.deprecated.regex_style_search {0} - {1}: gitlint will be switching from using " + "Python regex 'match' (match beginning) to 'search' (match anywhere) semantics. " + "Please review your {1}.regex option accordingly. " + "To remove this warning, set general.regex-style-search=True. More details: " + "https://jorisroovers.github.io/gitlint/configuration/#regex-style-search" +) + + +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 + + # Working directory in which tests in this class are executed + working_dir = None + # Originally working dir when the test was started + original_working_dir = 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]") + + @classmethod + def setUpClass(cls): + # Run tests a temporary directory to shield them from any local git config + cls.original_working_dir = os.getcwd() + cls.working_dir = tempfile.mkdtemp() + os.chdir(cls.working_dir) + + @classmethod + def tearDownClass(cls): + # Go back to original working dir and remove our temp working dir + os.chdir(cls.original_working_dir) + shutil.rmtree(cls.working_dir) + + 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] + DEPRECATION_LOG.handlers = [self.logcapture] + + # Make sure we don't propagate anything to child loggers, we need to do this explicitly 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 + # Example test where this matters (for DEPRECATION_LOG): + # gitlint-core/gitlint/tests/rules/test_configuration_rules.py::ConfigurationRuleTests::test_ignore_by_title + logging.getLogger("gitlint").propagate = False + DEPRECATION_LOG.propagate = False + + # Make sure Deprecation has a clean config set at the start of each test. + # Tests that want to specifically test deprecation should override this. + Deprecation.config = LintConfig() + # Normally Deprecation only logs messages once per process. + # For tests we want to log every time, so we reset the warning_msgs set per test. + Deprecation.warning_msgs = set() + + @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) + return Path(sample_path).read_text(encoding=FILE_ENCODING) + + @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) + expected = Path(expected_path).read_text(encoding=FILE_ENCODING) + + 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: + changed_file_stats = {filename: GitChangedFileStats(filename, 8, 3) for filename in changed_files} + commit.changed_files_stats = changed_file_stats + 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): + """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: # pragma: nocover + error = f"Right exception, wrong message:\n got: {exception_msg}\n expected: {expected_msg}" + raise self.fail(error) from exc + # else: everything is fine, just return + return + except Exception as exc: # pragma: nocover + raise self.fail(f"Expected '{expected_exception.__name__}' got '{exc.__class__.__name__}'") from exc + + # No exception raised while we expected one + raise self.fail( + f"Expected to raise {expected_exception.__name__}, didn't get an exception at all" + ) # pragma: nocover + + 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-core/gitlint/tests/cli/test_cli.py b/gitlint-core/gitlint/tests/cli/test_cli.py new file mode 100644 index 0000000..c006375 --- /dev/null +++ b/gitlint-core/gitlint/tests/cli/test_cli.py @@ -0,0 +1,736 @@ +import os +import platform +import sys +from io import StringIO +from unittest.mock import patch + +import arrow +from click.testing import CliRunner +from gitlint import __version__, cli +from gitlint.shell import CommandNotFound +from gitlint.tests.base import BaseTestCase +from gitlint.utils import FILE_ENCODING, TERMINAL_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().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()), + "TERMINAL_ENCODING": TERMINAL_ENCODING, + "FILE_ENCODING": FILE_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\ncommït-title\n\ncommït-body", + "#", # git config --get core.commentchar + "1\t4\tfile1.txt\n3\t5\tpåth/to/file2.txt\n", + "commit-1-branch-1\ncommit-1-branch-2\n", + ] + + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli) + self.assertEqual(stderr.getvalue(), '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""" + + # fmt: off + 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 + "3\t5\tcommit-1/file-1\n1\t4\tcommit-1/file-2\n", # git diff-tree + "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + # 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", + "8\t3\tcommit-2/file-1\n1\t5\tcommit-2/file-2\n", # git diff-tree + "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + # 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", + "7\t2\tcommit-3/file-1\n1\t7\tcommit-3/file-2\n", # git diff-tree + "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + ] + # fmt: on + + 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_csv(self, sh, _): + """Test for --commits option""" + + # fmt: off + 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 + "3\t5\tcommit-1/file-1\n1\t4\tcommit-1/file-2\n", # git diff-tree + "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + # 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", + "8\t3\tcommit-2/file-1\n1\t5\tcommit-2/file-2\n", # git diff-tree + "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + # 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", + "7\t2\tcommit-3/file-1\n1\t7\tcommit-3/file-2\n", # git diff-tree + "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + ] + # fmt: on + + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--commits", "6f29bf81,25053cce,4da2656b"]) + self.assertEqual(stderr.getvalue(), self.get_expected("cli/test_cli/test_lint_multiple_commits_csv_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""" + + # fmt: off + # 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 + "9\t4\tcommit-1/file-1\n0\t2\tcommit-1/file-2\n", # git diff-tree + "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + # 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", + "3\t7\tcommit-2/file-1\n4\t6\tcommit-2/file-2\n", # git diff-tree + "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + # 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", + "3\t8\tcommit-3/file-1\n1\t4\tcommit-3/file-2\n", # git diff-tree + "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + ] + # fmt: on + + 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""" + + # fmt: off + # 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 + "5\t9\tcommit-1/file-1\n1\t4\tcommit-1/file-2\n", # git diff-tree + "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + # 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", + "4\t7\tcommit-2/file-1\n1\t4\tcommit-2/file-2\n", # git diff-tree + "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + # 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", + "1\t9\tcommit-3/file-1\n3\t7\tcommit-3/file-2\n", # git diff-tree + "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + ] + # fmt: on + + 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" + '3: B5 Body message is too short (12<20): "commït-body1"\n\n' + "Commit 4da2656b0d:\n" + '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""" + + # fmt: off + 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 + "4\t5\tcommit-1/file-1\n1\t4\tcommit-1/file-2\n", # git diff-tree + "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + ] + # fmt: on + + 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) + def test_lint_commit_negative(self, _): + """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="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="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\ncommït-title\n\ncommït-body", + "#", # git config --get core.commentchar + "3\t12\tfile1.txt\n8\t5\tpåth/to/file2.txt\n", # git diff-tree + "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + ] + + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + result = self.cli.invoke(cli.cli, ["--ignore-stdin"]) + self.assertEqual(stderr.getvalue(), '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="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 + "1\t5\tcommit-1/file-1\n8\t9\tcommit-1/file-2\n", # git diff-tree + "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) + ] + + 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() + changed_files_stats = ( + f" {os.path.join('commit-1', 'file-1')}: 1 additions, 5 deletions\n" + f" {os.path.join('commit-1', 'file-2')}: 8 additions, 9 deletions" + ) + expected_kwargs.update({"changed_files_stats": changed_files_stats}) + 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""" + + # fmt: off + sh.git.side_effect = [ + "#", # git config --get core.commentchar + "3\t4\tcommit-1/file-1\n4\t7\tcommit-1/file-2\n", # git diff-tree + "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) + ] + # fmt: on + + with self.tempdir() as tmpdir: + msg_filename = os.path.join(tmpdir, "msg") + with open(msg_filename, "w", encoding=FILE_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() + changed_files_stats = ( + f" {os.path.join('commit-1', 'file-1')}: 3 additions, 4 deletions\n" + f" {os.path.join('commit-1', 'file-2')}: 4 additions, 7 deletions" + ) + expected_kwargs.update({"changed_files_stats": changed_files_stats}) + 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 open(msg_filename, "w", encoding=FILE_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="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""" + + # fmt: off + 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\x00a123\n" + "commït-title1\n\ncommït-body1", + "#", # git config --get core.commentchar + "5\t8\tcommit-1/file-1\n2\t9\tcommit-1/file-2\n", # git diff-tree + "commit-1-branch-1\ncommit-1-branch-2\n", # git branch --contains <sha> + "test åuthor2\x00test-email2@föo.com\x002016-12-04 15:28:15 +0100\x00b123\n" + "commït-title2.\n\ncommït-body2", + "5\t8\tcommit-2/file-1\n7\t9\tcommit-2/file-2\n", # git diff-tree + "commit-2-branch-1\ncommit-2-branch-2\n", # git branch --contains <sha> + "test åuthor3\x00test-email3@föo.com\x002016-12-05 15:28:15 +0100\x00c123\n" + "föobar\nbar", + "1\t4\tcommit-3/file-1\n3\t4\tcommit-3/file-2\n", # git diff-tree + "commit-3-branch-1\ncommit-3-branch-2\n", # git branch --contains <sha> + ] + # fmt: on + + 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() + changed_files_stats1 = ( + f" {os.path.join('commit-1', 'file-1')}: 5 additions, 8 deletions\n" + f" {os.path.join('commit-1', 'file-2')}: 2 additions, 9 deletions" + ) + changed_files_stats2 = ( + f" {os.path.join('commit-2', 'file-1')}: 5 additions, 8 deletions\n" + f" {os.path.join('commit-2', 'file-2')}: 7 additions, 9 deletions" + ) + changed_files_stats3 = ( + f" {os.path.join('commit-3', 'file-1')}: 1 additions, 4 deletions\n" + f" {os.path.join('commit-3', 'file-2')}: 3 additions, 4 deletions" + ) + expected_kwargs.update( + { + "changed_files_stats1": changed_files_stats1, + "changed_files_stats2": changed_files_stats2, + "changed_files_stats3": changed_files_stats3, + } + ) + 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") + def test_extra_path_environment(self, _): + """Test for GITLINT_EXTRA_PATH environment variable""" + # Test setting extra-path to a directory from an environment variable + with patch("gitlint.display.stderr", new=StringIO()) as stderr: + extra_path = self.get_sample_path("user_rules") + result = self.cli.invoke(cli.cli, env={"GITLINT_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 from an environment variable + 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, env={"GITLINT_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) + + @patch("gitlint.cli.get_stdin_data", return_value="WIP: tëst") + def test_config_file_environment(self, _): + """Test for GITLINT_CONFIG environment variable""" + 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, env={"GITLINT_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!r} 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) + + def test_config_file_negative_environment(self): + """Negative test for GITLINT_CONFIG environment variable""" + # Directory as config file + config_path = self.get_sample_path("config") + result = self.cli.invoke(cli.cli, env={"GITLINT_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, env={"GITLINT_CONFIG": config_path}) + expected_string = f"Error: Invalid value for '-C' / '--config': File {config_path!r} 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, env={"GITLINT_CONFIG": config_path}) + self.assertEqual(result.exit_code, self.CONFIG_ERROR_CODE) + + def test_config_error(self): + result = self.cli.invoke(cli.cli, ["-c", "foo.bar=hur"]) + self.assertEqual(result.output, "Config Error: No such rule 'foo'\n") + 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!r} 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", "main...HEAD"]) + + self.assert_log_contains('DEBUG: gitlint.cli No commits in range "main...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..c9e4eba --- /dev/null +++ b/gitlint-core/gitlint/tests/cli/test_cli_hooks.py @@ -0,0 +1,277 @@ +import os +from io import StringIO +from unittest.mock import patch + +from click.testing import CliRunner +from gitlint import cli, config, hooks +from gitlint.shell import ErrorReturnCode +from gitlint.tests.base import BaseTestCase +from gitlint.utils import FILE_ENCODING + + +class CLIHookTests(BaseTestCase): + USAGE_ERROR_CODE = 253 + GIT_CONTEXT_ERROR_CODE = 254 + CONFIG_ERROR_CODE = 255 + + def setUp(self): + super().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 open(msg_filename, "w", encoding=FILE_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] + else: + # When set_editors[i] == None, ensure we don't fallback to EDITOR set in shell invocating the tests + os.environ.pop("EDITOR", None) + + with self.patch_input(["e", "e", "n"]), self.tempdir() as tmpdir: + msg_filename = os.path.realpath(os.path.join(tmpdir, "hür")) + with open(msg_filename, "w", encoding=FILE_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"]), self.tempdir() as tmpdir: + msg_filename = os.path.join(tmpdir, "hür") + with open(msg_filename, "w", encoding=FILE_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"]), self.tempdir() as tmpdir: + msg_filename = os.path.join(tmpdir, "hür") + with open(msg_filename, "w", encoding=FILE_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_kwargs = {"git_repo": os.path.realpath(os.getcwd())} + expected = self.get_expected("cli/test_cli_hooks/test_run_hook_negative_1", expected_kwargs) + 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\nWIP: commït-title\n\ncommït-body", + "#", # git config --get core.commentchar + "1\t5\tfile1.txt\n3\t4\tpåth/to/file2.txt\n", + "commit-1-branch-1\ncommit-1-branch-2\n", + ] + + with self.patch_input(["e"]), 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-core/gitlint/tests/config/test_config.py b/gitlint-core/gitlint/tests/config/test_config.py new file mode 100644 index 0000000..439fd93 --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_config.py @@ -0,0 +1,320 @@ +from unittest.mock import patch + +from gitlint import options, rules +from gitlint.config import ( + GITLINT_CONFIG_TEMPLATE_SRC_PATH, + LintConfig, + LintConfigError, + LintConfigGenerator, +) +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("föobar", "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", "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_fixup_amend_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.regex_style_search) + 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_fixup_amend_commit + config.set_general_option("ignore-fixup-amend-commits", "false") + self.assertFalse(config.ignore_fixup_amend_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) + + # regex-style-search + config.set_general_option("regex-style-search", "true") + self.assertTrue(config.regex_style_search) + + # 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, "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, "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): # noqa: SIM117 + 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, "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_fixup_amend_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", "regex_style_search"]: + 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), + ("fail_without_commits", True), + ("regex_style_search", True), + ("debug", True), + ("ignore", ["T1"]), + ("staged", True), + ("_config_path", self.get_sample_path()), + ("ignore_merge_commits", False), + ("ignore_fixup_commits", False), + ("ignore_fixup_amend_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-core/gitlint/tests/config/test_config_builder.py b/gitlint-core/gitlint/tests/config/test_config_builder.py new file mode 100644 index 0000000..ac2a896 --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_config_builder.py @@ -0,0 +1,275 @@ +import copy + +from gitlint import rules +from gitlint.config import LintConfig, LintConfigBuilder, LintConfigError +from gitlint.tests.base import BaseTestCase + + +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(["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 = [ + "T7:my-extra-rüle", + " T7 : my-extra-rüle ", + "\tT7:\tmy-extra-rüle\t", + "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["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): + # Invalid rule name (T7 = title-match-regex) + 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-core/gitlint/tests/config/test_config_precedence.py b/gitlint-core/gitlint/tests/config/test_config_precedence.py new file mode 100644 index 0000000..a7f94cf --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_config_precedence.py @@ -0,0 +1,98 @@ +from io import StringIO +from unittest.mock import patch + +from click.testing import CliRunner +from gitlint import cli +from gitlint.config import LintConfigBuilder +from gitlint.tests.base import BaseTestCase + + +class LintConfigPrecedenceTests(BaseTestCase): + def setUp(self): + super().setUp() + 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("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("my-üser-commit-rule", "violation-count"), 3) diff --git a/gitlint-core/gitlint/tests/config/test_rule_collection.py b/gitlint-core/gitlint/tests/config/test_rule_collection.py new file mode 100644 index 0000000..2cb0e5c --- /dev/null +++ b/gitlint-core/gitlint/tests/config/test_rule_collection.py @@ -0,0 +1,62 @@ +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 explicitly 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("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-core/gitlint/tests/contrib/__init__.py b/gitlint-core/gitlint/tests/contrib/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint-core/gitlint/tests/contrib/__init__.py diff --git a/gitlint-core/gitlint/tests/contrib/rules/__init__.py b/gitlint-core/gitlint/tests/contrib/rules/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint-core/gitlint/tests/contrib/rules/__init__.py diff --git a/gitlint-core/gitlint/tests/contrib/rules/test_authors_commit.py b/gitlint-core/gitlint/tests/contrib/rules/test_authors_commit.py new file mode 100644 index 0000000..2bad2ed --- /dev/null +++ b/gitlint-core/gitlint/tests/contrib/rules/test_authors_commit.py @@ -0,0 +1,105 @@ +from collections import namedtuple +from unittest.mock import patch + +from gitlint.config import LintConfig +from gitlint.contrib.rules.authors_commit import AllowedAuthors +from gitlint.rules import RuleViolation +from gitlint.tests.base import BaseTestCase + + +class ContribAuthorsCommitTests(BaseTestCase): + def setUp(self): + author = namedtuple("Author", "name, email") + self.author_1 = author("John Doe", "john.doe@mail.com") + self.author_2 = author("Bob Smith", "bob.smith@mail.com") + self.rule = AllowedAuthors() + self.gitcontext = self.get_gitcontext() + + def get_gitcontext(self): + gitcontext = self.gitcontext(self.get_sample("commit_message/sample1")) + gitcontext.repository_path = self.get_sample_path("config") + return gitcontext + + def get_commit(self, name, email): + commit = self.gitcommit("commit_message/sample1", author_name=name, author_email=email) + commit.message.context = self.gitcontext + return commit + + def test_enable(self): + for rule_ref in ["CC3", "contrib-allowed-authors"]: + config = LintConfig() + config.contrib = [rule_ref] + self.assertIn(AllowedAuthors(), config.rules) + + def test_authors_succeeds(self): + for author in [self.author_1, self.author_2]: + commit = self.get_commit(author.name, author.email) + violations = self.rule.validate(commit) + self.assertListEqual([], violations) + + def test_authors_email_is_case_insensitive(self): + for email in [ + self.author_2.email.capitalize(), + self.author_2.email.lower(), + self.author_2.email.upper(), + ]: + commit = self.get_commit(self.author_2.name, email) + violations = self.rule.validate(commit) + self.assertListEqual([], violations) + + def test_authors_name_is_case_sensitive(self): + for name in [self.author_2.name.lower(), self.author_2.name.upper()]: + commit = self.get_commit(name, self.author_2.email) + violations = self.rule.validate(commit) + expected_violation = RuleViolation( + "CC3", + f"Author not in 'AUTHORS' file: " f'"{name} <{self.author_2.email}>"', + ) + self.assertListEqual([expected_violation], violations) + + def test_authors_bad_name_fails(self): + for name in ["", "root"]: + commit = self.get_commit(name, self.author_2.email) + violations = self.rule.validate(commit) + expected_violation = RuleViolation( + "CC3", + f"Author not in 'AUTHORS' file: " f'"{name} <{self.author_2.email}>"', + ) + self.assertListEqual([expected_violation], violations) + + def test_authors_bad_email_fails(self): + for email in ["", "root@example.com"]: + commit = self.get_commit(self.author_2.name, email) + violations = self.rule.validate(commit) + expected_violation = RuleViolation( + "CC3", + f"Author not in 'AUTHORS' file: " f'"{self.author_2.name} <{email}>"', + ) + self.assertListEqual([expected_violation], violations) + + def test_authors_invalid_combination_fails(self): + commit = self.get_commit(self.author_1.name, self.author_2.email) + violations = self.rule.validate(commit) + expected_violation = RuleViolation( + "CC3", + f"Author not in 'AUTHORS' file: " f'"{self.author_1.name} <{self.author_2.email}>"', + ) + self.assertListEqual([expected_violation], violations) + + @patch( + "gitlint.contrib.rules.authors_commit.Path.read_text", + return_value="John Doe <john.doe@mail.com>", + ) + def test_read_authors_file(self, _mock_read_text): + authors, authors_file_name = AllowedAuthors._read_authors_from_file(self.gitcontext) + self.assertEqual(authors_file_name, "AUTHORS") + self.assertEqual(len(authors), 1) + self.assertEqual(authors, {self.author_1}) + + @patch( + "gitlint.contrib.rules.authors_commit.Path.exists", + return_value=False, + ) + def test_read_authors_file_missing_file(self, _mock_iterdir): + with self.assertRaisesMessage(FileNotFoundError, "No AUTHORS file found!"): + AllowedAuthors._read_authors_from_file(self.gitcontext) diff --git a/gitlint-core/gitlint/tests/contrib/rules/test_conventional_commit.py b/gitlint-core/gitlint/tests/contrib/rules/test_conventional_commit.py new file mode 100644 index 0000000..cbab684 --- /dev/null +++ b/gitlint-core/gitlint/tests/contrib/rules/test_conventional_commit.py @@ -0,0 +1,82 @@ +from gitlint.config import LintConfig +from gitlint.contrib.rules.conventional_commit import ConventionalCommit +from gitlint.rules import RuleViolation +from gitlint.tests.base import BaseTestCase + + +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-core/gitlint/tests/contrib/rules/test_disallow_cleanup_commits.py b/gitlint-core/gitlint/tests/contrib/rules/test_disallow_cleanup_commits.py new file mode 100644 index 0000000..1983367 --- /dev/null +++ b/gitlint-core/gitlint/tests/contrib/rules/test_disallow_cleanup_commits.py @@ -0,0 +1,34 @@ +from gitlint.config import LintConfig +from gitlint.contrib.rules.disallow_cleanup_commits import DisallowCleanupCommits +from gitlint.rules import RuleViolation +from gitlint.tests.base import BaseTestCase + + +class ContribDisallowCleanupCommitsTest(BaseTestCase): + def test_enable(self): + # Test that rule can be enabled in config + for rule_ref in ["CC2", "contrib-disallow-cleanup-commits"]: + config = LintConfig() + config.contrib = [rule_ref] + self.assertIn(DisallowCleanupCommits(), config.rules) + + def test_disallow_fixup_squash_commit(self): + # No violations when no 'fixup!' line and no 'squash!' line is present + rule = DisallowCleanupCommits() + violations = rule.validate(self.gitcommit("Föobar\n\nMy Body")) + self.assertListEqual(violations, []) + + # Assert violation when 'fixup!' in title + violations = rule.validate(self.gitcommit("fixup! Föobar\n\nMy Body")) + expected_violation = RuleViolation("CC2", "Fixup commits are not allowed", line_nr=1) + self.assertListEqual(violations, [expected_violation]) + + # Assert violation when 'squash!' in title + violations = rule.validate(self.gitcommit("squash! Föobar\n\nMy Body")) + expected_violation = RuleViolation("CC2", "Squash commits are not allowed", line_nr=1) + self.assertListEqual(violations, [expected_violation]) + + # Assert violation when 'amend!' in title + violations = rule.validate(self.gitcommit("amend! Föobar\n\nMy Body")) + expected_violation = RuleViolation("CC2", "Amend commits are not allowed", line_nr=1) + self.assertListEqual(violations, [expected_violation]) diff --git a/gitlint-core/gitlint/tests/contrib/rules/test_signedoff_by.py b/gitlint-core/gitlint/tests/contrib/rules/test_signedoff_by.py new file mode 100644 index 0000000..bf526a0 --- /dev/null +++ b/gitlint-core/gitlint/tests/contrib/rules/test_signedoff_by.py @@ -0,0 +1,28 @@ +from gitlint.config import LintConfig +from gitlint.contrib.rules.signedoff_by import SignedOffBy +from gitlint.rules import RuleViolation +from gitlint.tests.base import BaseTestCase + + +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-core/gitlint/tests/contrib/test_contrib_rules.py b/gitlint-core/gitlint/tests/contrib/test_contrib_rules.py new file mode 100644 index 0000000..b0372d8 --- /dev/null +++ b/gitlint-core/gitlint/tests/contrib/test_contrib_rules.py @@ -0,0 +1,69 @@ +import os + +from gitlint import rule_finder, rules +from gitlint.contrib import rules as contrib_rules +from gitlint.tests.base import BaseTestCase +from gitlint.tests.contrib import rules as contrib_tests + + +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 = f"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-core/gitlint/tests/expected/cli/test_cli/test_contrib_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_contrib_1 new file mode 100644 index 0000000..b95433b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_contrib_1 @@ -0,0 +1,2 @@ +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-core/gitlint/tests/expected/cli/test_cli/test_debug_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_debug_1 new file mode 100644 index 0000000..046294c --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_debug_1 @@ -0,0 +1,139 @@ +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 TERMINAL_ENCODING: {TERMINAL_ENCODING} +DEBUG: gitlint.cli FILE_ENCODING: {FILE_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-fixup-amend-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: False +fail-without-commits: False +regex-style-search: 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 ('diff-tree', '--no-commit-id', '--numstat', '-r', '--root', '6f29bf81a8322a04071bb794666e48c443a90360') +DEBUG: gitlint.git ('branch', '--contains', '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-fixup-amend-commit: False +is-squash-commit: False +is-revert-commit: False +Parents: ['a123'] +Branches: ['commit-1-branch-1', 'commit-1-branch-2'] +Changed Files: ['commit-1/file-1', 'commit-1/file-2'] +Changed Files Stats: +{changed_files_stats1} +----------------------- +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 ('diff-tree', '--no-commit-id', '--numstat', '-r', '--root', '25053ccec5e28e1bb8f7551fdbb5ab213ada2401') +DEBUG: gitlint.git ('branch', '--contains', '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-fixup-amend-commit: False +is-squash-commit: False +is-revert-commit: False +Parents: ['b123'] +Branches: ['commit-2-branch-1', 'commit-2-branch-2'] +Changed Files: ['commit-2/file-1', 'commit-2/file-2'] +Changed Files Stats: +{changed_files_stats2} +----------------------- +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 ('diff-tree', '--no-commit-id', '--numstat', '-r', '--root', '4da2656b0dadc76c7ee3fd0243a96cb64007f125') +DEBUG: gitlint.git ('branch', '--contains', '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-fixup-amend-commit: False +is-squash-commit: False +is-revert-commit: False +Parents: ['c123'] +Branches: ['commit-3-branch-1', 'commit-3-branch-2'] +Changed Files: ['commit-3/file-1', 'commit-3/file-2'] +Changed Files Stats: +{changed_files_stats3} +----------------------- +DEBUG: gitlint.cli Exit Code = 6
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_1 new file mode 100644 index 0000000..4326729 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_1 @@ -0,0 +1,3 @@ +1: T2 Title has trailing whitespace: "WIP: tïtle " +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle " +3: B6 Body message is missing diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_1 new file mode 100644 index 0000000..4326729 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_1 @@ -0,0 +1,3 @@ +1: T2 Title has trailing whitespace: "WIP: tïtle " +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle " +3: B6 Body message is missing diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_2 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_2 new file mode 100644 index 0000000..46a8adf --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_input_stream_debug_2 @@ -0,0 +1,89 @@ +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 TERMINAL_ENCODING: {TERMINAL_ENCODING} +DEBUG: gitlint.cli FILE_ENCODING: {FILE_ENCODING} +DEBUG: gitlint.cli Configuration +config-path: None +[GENERAL] +extra-path: None +contrib: [] +ignore: +ignore-merge-commits: True +ignore-fixup-commits: True +ignore-fixup-amend-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: False +fail-without-commits: False +regex-style-search: 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-fixup-amend-commit: False +is-squash-commit: False +is-revert-commit: False +Parents: [] +Branches: [] +Changed Files: [] +Changed Files Stats: {{}} +----------------------- +DEBUG: gitlint.cli Exit Code = 3
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_commit_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_commit_1 new file mode 100644 index 0000000..b9f0742 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_commit_1 @@ -0,0 +1,2 @@ +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-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_1 new file mode 100644 index 0000000..be3288b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_1 @@ -0,0 +1,8 @@ +Commit 6f29bf81a8: +3: B5 Body message is too short (12<20): "commït-body1" + +Commit 25053ccec5: +3: B5 Body message is too short (12<20): "commït-body2" + +Commit 4da2656b0d: +3: B5 Body message is too short (12<20): "commït-body3" diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_config_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_config_1 new file mode 100644 index 0000000..1bf0503 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_config_1 @@ -0,0 +1,6 @@ +Commit 6f29bf81a8: +3: B5 Body message is too short (12<20): "commït-body1" + +Commit 4da2656b0d: +1: T3 Title has trailing punctuation (.): "commït-title3." +3: B5 Body message is too short (12<20): "commït-body3" diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_csv_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_csv_1 new file mode 100644 index 0000000..be3288b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_multiple_commits_csv_1 @@ -0,0 +1,8 @@ +Commit 6f29bf81a8: +3: B5 Body message is too short (12<20): "commït-body1" + +Commit 25053ccec5: +3: B5 Body message is too short (12<20): "commït-body2" + +Commit 4da2656b0d: +3: B5 Body message is too short (12<20): "commït-body3" diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_1 new file mode 100644 index 0000000..9a9091b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_1 @@ -0,0 +1,2 @@ +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: msg-filename tïtle" +3: B6 Body message is missing diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_2 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_2 new file mode 100644 index 0000000..6b96a45 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_msg_filename_2 @@ -0,0 +1,93 @@ +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 TERMINAL_ENCODING: {TERMINAL_ENCODING} +DEBUG: gitlint.cli FILE_ENCODING: {FILE_ENCODING} +DEBUG: gitlint.cli Configuration +config-path: None +[GENERAL] +extra-path: None +contrib: [] +ignore: +ignore-merge-commits: True +ignore-fixup-commits: True +ignore-fixup-amend-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: True +fail-without-commits: False +regex-style-search: 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 ('diff', '--staged', '--numstat', '-r') +DEBUG: gitlint.git ('config', '--get', 'user.name') +DEBUG: gitlint.git ('config', '--get', 'user.email') +DEBUG: gitlint.git ('rev-parse', '--abbrev-ref', 'HEAD') +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-fixup-amend-commit: False +is-squash-commit: False +is-revert-commit: False +Parents: [] +Branches: ['my-branch'] +Changed Files: ['commit-1/file-1', 'commit-1/file-2'] +Changed Files Stats: +{changed_files_stats} +----------------------- +DEBUG: gitlint.cli Exit Code = 2
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_1 new file mode 100644 index 0000000..4326729 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_1 @@ -0,0 +1,3 @@ +1: T2 Title has trailing whitespace: "WIP: tïtle " +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle " +3: B6 Body message is missing diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_2 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_2 new file mode 100644 index 0000000..45d94e2 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_lint_staged_stdin_2 @@ -0,0 +1,95 @@ +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 TERMINAL_ENCODING: {TERMINAL_ENCODING} +DEBUG: gitlint.cli FILE_ENCODING: {FILE_ENCODING} +DEBUG: gitlint.cli Configuration +config-path: None +[GENERAL] +extra-path: None +contrib: [] +ignore: +ignore-merge-commits: True +ignore-fixup-commits: True +ignore-fixup-amend-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: True +fail-without-commits: False +regex-style-search: 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 ('diff', '--staged', '--numstat', '-r') +DEBUG: gitlint.git ('config', '--get', 'user.name') +DEBUG: gitlint.git ('config', '--get', 'user.email') +DEBUG: gitlint.git ('rev-parse', '--abbrev-ref', 'HEAD') +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-fixup-amend-commit: False +is-squash-commit: False +is-revert-commit: False +Parents: [] +Branches: ['my-branch'] +Changed Files: ['commit-1/file-1', 'commit-1/file-2'] +Changed Files Stats: +{changed_files_stats} +----------------------- +DEBUG: gitlint.cli Exit Code = 3
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli/test_named_rules_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_named_rules_1 new file mode 100644 index 0000000..a581d05 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_named_rules_1 @@ -0,0 +1,4 @@ +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-core/gitlint/tests/expected/cli/test_cli/test_named_rules_2 b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_named_rules_2 new file mode 100644 index 0000000..f4df46e --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli/test_named_rules_2 @@ -0,0 +1,92 @@ +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 TERMINAL_ENCODING: {TERMINAL_ENCODING} +DEBUG: gitlint.cli FILE_ENCODING: {FILE_ENCODING} +DEBUG: gitlint.cli Configuration +config-path: {config_path} +[GENERAL] +extra-path: None +contrib: [] +ignore: +ignore-merge-commits: True +ignore-fixup-commits: True +ignore-fixup-amend-commits: True +ignore-squash-commits: True +ignore-revert-commits: True +ignore-stdin: False +staged: False +fail-without-commits: False +regex-style-search: 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-fixup-amend-commit: False +is-squash-commit: False +is-revert-commit: False +Parents: [] +Branches: [] +Changed Files: [] +Changed Files Stats: {{}} +----------------------- +DEBUG: gitlint.cli Exit Code = 4
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stderr b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stderr new file mode 100644 index 0000000..cfacd42 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stderr @@ -0,0 +1,2 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stdout new file mode 100644 index 0000000..bee014b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_config_1_stdout @@ -0,0 +1,5 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stderr b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stderr new file mode 100644 index 0000000..3eb8fca --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stderr @@ -0,0 +1,6 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stdout new file mode 100644 index 0000000..b57a35a --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_edit_1_stdout @@ -0,0 +1,14 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stderr b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stderr new file mode 100644 index 0000000..11c3cd8 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stderr @@ -0,0 +1,2 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stdout new file mode 100644 index 0000000..0b8e90e --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_local_commit_1_stdout @@ -0,0 +1,4 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stderr b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stderr new file mode 100644 index 0000000..6d0c9cf --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stderr @@ -0,0 +1,2 @@ +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: höok no" +3: B6 Body message is missing diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stdout new file mode 100644 index 0000000..98a83b1 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_1_stdout @@ -0,0 +1,8 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stderr b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stderr new file mode 100644 index 0000000..a8d8760 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stderr @@ -0,0 +1,2 @@ +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: tïtle" +3: B6 Body message is missing diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stdout new file mode 100644 index 0000000..bee014b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_no_tty_1_stdout @@ -0,0 +1,5 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_no_violations_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_no_violations_1_stdout new file mode 100644 index 0000000..da1ef0b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_no_violations_1_stdout @@ -0,0 +1,2 @@ +gitlint: checking commit message... +gitlint: OK (no violations in commit message) diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stderr b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stderr new file mode 100644 index 0000000..1404f4a --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stderr @@ -0,0 +1,2 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stdout new file mode 100644 index 0000000..bee014b --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_stdin_violations_1_stdout @@ -0,0 +1,5 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stderr b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stderr new file mode 100644 index 0000000..da6f874 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stderr @@ -0,0 +1,2 @@ +1: T5 Title contains the word 'WIP' (case-insensitive): "WIP: höok yes" +3: B6 Body message is missing diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stdout b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stdout new file mode 100644 index 0000000..0414712 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_hook_yes_1_stdout @@ -0,0 +1,4 @@ +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-core/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_1 b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_1 new file mode 100644 index 0000000..9082830 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_1 @@ -0,0 +1,2 @@ +gitlint: checking commit message... +{git_repo} is not a git repository. diff --git a/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_2 b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_2 new file mode 100644 index 0000000..bafbf29 --- /dev/null +++ b/gitlint-core/gitlint/tests/expected/cli/test_cli_hooks/test_run_hook_negative_2 @@ -0,0 +1,2 @@ +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-core/gitlint/tests/git/test_git.py b/gitlint-core/gitlint/tests/git/test_git.py new file mode 100644 index 0000000..b6a146a --- /dev/null +++ b/gitlint-core/gitlint/tests/git/test_git.py @@ -0,0 +1,121 @@ +import os +from unittest.mock import call, patch + +from gitlint.git import ( + GitContext, + GitContextError, + GitNotInstalledError, + git_commentchar, + git_hooks_dir, +) +from gitlint.shell import CommandNotFound, ErrorReturnCode +from gitlint.tests.base import BaseTestCase + + +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 'main' 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) + + @patch("gitlint.git.sh") + def test_git_no_commits_get_branch(self, sh): + """Check that we can still read the current branch name when there's no commits. This is useful when + when trying to lint the first commit using the --staged flag. + """ + # 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), + "test-branch", # git branch --show-current + ] + + context = GitContext.from_commit_msg("test") + self.assertEqual(context.current_branch, "test-branch") + + # assert that we try using `git rev-parse` first, and if that fails (as will be the case with the first commit), + # we fallback to `git branch --show-current` to determine the current branch name. + expected_calls = [ + call("config", "--get", "core.commentchar", _tty_out=False, _cwd=None, _ok_code=[0, 1]), + call("rev-parse", "--abbrev-ref", "HEAD", _tty_out=False, _cwd=None), + call("branch", "--show-current", _tty_out=False, _cwd=None), + ] + + self.assertEqual(sh.git.mock_calls, expected_calls) + + @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-core/gitlint/tests/git/test_git_commit.py b/gitlint-core/gitlint/tests/git/test_git_commit.py new file mode 100644 index 0000000..e6b0b2c --- /dev/null +++ b/gitlint-core/gitlint/tests/git/test_git_commit.py @@ -0,0 +1,825 @@ +import copy +import datetime +from pathlib import Path +from unittest.mock import call, patch + +import arrow +import dateutil +from gitlint.git import ( + GitChangedFileStats, + GitCommit, + GitCommitMessage, + GitContext, + GitContextError, + LocalGitCommit, + StagedLocalGitCommit, +) +from gitlint.shell import ErrorReturnCode +from gitlint.tests.base import BaseTestCase + + +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\ncömmit-title\n\ncömmit-body", + "#", # git config --get core.commentchar + "4\t15\tfile1.txt\n-\t-\tpåth/to/file2.bin\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", + "--numstat", + "-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_fixup_amend_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.bin"]) + expected_file_stats = { + "file1.txt": GitChangedFileStats("file1.txt", 4, 15), + "påth/to/file2.bin": GitChangedFileStats("påth/to/file2.bin", None, None), + } + self.assertDictEqual(last_commit.changed_files_stats, expected_file_stats) + + # '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\ncömmit-title\n\ncömmit-body", + "#", # git config --get core.commentchar + "7\t10\tfile1.txt\n9\t12\tpå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", + "--numstat", + "-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_fixup_amend_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"]) + expected_file_stats = { + "file1.txt": GitChangedFileStats("file1.txt", 7, 10), + "påth/to/file2.txt": GitChangedFileStats("påth/to/file2.txt", 9, 12), + } + self.assertDictEqual(last_commit.changed_files_stats, expected_file_stats) + + # '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\ncömmit-title\n\ncömmit-body", + "#", # git config --get core.commentchar + "8\t3\tfile1.txt\n1\t4\tpåth/to/file2.txt\n", + "foöbar\n* hürdur\n", + ] + + context = GitContext.from_local_repository("fåke/path", commit_hashes=[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", + "--numstat", + "-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_fixup_amend_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"]) + expected_file_stats = { + "file1.txt": GitChangedFileStats("file1.txt", 8, 3), + "påth/to/file2.txt": GitChangedFileStats("påth/to/file2.txt", 1, 4), + } + self.assertDictEqual(last_commit.changed_files_stats, expected_file_stats) + # '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_multiple_commit_hashes(self, sh): + hashes = ["åbc123", "dęf456", "ghí789"] + sh.git.side_effect = [ + *hashes, + f"test åuthor {hashes[0]}\x00test-emåil-{hashes[0]}@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + f"cömmit-title {hashes[0]}\n\ncömmit-body {hashes[0]}", + "#", # git config --get core.commentchar + f"test åuthor {hashes[1]}\x00test-emåil-{hashes[1]}@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + f"cömmit-title {hashes[1]}\n\ncömmit-body {hashes[1]}", + f"test åuthor {hashes[2]}\x00test-emåil-{hashes[2]}@foo.com\x002016-12-03 15:28:15 +0100\x00åbc\n" + f"cömmit-title {hashes[2]}\n\ncömmit-body {hashes[2]}", + f"2\t5\tfile1-{hashes[0]}.txt\n7\t1\tpåth/to/file2.txt\n", + f"2\t5\tfile1-{hashes[1]}.txt\n7\t1\tpåth/to/file2.txt\n", + f"2\t5\tfile1-{hashes[2]}.txt\n7\t1\tpåth/to/file2.txt\n", + f"foöbar-{hashes[0]}\n* hürdur\n", + f"foöbar-{hashes[1]}\n* hürdur\n", + f"foöbar-{hashes[2]}\n* hürdur\n", + ] + + expected_calls = [ + call("log", "-1", hashes[0], "--pretty=%H", **self.expected_sh_special_args), + call("log", "-1", hashes[1], "--pretty=%H", **self.expected_sh_special_args), + call("log", "-1", hashes[2], "--pretty=%H", **self.expected_sh_special_args), + call("log", hashes[0], "-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("log", hashes[1], "-1", "--pretty=%aN%x00%aE%x00%ai%x00%P%n%B", **self.expected_sh_special_args), + call("log", hashes[2], "-1", "--pretty=%aN%x00%aE%x00%ai%x00%P%n%B", **self.expected_sh_special_args), + call( + "diff-tree", "--no-commit-id", "--numstat", "-r", "--root", hashes[0], **self.expected_sh_special_args + ), + call( + "diff-tree", "--no-commit-id", "--numstat", "-r", "--root", hashes[1], **self.expected_sh_special_args + ), + call( + "diff-tree", "--no-commit-id", "--numstat", "-r", "--root", hashes[2], **self.expected_sh_special_args + ), + call("branch", "--contains", hashes[0], **self.expected_sh_special_args), + call("branch", "--contains", hashes[1], **self.expected_sh_special_args), + call("branch", "--contains", hashes[2], **self.expected_sh_special_args), + ] + + context = GitContext.from_local_repository("fåke/path", commit_hashes=hashes) + + # Only first set of 'git log' calls should've happened at this point + self.assertEqual(sh.git.mock_calls, expected_calls[:3]) + + for i, commit in enumerate(context.commits): + expected_hash = hashes[i] + self.assertIsInstance(commit, LocalGitCommit) + self.assertEqual(commit.sha, expected_hash) + self.assertEqual(commit.message.title, f"cömmit-title {expected_hash}") + self.assertEqual(commit.message.body, ["", f"cömmit-body {expected_hash}"]) + self.assertEqual(commit.author_name, f"test åuthor {expected_hash}") + self.assertEqual(commit.author_email, f"test-emåil-{expected_hash}@foo.com") + self.assertEqual( + commit.date, datetime.datetime(2016, 12, 3, 15, 28, 15, tzinfo=dateutil.tz.tzoffset("+0100", 3600)) + ) + self.assertListEqual(commit.parents, ["åbc"]) + self.assertFalse(commit.is_merge_commit) + self.assertFalse(commit.is_fixup_commit) + self.assertFalse(commit.is_fixup_amend_commit) + self.assertFalse(commit.is_squash_commit) + self.assertFalse(commit.is_revert_commit) + + # All 'git log' calls should've happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:7]) + + for i, commit in enumerate(context.commits): + expected_hash = hashes[i] + self.assertListEqual(commit.changed_files, [f"file1-{expected_hash}.txt", "påth/to/file2.txt"]) + expected_file_stats = { + f"file1-{expected_hash}.txt": GitChangedFileStats(f"file1-{expected_hash}.txt", 2, 5), + "påth/to/file2.txt": GitChangedFileStats("påth/to/file2.txt", 7, 1), + } + self.assertDictEqual(commit.changed_files_stats, expected_file_stats) + + # 'git diff-tree' should have happened at this point + self.assertListEqual(sh.git.mock_calls, expected_calls[:10]) + + for i, commit in enumerate(context.commits): + expected_hash = hashes[i] + self.assertListEqual(commit.branches, [f"foöbar-{expected_hash}", "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\nMerge "foo bår commit"', + "#", # git config --get core.commentchar + "6\t2\tfile1.txt\n1\t4\tpå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", + "--numstat", + "-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_fixup_amend_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"]) + expected_file_stats = { + "file1.txt": GitChangedFileStats("file1.txt", 6, 2), + "påth/to/file2.txt": GitChangedFileStats("påth/to/file2.txt", 1, 4), + } + self.assertDictEqual(last_commit.changed_files_stats, expected_file_stats) + # '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_prefixes = {"fixup": "is_fixup_commit", "squash": "is_squash_commit", "amend": "is_fixup_amend_commit"} + for commit_type in commit_prefixes: + 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 + "8\t2\tfile1.txt\n7\t3\tpå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", + "--numstat", + "-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, attr in commit_prefixes.items(): + 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"]) + expected_file_stats = { + "file1.txt": GitChangedFileStats("file1.txt", 8, 2), + "påth/to/file2.txt": GitChangedFileStats("påth/to/file2.txt", 7, 3), + } + self.assertDictEqual(last_commit.changed_files_stats, expected_file_stats) + + # '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_fixup_amend_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_fixup_amend_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_fixup_amend_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_fixup_amend_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_fixup_amend_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_fixup_amend_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_amend_commit(self): + # mapping between cleanup commit prefixes and the commit object attribute + commit_prefixes = {"fixup": "is_fixup_commit", "squash": "is_squash_commit", "amend": "is_fixup_amend_commit"} + + for commit_type in commit_prefixes: + 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, commit_attr_name in commit_prefixes.items(): + self.assertEqual(getattr(commit, commit_attr_name), commit_type == type) + + @patch("gitlint.git.sh") + @patch("arrow.now") + def test_staged_commit(self, now, sh): + """Test for 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 + "4\t2\tfile1.txt\n13\t9\tpå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 expecting + 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", "--numstat", "-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_fixup_amend_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"]) + expected_file_stats = { + "file1.txt": GitChangedFileStats("file1.txt", 4, 2), + "påth/to/file2.txt": GitChangedFileStats("påth/to/file2.txt", 13, 9), + } + self.assertDictEqual(last_commit.changed_files_stats, expected_file_stats) + + self.assertListEqual(sh.git.mock_calls, expected_calls[0:5]) + + @patch("gitlint.git.sh") + def test_staged_commit_with_missing_username(self, sh): + 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") + ctx.commits[0].author_name # accessing this attribute should raise an exception + + @patch("gitlint.git.sh") + def test_staged_commit_with_missing_email(self, sh): + sh.git.side_effect = [ + "#", # git config --get core.commentchar + ErrorReturnCode("git config --get user.email", 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") + ctx.commits[0].author_email # accessing this attribute should raise an exception + + 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}) + + def test_gitchangedfilestats_equality(self): + changed_file_stats = GitChangedFileStats(Path("foö/bar"), 5, 13) + attrs = ["filepath", "additions", "deletions"] + self.object_equality_test(changed_file_stats, attrs) + + @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.now(datetime.timezone.utc) + 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": GitChangedFileStats("föo/bar", 5, 13)}, + ["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": GitChangedFileStats("föo/bar", 5, 13)}, + ["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, + "branches": commit1.branches, + } + + self.object_equality_test( + commit1, + kwargs.keys(), + {"context": commit1.context, "changed_files_stats": {"föo/bar": GitChangedFileStats("föo/bar", 5, 13)}}, + ) + + # 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) + + # Check changed_files and changed_files_stats + commit2.changed_files_stats = {"föo/bar2": GitChangedFileStats("föo/bar2", 5, 13)} + self.assertNotEqual(commit1, commit2) + + @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-core/gitlint/tests/git/test_git_context.py b/gitlint-core/gitlint/tests/git/test_git_context.py new file mode 100644 index 0000000..751136c --- /dev/null +++ b/gitlint-core/gitlint/tests/git/test_git_context.py @@ -0,0 +1,73 @@ +from unittest.mock import call, patch + +from gitlint.git import GitContext +from gitlint.tests.base import BaseTestCase + + +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 = ["#", "\nfoöbar\n"] # git config --get core.commentchar + + 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-core/gitlint/tests/rules/__init__.py b/gitlint-core/gitlint/tests/rules/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/gitlint-core/gitlint/tests/rules/__init__.py diff --git a/gitlint-core/gitlint/tests/rules/test_body_rules.py b/gitlint-core/gitlint/tests/rules/test_body_rules.py new file mode 100644 index 0000000..c142e6e --- /dev/null +++ b/gitlint-core/gitlint/tests/rules/test_body_rules.py @@ -0,0 +1,235 @@ +from gitlint import rules +from gitlint.tests.base import BaseTestCase + + +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{}\n".format("å" * 21)) + violations = rule.validate(commit) + self.assertListEqual(violations, [expected_violation]) + + # Make sure we don't get the error if the body-length is exactly the min-length + rule = rules.BodyMinLength({"min-length": 8}) + commit = self.gitcommit("Tïtle\n\n{}\n".format("å" * 8)) + violations = rule.validate(commit) + self.assertIsNone(violations) + + def test_body_missing(self): + rule = rules.BodyMissing() + + # assert no error - body is present + commit = self.gitcommit("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-core/gitlint/tests/rules/test_configuration_rules.py b/gitlint-core/gitlint/tests/rules/test_configuration_rules.py new file mode 100644 index 0000000..5935a4a --- /dev/null +++ b/gitlint-core/gitlint/tests/rules/test_configuration_rules.py @@ -0,0 +1,178 @@ +from gitlint import rules +from gitlint.config import LintConfig +from gitlint.tests.base import ( + EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING, + BaseTestCase, +) + + +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_messages = [ + EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING.format("I1", "ignore-by-title"), + "DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + "Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: all", + ] + self.assert_logged(expected_log_messages) + + # 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_messages += [ + "DEBUG: gitlint.rules Ignoring commit because of rule 'I1': " + "Commit title 'Releäse' matches the regex '^Releäse(.*)', ignoring rules: T1,B2" + ] + self.assert_logged(expected_log_messages) + + 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_messages = [ + EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING.format("I2", "ignore-by-body"), + "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_logged(expected_log_messages) + + # 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_messages += [ + "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_logged(expected_log_messages) + + 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 + + # No author available -> rule is skipped and warning logged + staged_commit = self.gitcommit("Tïtle\n\nThis is\n a relëase body\n line") + rule = rules.IgnoreByAuthorName({"regex": "foo"}) + config = LintConfig() + rule.apply(config, staged_commit) + self.assertEqual(config, LintConfig()) + expected_log_messages = [ + "WARNING: gitlint.rules ignore-by-author-name - I4: skipping - commit.author_name unknown. " + "Suggested fix: Use the --staged flag (or set general.staged=True in .gitlint). " + "More details: https://jorisroovers.com/gitlint/configuration/#staged" + ] + self.assert_logged(expected_log_messages) + + # Non-Matching regex -> expect config to stay the same + rule = rules.IgnoreByAuthorName({"regex": "foo"}) + expected_config = LintConfig() + rule.apply(config, commit) + self.assertEqual(config, LintConfig()) + + # 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_messages += [ + EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING.format("I4", "ignore-by-author-name"), + "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_logged(expected_log_messages) + + # 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_messages += [ + "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_logged(expected_log_messages) + + 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 + expected_log_messages = [ + EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING.format("I3", "ignore-body-lines"), + "DEBUG: gitlint.rules Ignoring line ' a relëase body' because it " + "matches '(.*)relëase(.*)'", + ] + self.assert_logged(expected_log_messages) + + # 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-core/gitlint/tests/rules/test_meta_rules.py b/gitlint-core/gitlint/tests/rules/test_meta_rules.py new file mode 100644 index 0000000..a574aa3 --- /dev/null +++ b/gitlint-core/gitlint/tests/rules/test_meta_rules.py @@ -0,0 +1,80 @@ +from gitlint.rules import AuthorValidEmail, RuleViolation +from gitlint.tests.base import ( + EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING, + BaseTestCase, +) + + +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)]) + + # Ensure nothing is logged, this relates specifically to a deprecation warning on the use of + # re.match vs re.search in the rules (see issue #254) + # If no custom regex is used, the rule uses the default regex in combination with re.search + self.assert_logged([]) + + 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)]) + + # When a custom regex is used, a warning should be logged by default + self.assert_logged([EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING.format("M1", "author-valid-email")]) diff --git a/gitlint-core/gitlint/tests/rules/test_rules.py b/gitlint-core/gitlint/tests/rules/test_rules.py new file mode 100644 index 0000000..b401372 --- /dev/null +++ b/gitlint-core/gitlint/tests/rules/test_rules.py @@ -0,0 +1,32 @@ +from gitlint.rules import Rule, RuleViolation +from gitlint.tests.base import BaseTestCase + + +class RuleTests(BaseTestCase): + def test_ruleviolation__str__(self): + expected = '57: rule-ïd Tēst message: "Tēst content"' + self.assertEqual(str(RuleViolation("rule-ïd", "Tēst message", "Tēst content", 57)), expected) + + 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() + self.assertIsNone(rule._log) + rule.log.debug("Tēst message") + self.assert_log_contains("DEBUG: gitlint.rules Tēst message") + + # Assert the same logger is reused when logging multiple messages + log = rule._log + rule.log.debug("Anöther message") + self.assertEqual(log, rule._log) + self.assert_log_contains("DEBUG: gitlint.rules Anöther 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-core/gitlint/tests/rules/test_title_rules.py b/gitlint-core/gitlint/tests/rules/test_title_rules.py new file mode 100644 index 0000000..cba3851 --- /dev/null +++ b/gitlint-core/gitlint/tests/rules/test_title_rules.py @@ -0,0 +1,200 @@ +from gitlint.rules import ( + RuleViolation, + TitleHardTab, + TitleLeadingWhitespace, + TitleMaxLength, + TitleMinLength, + TitleMustNotContainWord, + TitleRegexMatches, + TitleTrailingPunctuation, + TitleTrailingWhitespace, +) +from gitlint.tests.base import BaseTestCase + + +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-core/gitlint/tests/rules/test_user_rules.py b/gitlint-core/gitlint/tests/rules/test_user_rules.py new file mode 100644 index 0000000..8086bea --- /dev/null +++ b/gitlint-core/gitlint/tests/rules/test_user_rules.py @@ -0,0 +1,266 @@ +import os +import sys + +from gitlint import options, rules +from gitlint.rule_finder import assert_valid_rule_class, find_rule_classes +from gitlint.rules import UserRuleError +from gitlint.tests.base import BaseTestCase + + +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 # pragma: nocover + + class MyCommitRuleClass(rules.CommitRule): + id = "UC2" + name = "my-cömmit-rule" + + def validate(self): + pass # pragma: nocover + + class MyConfigurationRuleClass(rules.ConfigurationRule): + id = "UC3" + name = "my-cönfiguration-rule" + + def apply(self): + pass # pragma: nocover + + # 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 a 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] + 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) + + # apply attribute - not a method + MyRuleClass.apply = "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 # pragma: nocover + + # 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 + self.assertIsNone(assert_valid_rule_class(MyRuleClass)) diff --git a/gitlint-core/gitlint/tests/samples/commit_message/fixup b/gitlint-core/gitlint/tests/samples/commit_message/fixup new file mode 100644 index 0000000..2539dd1 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/fixup @@ -0,0 +1 @@ +fixup! WIP: This is a fixup cömmit with violations. diff --git a/gitlint-core/gitlint/tests/samples/commit_message/fixup_amend b/gitlint-core/gitlint/tests/samples/commit_message/fixup_amend new file mode 100644 index 0000000..293a2b7 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/fixup_amend @@ -0,0 +1 @@ +amend! WIP: This is a fixup cömmit with violations. diff --git a/gitlint-core/gitlint/tests/samples/commit_message/merge b/gitlint-core/gitlint/tests/samples/commit_message/merge new file mode 100644 index 0000000..764e131 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/merge @@ -0,0 +1,3 @@ +Merge: "This is a merge commit with a long title that most definitely exceeds the normål limit of 72 chars" +This line should be ëmpty +This is the first line is meant to test å line that exceeds the maximum line length of 80 characters. diff --git a/gitlint-core/gitlint/tests/samples/commit_message/no-violations b/gitlint-core/gitlint/tests/samples/commit_message/no-violations new file mode 100644 index 0000000..33c73b9 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/no-violations @@ -0,0 +1,6 @@ +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-core/gitlint/tests/samples/commit_message/revert b/gitlint-core/gitlint/tests/samples/commit_message/revert new file mode 100644 index 0000000..6dc8368 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/revert @@ -0,0 +1,3 @@ +Revert "WIP: this is a tïtle" + +This reverts commit a8ad67e04164a537198dea94a4fde81c5592ae9c.
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/commit_message/sample1 b/gitlint-core/gitlint/tests/samples/commit_message/sample1 new file mode 100644 index 0000000..646c0cb --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/sample1 @@ -0,0 +1,14 @@ +Commit title contåining 'WIP', as well as trailing punctuation. +This line should be empty +This is the first line of the commit message body and it is meant to test a line that exceeds the maximum line length of 80 characters. +This line has a tråiling space. +This line has a trailing tab. +# This is a cömmented line +# ------------------------ >8 ------------------------ +# Anything after this line should be cleaned up +# this line appears on `git commit -v` command +diff --git a/gitlint/tests/samples/commit_message/sample1 b/gitlint/tests/samples/commit_message/sample1 +index 82dbe7f..ae71a14 100644 +--- a/gitlint/tests/samples/commit_message/sample1 ++++ b/gitlint/tests/samples/commit_message/sample1 +@@ -1 +1 @@ diff --git a/gitlint-core/gitlint/tests/samples/commit_message/sample2 b/gitlint-core/gitlint/tests/samples/commit_message/sample2 new file mode 100644 index 0000000..356540c --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/sample2 @@ -0,0 +1 @@ +Just a title contåining WIP
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/commit_message/sample3 b/gitlint-core/gitlint/tests/samples/commit_message/sample3 new file mode 100644 index 0000000..d67d70b --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/sample3 @@ -0,0 +1,6 @@ + Commit title containing 'WIP', leading and tråiling whitespace and longer than 72 characters. +This line should be empty +This is the first line is meånt to test a line that exceeds the maximum line length of 80 characters. +This line has a trailing space. +This line has a tråiling tab. +# This is a commented line diff --git a/gitlint-core/gitlint/tests/samples/commit_message/sample4 b/gitlint-core/gitlint/tests/samples/commit_message/sample4 new file mode 100644 index 0000000..c858d89 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/sample4 @@ -0,0 +1,7 @@ + Commit title containing 'WIP', leading and tråiling whitespace and longer than 72 characters. +This line should be empty +This is the first line is meånt to test a line that exceeds the maximum line length of 80 characters. +This line has a tråiling space. +This line has a trailing tab. +# This is a commented line +gitlint-ignore: all diff --git a/gitlint-core/gitlint/tests/samples/commit_message/sample5 b/gitlint-core/gitlint/tests/samples/commit_message/sample5 new file mode 100644 index 0000000..77ccbe8 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/sample5 @@ -0,0 +1,7 @@ + Commit title containing 'WIP', leading and tråiling whitespace and longer than 72 characters. +This line should be ëmpty +This is the first line is meånt to test a line that exceeds the maximum line length of 80 characters. +This line has a tråiling space. +This line has a trailing tab. +# This is a commented line +gitlint-ignore: T3, T6, body-max-line-length diff --git a/gitlint-core/gitlint/tests/samples/commit_message/squash b/gitlint-core/gitlint/tests/samples/commit_message/squash new file mode 100644 index 0000000..538a93a --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/commit_message/squash @@ -0,0 +1,3 @@ +squash! WIP: This is a squash cömmit with violations. + +Body töo short diff --git a/gitlint-core/gitlint/tests/samples/config/AUTHORS b/gitlint-core/gitlint/tests/samples/config/AUTHORS new file mode 100644 index 0000000..1c355d6 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/AUTHORS @@ -0,0 +1,2 @@ +John Doe <john.doe@mail.com> +Bob Smith <bob.smith@mail.com>
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/config/gitlintconfig b/gitlint-core/gitlint/tests/samples/config/gitlintconfig new file mode 100644 index 0000000..8c93f71 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/gitlintconfig @@ -0,0 +1,15 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 +ignore-merge-commits = false +debug = false + +[title-max-length] +line-length=20 + +[B1] +# B1 = body-max-line-length +line-length=30 + +[title-must-not-contain-word] +words=WIP,bögus
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/config/invalid-option-value b/gitlint-core/gitlint/tests/samples/config/invalid-option-value new file mode 100644 index 0000000..92015aa --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/invalid-option-value @@ -0,0 +1,11 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 + +[title-max-length] +line-length=föo + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/config/named-rules b/gitlint-core/gitlint/tests/samples/config/named-rules new file mode 100644 index 0000000..73ab0d2 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/named-rules @@ -0,0 +1,8 @@ +[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-core/gitlint/tests/samples/config/no-sections b/gitlint-core/gitlint/tests/samples/config/no-sections new file mode 100644 index 0000000..ec82b25 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/no-sections @@ -0,0 +1 @@ +ignore=title-max-length, T3 diff --git a/gitlint-core/gitlint/tests/samples/config/nonexisting-general-option b/gitlint-core/gitlint/tests/samples/config/nonexisting-general-option new file mode 100644 index 0000000..d5cfef2 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/nonexisting-general-option @@ -0,0 +1,13 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 +ignore-merge-commits = false +foo = bar + +[title-max-length] +line-length=20 + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/config/nonexisting-option b/gitlint-core/gitlint/tests/samples/config/nonexisting-option new file mode 100644 index 0000000..6964c77 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/nonexisting-option @@ -0,0 +1,11 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 + +[title-max-length] +föobar=foo + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/config/nonexisting-rule b/gitlint-core/gitlint/tests/samples/config/nonexisting-rule new file mode 100644 index 0000000..c0f0d2b --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/config/nonexisting-rule @@ -0,0 +1,11 @@ +[general] +ignore=title-trailing-whitespace,B2 +verbosity = 1 + +[föobar] +line-length=20 + + +[B1] +# B1 = body-max-line-length +line-length=30
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/user_rules/bogus-file.txt b/gitlint-core/gitlint/tests/samples/user_rules/bogus-file.txt new file mode 100644 index 0000000..2a56650 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/user_rules/bogus-file.txt @@ -0,0 +1,2 @@ +This is just a bogus file. +This file being here is part of the test: gitlint should ignore it.
\ No newline at end of file diff --git a/gitlint-core/gitlint/tests/samples/user_rules/import_exception/invalid_python.py b/gitlint-core/gitlint/tests/samples/user_rules/import_exception/invalid_python.py new file mode 100644 index 0000000..a123a64 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/user_rules/import_exception/invalid_python.py @@ -0,0 +1,2 @@ +# This is invalid python code which will cause an import exception +class MyObject: diff --git a/gitlint-core/gitlint/tests/samples/user_rules/incorrect_linerule/my_line_rule.py b/gitlint-core/gitlint/tests/samples/user_rules/incorrect_linerule/my_line_rule.py new file mode 100644 index 0000000..b23b5bf --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/user_rules/incorrect_linerule/my_line_rule.py @@ -0,0 +1,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-core/gitlint/tests/samples/user_rules/my_commit_rules.foo b/gitlint-core/gitlint/tests/samples/user_rules/my_commit_rules.foo new file mode 100644 index 0000000..605d704 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/user_rules/my_commit_rules.foo @@ -0,0 +1,16 @@ +# This rule is ignored because it doesn't have a .py extension +from gitlint.rules import CommitRule, RuleViolation +from gitlint.options import IntOption + + +class MyUserCommitRule2(CommitRule): + name = "my-user-commit-rule2" + id = "TUC2" + options_spec = [IntOption('violation-count', 0, "Number of violations to return")] + + def validate(self, _commit): + violations = [] + for i in range(1, self.options['violation-count'].value + 1): + violations.append(RuleViolation(self.id, "Commit violation %d" % i, "Content %d" % i, i)) + + return violations diff --git a/gitlint-core/gitlint/tests/samples/user_rules/my_commit_rules.py b/gitlint-core/gitlint/tests/samples/user_rules/my_commit_rules.py new file mode 100644 index 0000000..c947250 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/user_rules/my_commit_rules.py @@ -0,0 +1,25 @@ +from gitlint.options import IntOption +from gitlint.rules import CommitRule, RuleViolation + + +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 # pragma: nocover + + +global_variable_should_be_ignored = True diff --git a/gitlint-core/gitlint/tests/samples/user_rules/parent_package/__init__.py b/gitlint-core/gitlint/tests/samples/user_rules/parent_package/__init__.py new file mode 100644 index 0000000..c2863fe --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/user_rules/parent_package/__init__.py @@ -0,0 +1,12 @@ +# 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 [] # pragma: nocover diff --git a/gitlint-core/gitlint/tests/samples/user_rules/parent_package/my_commit_rules.py b/gitlint-core/gitlint/tests/samples/user_rules/parent_package/my_commit_rules.py new file mode 100644 index 0000000..f91cb07 --- /dev/null +++ b/gitlint-core/gitlint/tests/samples/user_rules/parent_package/my_commit_rules.py @@ -0,0 +1,10 @@ +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-core/gitlint/tests/test_cache.py b/gitlint-core/gitlint/tests/test_cache.py new file mode 100644 index 0000000..08b821e --- /dev/null +++ b/gitlint-core/gitlint/tests/test_cache.py @@ -0,0 +1,55 @@ +from gitlint.cache import PropertyCache, cache +from gitlint.tests.base import BaseTestCase + + +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-core/gitlint/tests/test_deprecation.py b/gitlint-core/gitlint/tests/test_deprecation.py new file mode 100644 index 0000000..bfe5934 --- /dev/null +++ b/gitlint-core/gitlint/tests/test_deprecation.py @@ -0,0 +1,26 @@ +from gitlint.config import LintConfig +from gitlint.deprecation import Deprecation +from gitlint.rules import IgnoreByTitle +from gitlint.tests.base import ( + EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING, + BaseTestCase, +) + + +class DeprecationTests(BaseTestCase): + def test_get_regex_method(self): + config = LintConfig() + Deprecation.config = config + rule = IgnoreByTitle({"regex": "^Releäse(.*)"}) + + # When general.regex-style-search=True, we expect regex.search to be returned and no warning to be logged + config.regex_style_search = True + regex_method = Deprecation.get_regex_method(rule, rule.options["regex"]) + self.assertEqual(regex_method, rule.options["regex"].value.search) + self.assert_logged([]) + + # When general.regex-style-search=False, we expect regex.match to be returned and a warning to be logged + config.regex_style_search = False + regex_method = Deprecation.get_regex_method(rule, rule.options["regex"]) + self.assertEqual(regex_method, rule.options["regex"].value.match) + self.assert_logged([EXPECTED_REGEX_STYLE_SEARCH_DEPRECATION_WARNING.format("I1", "ignore-by-title")]) diff --git a/gitlint-core/gitlint/tests/test_display.py b/gitlint-core/gitlint/tests/test_display.py new file mode 100644 index 0000000..e669cdb --- /dev/null +++ b/gitlint-core/gitlint/tests/test_display.py @@ -0,0 +1,60 @@ +from io import StringIO +from unittest.mock import patch + +from gitlint.config import LintConfig +from gitlint.display import Display +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 throughout 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 throughout all of this + self.assertEqual("", stdout.getvalue()) diff --git a/gitlint-core/gitlint/tests/test_hooks.py b/gitlint-core/gitlint/tests/test_hooks.py new file mode 100644 index 0000000..7390f14 --- /dev/null +++ b/gitlint-core/gitlint/tests/test_hooks.py @@ -0,0 +1,139 @@ +import os +from unittest.mock import ANY, mock_open, patch + +from gitlint.config import LintConfig +from gitlint.hooks import ( + COMMIT_MSG_HOOK_DST_PATH, + COMMIT_MSG_HOOK_SRC_PATH, + GITLINT_HOOK_IDENTIFIER, + GitHookInstaller, + GitHookInstallerError, +) +from gitlint.tests.base import BaseTestCase + + +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("builtins.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("builtins.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-core/gitlint/tests/test_lint.py b/gitlint-core/gitlint/tests/test_lint.py new file mode 100644 index 0000000..1cf3772 --- /dev/null +++ b/gitlint-core/gitlint/tests/test_lint.py @@ -0,0 +1,296 @@ +from io import StringIO +from unittest.mock import patch + +from gitlint.config import LintConfig, LintConfigBuilder +from gitlint.lint import GitLinter +from gitlint.rules import RuleViolation, TitleMustNotContainWord +from gitlint.tests.base import BaseTestCase + + +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]) + # fmt: off + 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) + ] + # fmt: on + + 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]) + + # fmt: off + 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) + ] + # fmt: on + + 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"))) + # fmt: off + 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) + ] + # fmt: on + self.assertListEqual(violations, expected_errors) + + def test_lint_special_commit(self): + for commit_type in ["merge", "revert", "squash", "fixup", "fixup_amend"]: + 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-core/gitlint/tests/test_options.py b/gitlint-core/gitlint/tests/test_options.py new file mode 100644 index 0000000..deff723 --- /dev/null +++ b/gitlint-core/gitlint/tests/test_options.py @@ -0,0 +1,240 @@ +import os +import re + +from gitlint.options import ( + BoolOption, + IntOption, + ListOption, + PathOption, + RegexOption, + RuleOptionError, + StrOption, +) +from gitlint.tests.base import BaseTestCase + + +class RuleOptionTests(BaseTestCase): + def test_option__str__(self): + option = StrOption("tëst-option", "åbc", "Test Dëscription") + self.assertEqual(str(option), "(tëst-option: åbc (Test Dëscription))") + + 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.path.realpath(".")) + 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-core/gitlint/tests/test_utils.py b/gitlint-core/gitlint/tests/test_utils.py new file mode 100644 index 0000000..d21ec3f --- /dev/null +++ b/gitlint-core/gitlint/tests/test_utils.py @@ -0,0 +1,70 @@ +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 False (not using) + patched_env.get.return_value = None + self.assertEqual(utils.use_sh_library(), False) + + @patch("gitlint.utils.locale") + def test_terminal_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_terminal_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") diff --git a/gitlint-core/gitlint/utils.py b/gitlint-core/gitlint/utils.py new file mode 100644 index 0000000..3ccb78b --- /dev/null +++ b/gitlint-core/gitlint/utils.py @@ -0,0 +1,87 @@ +import codecs +import locale +import os +import platform + +# Note: While we can easily inline the logic related to the constants set in this module, we deliberately create +# small functions that encapsulate that logic as this enables easy unit testing. In particular, by creating functions +# we can easily mock the dependencies during testing, which is not possible if the code is not enclosed in a function +# and just executed at import-time. + +######################################################################################################################## +LOG_FORMAT = "%(levelname)s: %(name)s %(message)s" + +######################################################################################################################## +# PLATFORM_IS_WINDOWS + + +def platform_is_windows(): + return "windows" in platform.system().lower() + + +PLATFORM_IS_WINDOWS = platform_is_windows() + +######################################################################################################################## +# USE_SH_LIB +# Determine whether to use the `sh` library +# On windows we won't want to use the sh library since it's not supported - instead we'll use our own shell module. +# However, we want to be able to overwrite this behavior for testing using the GITLINT_USE_SH_LIB env var. + + +def use_sh_library(): + gitlint_use_sh_lib_env = os.environ.get("GITLINT_USE_SH_LIB", None) + if gitlint_use_sh_lib_env: + return gitlint_use_sh_lib_env == "1" + return False + + +USE_SH_LIB = use_sh_library() + +######################################################################################################################## +# TERMINAL_ENCODING +# Encoding used for terminal encoding/decoding. + + +def getpreferredencoding(): + """Modified version of local.getpreferredencoding() that takes into account LC_ALL, LC_CTYPE, LANG env vars + on windows and falls back to UTF-8.""" + fallback_encoding = "UTF-8" + preferred_encoding = locale.getpreferredencoding() or fallback_encoding + + # On Windows, we mimic git/linux by trying to read the LC_ALL, LC_CTYPE, LANG env vars manually + # (on Linux/MacOS the `getpreferredencoding()` call will take care of this). + # We fallback to UTF-8 + if PLATFORM_IS_WINDOWS: + preferred_encoding = fallback_encoding + for env_var in ["LC_ALL", "LC_CTYPE", "LANG"]: + encoding = os.environ.get(env_var, False) + if encoding: + # Support dotted (C.UTF-8) and non-dotted (C or UTF-8) charsets: + # If encoding contains a dot: split and use second part, otherwise use everything + dot_index = encoding.find(".") + preferred_encoding = encoding[dot_index + 1 :] if dot_index != -1 else encoding + break + + # We've determined what encoding the user *wants*, let's now check if it's actually a valid encoding on the + # system. If not, fallback to UTF-8. + # This scenario is fairly common on Windows where git sets LC_CTYPE=C when invoking the commit-msg hook, which + # is not a valid encoding in Python on Windows. + try: + codecs.lookup(preferred_encoding) + except LookupError: + preferred_encoding = fallback_encoding + + return preferred_encoding + + +TERMINAL_ENCODING = getpreferredencoding() + +######################################################################################################################## +# FILE_ENCODING +# Gitlint assumes UTF-8 encoding for all file operations: +# - reading/writing its own hook and config files +# - reading/writing git commit messages +# Git does have i18n.commitEncoding and i18n.logOutputEncoding options which we might want to take into account, +# but that's not supported today. + +FILE_ENCODING = "UTF-8" diff --git a/gitlint-core/pyproject.toml b/gitlint-core/pyproject.toml new file mode 100644 index 0000000..e65b7b0 --- /dev/null +++ b/gitlint-core/pyproject.toml @@ -0,0 +1,71 @@ +[build-system] +requires = ["hatchling", "hatch-vcs"] +build-backend = "hatchling.build" + +[project] +name = "gitlint-core" +dynamic = ["version", "urls"] +description = "Git commit message linter written in python, checks your commit messages for style." +readme = "README.md" +license = "MIT" +requires-python = ">=3.7" +authors = [{ name = "Joris Roovers" }] +keywords = [ + "git", + "gitlint", + "lint", # +] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Environment :: Console", + "Intended Audience :: Developers", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Programming Language :: Python", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: Implementation :: CPython", + "Programming Language :: Python :: Implementation :: PyPy", + "Topic :: Software Development :: Quality Assurance", + "Topic :: Software Development :: Testing", +] +dependencies = [ + "arrow>=1", + "Click>=8", + "importlib-metadata >= 1.0 ; python_version < \"3.8\"", + "sh>=1.13.0 ; sys_platform != \"win32\"", +] + +[project.optional-dependencies] +trusted-deps = [ + "arrow==1.2.3", + "Click==8.1.3", + "sh==1.14.3 ; sys_platform != \"win32\"", +] + +[project.scripts] +gitlint = "gitlint.cli:cli" + +[tool.hatch.version] +source = "vcs" +raw-options = { root = ".." } + +[tool.hatch.build] +include = [ + "/gitlint", # +] + +exclude = [ + "/gitlint/tests", # +] + +[tool.hatch.metadata.hooks.vcs.urls] +Homepage = "https://jorisroovers.github.io/gitlint" +Documentation = "https://jorisroovers.github.io/gitlint" +Source = "https://github.com/jorisroovers/gitlint/tree/main/gitlint-core" +Changelog = "https://github.com/jorisroovers/gitlint/blob/main/CHANGELOG.md" +# TODO(jorisroovers): Temporary disable until fixed in hatch-vcs (see #460) +# 'Source Commit' = "https://github.com/jorisroovers/gitlint/tree/{commit_hash}/gitlint-core"
\ No newline at end of file |