diff --git a/commitizen/bump.py b/commitizen/bump.py index 030c8f1e5..a85853582 100644 --- a/commitizen/bump.py +++ b/commitizen/bump.py @@ -2,64 +2,18 @@ import os import re -from collections import OrderedDict from glob import iglob -from logging import getLogger from string import Template -from typing import TYPE_CHECKING, cast +from typing import TYPE_CHECKING -from commitizen.defaults import BUMP_MESSAGE, MAJOR, MINOR, PATCH +from commitizen.defaults import BUMP_MESSAGE from commitizen.exceptions import CurrentVersionNotFoundError -from commitizen.git import GitCommit, smart_open +from commitizen.git import smart_open if TYPE_CHECKING: from collections.abc import Generator, Iterable - from commitizen.version_schemes import Increment, VersionProtocol - -VERSION_TYPES = [None, PATCH, MINOR, MAJOR] - -logger = getLogger("commitizen") - - -def find_increment( - commits: list[GitCommit], regex: str, increments_map: dict | OrderedDict -) -> Increment | None: - if isinstance(increments_map, dict): - increments_map = OrderedDict(increments_map) - - # Most important cases are major and minor. - # Everything else will be considered patch. - select_pattern = re.compile(regex) - increment: str | None = None - - for commit in commits: - for message in commit.message.split("\n"): - result = select_pattern.search(message) - - if result: - found_keyword = result.group(1) - new_increment = None - for match_pattern in increments_map.keys(): - if re.match(match_pattern, found_keyword): - new_increment = increments_map[match_pattern] - break - - if new_increment is None: - logger.debug( - f"no increment needed for '{found_keyword}' in '{message}'" - ) - - if VERSION_TYPES.index(increment) < VERSION_TYPES.index(new_increment): - logger.debug( - f"increment detected is '{new_increment}' due to '{found_keyword}' in '{message}'" - ) - increment = new_increment - - if increment == MAJOR: - break - - return cast("Increment", increment) + from commitizen.version_schemes import VersionProtocol def update_version_in_files( diff --git a/commitizen/bump_rule.py b/commitizen/bump_rule.py new file mode 100644 index 000000000..f31e234ea --- /dev/null +++ b/commitizen/bump_rule.py @@ -0,0 +1,191 @@ +from __future__ import annotations + +import re +from functools import cached_property +from typing import TYPE_CHECKING, Protocol + +from commitizen.exceptions import NoPatternMapError +from commitizen.version_increment import VersionIncrement + +if TYPE_CHECKING: + from collections.abc import Mapping + + +# Re-export for backward compatibility with code that uses +# ``from commitizen.bump_rule import VersionIncrement``. +__all__ = [ + "BumpRule", + "ConventionalCommitBumpRule", + "CustomBumpRule", + "VersionIncrement", +] + + +class BumpRule(Protocol): + """A protocol defining the interface for version bump rules. + + This protocol specifies the contract that all version bump rule implementations must follow. + It defines how commit messages should be analyzed to determine the appropriate semantic + version increment. + + The protocol is used to ensure consistent behavior across different bump rule implementations, + such as conventional commits or custom rules. + """ + + def extract_increment( + self, commit_message: str, major_version_zero: bool + ) -> VersionIncrement: + """Determine the version increment based on a commit message. + + This method analyzes a commit message to determine what kind of version increment + is needed. It handles special cases for breaking changes and respects the major_version_zero flag. + + See the following subclasses for more details: + - ConventionalCommitBumpRule: For conventional commits + - CustomBumpRule: For custom bump rules + + Args: + commit_message: The commit message to analyze. + major_version_zero: If True, breaking changes will result in a MINOR version bump instead of MAJOR + + Returns: + VersionIncrement: The type of version increment needed: + """ + + +class ConventionalCommitBumpRule(BumpRule): + _BREAKING_CHANGE_TYPES = {"BREAKING CHANGE", "BREAKING-CHANGE"} + _MINOR_CHANGE_TYPES = {"feat"} + _PATCH_CHANGE_TYPES = {"fix", "perf", "refactor"} + + def extract_increment( + self, commit_message: str, major_version_zero: bool + ) -> VersionIncrement: + if not (m := self._head_pattern.match(commit_message)): + return VersionIncrement.NONE + + change_type = m.group("change_type") + if m.group("bang") or change_type in self._BREAKING_CHANGE_TYPES: + return ( + VersionIncrement.MINOR if major_version_zero else VersionIncrement.MAJOR + ) + + if change_type in self._MINOR_CHANGE_TYPES: + return VersionIncrement.MINOR + + if change_type in self._PATCH_CHANGE_TYPES: + return VersionIncrement.PATCH + + return VersionIncrement.NONE + + @cached_property + def _head_pattern(self) -> re.Pattern: + change_types = [ + *self._BREAKING_CHANGE_TYPES, + *self._PATCH_CHANGE_TYPES, + *self._MINOR_CHANGE_TYPES, + "docs", + "style", + "test", + "build", + "ci", + ] + re_change_type = r"(?P" + "|".join(change_types) + r")" + re_scope = r"(?P\(.+\))?" + re_bang = r"(?P!)?" + return re.compile(f"^{re_change_type}{re_scope}{re_bang}:") + + +class CustomBumpRule(BumpRule): + def __init__( + self, + bump_pattern: str, + bump_map: Mapping[str, VersionIncrement], + bump_map_major_version_zero: Mapping[str, VersionIncrement] | None = None, + ) -> None: + """Initialize a custom bump rule for version incrementing. + + This constructor creates a rule that determines how version numbers should be + incremented based on commit messages. It validates and compiles the provided + pattern and maps for use in version bumping. + + The fallback logic is used for backward compatibility. + + Args: + bump_pattern: A regex pattern string used to match commit messages. + Example: r"^((?Pmajor)|(?Pminor)|(?Ppatch))(?P\\(.+\\))?(?P!)?:" + + Or with fallback regex: r"^((BREAKING[\\-\\ ]CHANGE|\\w+)(\\(.+\\))?!?):" # First group is type + bump_map: A mapping of commit types to their corresponding version increments. + Example: { + "major": VersionIncrement.MAJOR, + "bang": VersionIncrement.MAJOR, + "minor": VersionIncrement.MINOR, + "patch": VersionIncrement.PATCH + } + Or with fallback: { + r"^.+!$": VersionIncrement.MAJOR, + r"^BREAKING[\\-\\ ]CHANGE": VersionIncrement.MAJOR, + r"^feat": VersionIncrement.MINOR, + r"^fix": VersionIncrement.PATCH, + r"^refactor": VersionIncrement.PATCH, + r"^perf": VersionIncrement.PATCH, + } + + NOTE: For the fallback path, iteration order matters because the rule + returns the first matching pattern. Python 3.7+ preserves insertion + order for plain dicts. + bump_map_major_version_zero: A mapping of commit types to version increments + specifically for when the major version is 0. This allows for different + versioning behavior during initial development. The format is the same + as bump_map. May be ``None`` if the plugin doesn't need to bump + differently in the ``major_version_zero`` mode; in that case calling + ``extract_increment(..., major_version_zero=True)`` will raise + :class:`NoPatternMapError` (matching the legacy behaviour). + + Raises: + NoPatternMapError: If ``bump_pattern`` or ``bump_map`` is empty or ``None``. + """ + if not bump_map or not bump_pattern: + raise NoPatternMapError( + f"Invalid bump rule: {bump_pattern=} and {bump_map=}" + ) + + self.bump_pattern = re.compile(bump_pattern) + self.bump_map = bump_map + self.bump_map_major_version_zero = bump_map_major_version_zero + + def extract_increment( + self, commit_message: str, major_version_zero: bool + ) -> VersionIncrement: + if major_version_zero: + if not self.bump_map_major_version_zero: + raise NoPatternMapError( + "bump_map_major_version_zero is required when major_version_zero is True" + ) + effective_bump_map = self.bump_map_major_version_zero + else: + effective_bump_map = self.bump_map + + if not (m := self.bump_pattern.search(commit_message)): + return VersionIncrement.NONE + + try: + increments = ( + increment + for name, increment in effective_bump_map.items() + if m.group(name) + ) + increment = max(increments, default=VersionIncrement.NONE) + if increment != VersionIncrement.NONE: + return increment + except IndexError: + pass + + # Fallback to legacy bump rule, for backward compatibility. + # Iteration order matters: returns the FIRST matching pattern. + found_keyword = m.group(1) + for match_pattern, increment in effective_bump_map.items(): + if re.match(match_pattern, found_keyword): + return increment + return VersionIncrement.NONE diff --git a/commitizen/commands/bump.py b/commitizen/commands/bump.py index 0b6e0ffa3..9de57e2c9 100644 --- a/commitizen/commands/bump.py +++ b/commitizen/commands/bump.py @@ -7,6 +7,7 @@ import questionary from commitizen import bump, factory, git, hooks, out +from commitizen.bump_rule import VersionIncrement from commitizen.changelog_formats import get_changelog_format from commitizen.commands.changelog import Changelog from commitizen.defaults import Settings @@ -18,14 +19,12 @@ InvalidManualVersion, NoCommitsFoundError, NoneIncrementExit, - NoPatternMapError, NotAGitProjectError, NotAllowed, ) from commitizen.providers import get_provider from commitizen.tags import TagRules from commitizen.version_schemes import ( - Increment, InvalidVersion, Prerelease, VersionProtocol, @@ -53,7 +52,7 @@ class BumpArgs(Settings, total=False): get_next: bool # TODO: maybe rename to `next_version_to_stdout` git_output_to_stderr: bool increment_mode: str - increment: Increment | None + increment: VersionIncrement | None local_version: bool manual_version: str | None no_verify: bool @@ -144,27 +143,21 @@ def _is_initial_tag( ) return bool(questionary.confirm("Is this the first tag created?").ask()) - def _find_increment(self, commits: list[git.GitCommit]) -> Increment | None: + def _find_increment(self, commits: list[git.GitCommit]) -> VersionIncrement: # Update the bump map to ensure major version doesn't increment. - # self.cz.bump_map = defaults.bump_map_major_version_zero - bump_map = ( - self.cz.bump_map_major_version_zero - if self.bump_settings["major_version_zero"] - else self.cz.bump_map - ) - bump_pattern = self.cz.bump_pattern + is_major_version_zero = self.bump_settings["major_version_zero"] - if not bump_map or not bump_pattern: - raise NoPatternMapError( - f"'{self.config.settings['name']}' rule does not support bump" - ) - return bump.find_increment(commits, regex=bump_pattern, increments_map=bump_map) + return VersionIncrement.get_highest_by_messages( + (commit.message for commit in commits), + lambda x: self.cz.bump_rule.extract_increment(x, is_major_version_zero), + ) def _validate_arguments(self, current_version: VersionProtocol) -> None: errors: list[str] = [] + increment = VersionIncrement.safe_cast(self.arguments["increment"]) if self.arguments["manual_version"]: for val, option in ( - (self.arguments["increment"], "--increment"), + (increment != VersionIncrement.NONE, "--increment"), (self.arguments["prerelease"], "--prerelease"), (self.arguments["devrelease"] is not None, "--devrelease"), (self.arguments["local_version"], "--local-version"), @@ -186,8 +179,9 @@ def _validate_arguments(self, current_version: VersionProtocol) -> None: def _resolve_increment_and_new_version( self, current_version: VersionProtocol, current_tag: git.GitTag | None - ) -> tuple[Increment | None, VersionProtocol]: - increment = self.arguments["increment"] + ) -> tuple[VersionIncrement, VersionProtocol]: + increment = VersionIncrement.safe_cast(self.arguments["increment"]) + prerelease = self.arguments["prerelease"] if manual_version := self.arguments["manual_version"]: try: return increment, self.scheme(manual_version) @@ -197,7 +191,7 @@ def _resolve_increment_and_new_version( f"Invalid manual version: '{manual_version}'" ) from exc - if increment is None: + if increment == VersionIncrement.NONE: commits = git.get_commits(current_tag.name if current_tag else None) # No commits, there is no need to create an empty tag. @@ -214,8 +208,8 @@ def _resolve_increment_and_new_version( # It may happen that there are commits, but they are not eligible # for an increment, this generates a problem when using prerelease (#281) if ( - self.arguments["prerelease"] - and increment is None + prerelease + and increment == VersionIncrement.NONE and not current_version.is_prerelease ): raise NoCommitsFoundError( @@ -225,12 +219,12 @@ def _resolve_increment_and_new_version( ) # we create an empty PATCH increment for empty tag - if increment is None and self.arguments["allow_no_commit"]: - increment = "PATCH" + if self.arguments["allow_no_commit"]: + increment = max(increment, VersionIncrement.PATCH) return increment, current_version.bump( increment, - prerelease=self.arguments["prerelease"], + prerelease=prerelease, prerelease_offset=self.bump_settings["prerelease_offset"], devrelease=self.arguments["devrelease"], is_local_version=self.arguments["local_version"], @@ -277,7 +271,10 @@ def __call__(self) -> None: new_tag_version = rules.normalize_tag(new_version) if next_version_to_stdout: - if increment is None and new_tag_version == current_tag_version: + if ( + increment == VersionIncrement.NONE + and new_tag_version == current_tag_version + ): raise NoneIncrementExit( "[NO_COMMITS_TO_BUMP]\n" "The commits found are not eligible to be bumped" @@ -290,7 +287,7 @@ def __call__(self) -> None: ) # Report found information information = f"{message}\ntag to create: {new_tag_version}\n" - if increment: + if increment != VersionIncrement.NONE: information += f"increment detected: {increment}\n" if self.changelog_to_stdout: @@ -301,7 +298,10 @@ def __call__(self) -> None: else: out.write(information) - if increment is None and new_tag_version == current_tag_version: + if ( + increment == VersionIncrement.NONE + and new_tag_version == current_tag_version + ): raise NoneIncrementExit( "[NO_COMMITS_TO_BUMP]\nThe commits found are not eligible to be bumped" ) @@ -366,7 +366,7 @@ def __call__(self) -> None: new_version=new_version.public, new_tag_version=new_tag_version, message=message, - increment=increment, + increment=(increment if increment != VersionIncrement.NONE else None), changelog_file_name=changelog_file_name, ) @@ -429,7 +429,7 @@ def __call__(self) -> None: current_version=new_version.public, current_tag_version=new_tag_version, message=message, - increment=increment, + increment=(increment if increment != VersionIncrement.NONE else None), changelog_file_name=changelog_file_name, ) diff --git a/commitizen/commands/version.py b/commitizen/commands/version.py index 2a4bcea88..7f384c38d 100644 --- a/commitizen/commands/version.py +++ b/commitizen/commands/version.py @@ -11,7 +11,7 @@ from commitizen.providers import get_provider from commitizen.tags import TagRules from commitizen.version_increment import VersionIncrement -from commitizen.version_schemes import Increment, get_version_scheme +from commitizen.version_schemes import get_version_scheme class VersionArgs(TypedDict, total=False): @@ -91,16 +91,7 @@ def __call__(self) -> None: return next_increment = VersionIncrement.from_value(next_increment_str) - increment: Increment | None - if next_increment == VersionIncrement.NONE: - increment = None - elif next_increment == VersionIncrement.PATCH: - increment = "PATCH" - elif next_increment == VersionIncrement.MINOR: - increment = "MINOR" - else: - increment = "MAJOR" - version = version.bump(increment=increment) + version = version.bump(increment=next_increment) if self.arguments.get("major"): out.write(version.major) diff --git a/commitizen/cz/base.py b/commitizen/cz/base.py index 5e7f2663c..f95e0eeb5 100644 --- a/commitizen/cz/base.py +++ b/commitizen/cz/base.py @@ -1,13 +1,14 @@ from __future__ import annotations from abc import ABCMeta, abstractmethod -from collections.abc import Iterable, Mapping +from functools import cached_property from typing import TYPE_CHECKING, Any, NamedTuple, Protocol from jinja2 import BaseLoader, PackageLoader from prompt_toolkit.styles import Style -from commitizen.exceptions import CommitMessageLengthExceededError +from commitizen.bump_rule import BumpRule, CustomBumpRule, VersionIncrement +from commitizen.exceptions import CommitMessageLengthExceededError, NoPatternMapError if TYPE_CHECKING: import re @@ -36,9 +37,13 @@ class ValidationResult(NamedTuple): class BaseCommitizen(metaclass=ABCMeta): + _bump_rule: BumpRule | None = None + + # TODO: decide if these should be removed bump_pattern: str | None = None bump_map: dict[str, str] | None = None bump_map_major_version_zero: dict[str, str] | None = None + default_style_config: list[tuple[str, str]] = [ ("qmark", "fg:#ff9d00 bold"), ("question", "bold"), @@ -95,6 +100,47 @@ def style(self) -> Style: ] ) + @cached_property + def bump_rule(self) -> BumpRule: + """Get the bump rule for version incrementing. + + This property returns a BumpRule instance that determines how version numbers + should be incremented based on commit messages. It first checks if a custom + bump rule was set via `_bump_rule`. If not, it falls back to creating a + CustomBumpRule using the class's bump pattern and maps. + + ``bump_pattern`` and ``bump_map`` are required. + ``bump_map_major_version_zero`` is optional, mirroring legacy behaviour: + plugins that don't define it will only fail if a bump is attempted with + ``major_version_zero = True``. + + Returns: + BumpRule: A rule instance that determines version increments + + Raises: + NoPatternMapError: If ``bump_pattern`` or ``bump_map`` are not defined. + """ + if self._bump_rule: + return self._bump_rule + + # Fallback to custom bump rule if no bump rule is provided + if not self.bump_pattern or not self.bump_map: + raise NoPatternMapError( + f"'{self.config.settings['name']}' rule does not support bump: " + f"{self.bump_pattern=}, {self.bump_map=}" + ) + + bump_map_major_version_zero = ( + VersionIncrement.safe_cast_dict(self.bump_map_major_version_zero) + if self.bump_map_major_version_zero + else None + ) + return CustomBumpRule( + self.bump_pattern, + VersionIncrement.safe_cast_dict(self.bump_map), + bump_map_major_version_zero, + ) + @abstractmethod def example(self) -> str: """Example of the commit message.""" diff --git a/commitizen/cz/conventional_commits/conventional_commits.py b/commitizen/cz/conventional_commits/conventional_commits.py index 31c329595..0e63c4f9a 100644 --- a/commitizen/cz/conventional_commits/conventional_commits.py +++ b/commitizen/cz/conventional_commits/conventional_commits.py @@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, TypedDict from commitizen import defaults +from commitizen.bump_rule import ConventionalCommitBumpRule from commitizen.cz.base import BaseCommitizen from commitizen.cz.utils import multiple_line_breaker, required_validator @@ -31,6 +32,8 @@ class ConventionalCommitsAnswers(TypedDict): class ConventionalCommitsCz(BaseCommitizen): + _bump_rule = ConventionalCommitBumpRule() + bump_pattern = defaults.BUMP_PATTERN bump_map = defaults.BUMP_MAP bump_map_major_version_zero = defaults.BUMP_MAP_MAJOR_VERSION_ZERO diff --git a/commitizen/defaults.py b/commitizen/defaults.py index 4865ccc18..5d00194d6 100644 --- a/commitizen/defaults.py +++ b/commitizen/defaults.py @@ -1,12 +1,14 @@ from __future__ import annotations import warnings -from collections import OrderedDict from collections.abc import Iterable, MutableMapping, Sequence from typing import TYPE_CHECKING, Any, TypedDict +from commitizen.bump_rule import VersionIncrement + if TYPE_CHECKING: import pathlib + from collections import OrderedDict from commitizen.question import CzQuestion @@ -117,31 +119,31 @@ class Settings(TypedDict, total=False): "message_length_limit": 0, # 0 for no limit } -MAJOR = "MAJOR" -MINOR = "MINOR" -PATCH = "PATCH" - CHANGELOG_FORMAT = "markdown" BUMP_PATTERN = r"^((BREAKING[\-\ ]CHANGE|\w+)(\(.+\))?!?):" -BUMP_MAP = OrderedDict( + +# TODO: remove this in v5 +BUMP_MAP = dict( ( - (r"^.+!$", MAJOR), - (r"^BREAKING[\-\ ]CHANGE", MAJOR), - (r"^feat", MINOR), - (r"^fix", PATCH), - (r"^refactor", PATCH), - (r"^perf", PATCH), + (r"^.+!$", str(VersionIncrement.MAJOR)), + (r"^BREAKING[\-\ ]CHANGE", str(VersionIncrement.MAJOR)), + (r"^feat", str(VersionIncrement.MINOR)), + (r"^fix", str(VersionIncrement.PATCH)), + (r"^refactor", str(VersionIncrement.PATCH)), + (r"^perf", str(VersionIncrement.PATCH)), ) ) -BUMP_MAP_MAJOR_VERSION_ZERO = OrderedDict( + +# TODO: remove this in v5 +BUMP_MAP_MAJOR_VERSION_ZERO = dict( ( - (r"^.+!$", MINOR), - (r"^BREAKING[\-\ ]CHANGE", MINOR), - (r"^feat", MINOR), - (r"^fix", PATCH), - (r"^refactor", PATCH), - (r"^perf", PATCH), + (r"^.+!$", str(VersionIncrement.MINOR)), + (r"^BREAKING[\-\ ]CHANGE", str(VersionIncrement.MINOR)), + (r"^feat", str(VersionIncrement.MINOR)), + (r"^fix", str(VersionIncrement.PATCH)), + (r"^refactor", str(VersionIncrement.PATCH)), + (r"^perf", str(VersionIncrement.PATCH)), ) ) CHANGE_TYPE_ORDER = ["BREAKING CHANGE", "Feat", "Fix", "Refactor", "Perf"] @@ -185,6 +187,9 @@ def __getattr__(name: str) -> Any: "encoding": (ENCODING, "ENCODING"), "name": (DEFAULT_SETTINGS["name"], "DEFAULT_SETTINGS['name']"), "Questions": (Questions, "Iterable[CzQuestion]"), + "MAJOR": (str(VersionIncrement.MAJOR), "VersionIncrement.MAJOR"), + "MINOR": (str(VersionIncrement.MINOR), "VersionIncrement.MINOR"), + "PATCH": (str(VersionIncrement.PATCH), "VersionIncrement.PATCH"), } if name in deprecated_vars: value, replacement = deprecated_vars[name] diff --git a/commitizen/version_increment.py b/commitizen/version_increment.py index 9320fe8f9..7467ee294 100644 --- a/commitizen/version_increment.py +++ b/commitizen/version_increment.py @@ -1,6 +1,10 @@ from __future__ import annotations from enum import IntEnum +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from collections.abc import Callable, Iterable, Mapping class VersionIncrement(IntEnum): @@ -31,3 +35,54 @@ def from_value(cls, value: object) -> VersionIncrement: return cls[value] except KeyError: return VersionIncrement.NONE + + # Alias kept for the new ``BumpRule`` / ``CustomBumpRule`` API in + # ``commitizen.bump_rule``. The two names do the same thing; ``safe_cast`` + # is the wording used in the bump rule plumbing while ``from_value`` + # is the wording used in the version command. + safe_cast = from_value + + @staticmethod + def safe_cast_dict(d: Mapping[str, object]) -> dict[str, VersionIncrement]: + """Cast every value in ``d`` to a :class:`VersionIncrement`, dropping entries + whose value is not one of the recognised names (``"MAJOR"``, ``"MINOR"``, + ``"PATCH"``, ``"NONE"``). + + Entries with unrecognised string values (e.g. typos like ``"MNIOR"``) are + silently dropped. Values that successfully cast to ``VersionIncrement.NONE`` + are also dropped because they don't contribute to a bump. + + Iteration order of the input mapping is preserved. + """ + return { + k: v + for k, v in ((k, VersionIncrement.safe_cast(v)) for k, v in d.items()) + if v is not VersionIncrement.NONE + } + + @staticmethod + def get_highest_by_messages( + commit_messages: Iterable[str], + extract_increment: Callable[[str], VersionIncrement], + ) -> VersionIncrement: + """Find the highest version increment from a list of messages. + + This function processes a list of messages and determines the highest version + increment needed based on the commit messages. It splits multi-line commit messages + and evaluates each line using the provided extract_increment callable. + + Args: + commit_messages: A list of messages to analyze. + extract_increment: A callable that takes a commit message string and returns an + VersionIncrement value (MAJOR, MINOR, PATCH) or NONE if no increment is needed. + + Returns: + The highest version increment needed (MAJOR, MINOR, PATCH) or NONE if no + increment is needed. The order of precedence is MAJOR > MINOR > PATCH. + """ + increments = ( + extract_increment(line) + for message in commit_messages + for line in message.split("\n") + ) + return max(increments, default=VersionIncrement.NONE) diff --git a/commitizen/version_schemes.py b/commitizen/version_schemes.py index 14a55d655..3e09b5629 100644 --- a/commitizen/version_schemes.py +++ b/commitizen/version_schemes.py @@ -18,12 +18,14 @@ from packaging.version import InvalidVersion # noqa: F401 (expose the common exception) from packaging.version import Version as _BaseVersion -from commitizen.defaults import MAJOR, MINOR, PATCH, Settings +from commitizen.bump_rule import VersionIncrement from commitizen.exceptions import VersionSchemeUnknown if TYPE_CHECKING: import sys + from commitizen.defaults import Settings + # Self is Python 3.11+ but backported in typing-extensions if sys.version_info < (3, 11): from typing_extensions import Self @@ -31,8 +33,9 @@ from typing import Self -Increment: TypeAlias = Literal["MAJOR", "MINOR", "PATCH"] # TODO: deprecate Prerelease: TypeAlias = Literal["alpha", "beta", "rc"] + + _DEFAULT_VERSION_PARSER = re.compile( r"v?(?P([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.]+)?(\w+)?)" ) @@ -120,7 +123,7 @@ def __ne__(self, other: object) -> bool: def bump( self, - increment: Increment | None, + increment: VersionIncrement, prerelease: Prerelease | None = None, prerelease_offset: int = 0, devrelease: int | None = None, @@ -212,26 +215,34 @@ def generate_build_metadata(self, build_metadata: str | None) -> str: return f"+{build_metadata}" - def increment_base(self, increment: Increment | None = None) -> str: - prev_release = list(self.release) - increments = [MAJOR, MINOR, PATCH] - base = dict(zip_longest(increments, prev_release, fillvalue=0)) + def increment_base(self, increment: VersionIncrement) -> str: + base = dict( + zip_longest( + ( + VersionIncrement.MAJOR, + VersionIncrement.MINOR, + VersionIncrement.PATCH, + ), + self.release, + fillvalue=0, + ) + ) - if increment == MAJOR: - base[MAJOR] += 1 - base[MINOR] = 0 - base[PATCH] = 0 - elif increment == MINOR: - base[MINOR] += 1 - base[PATCH] = 0 - elif increment == PATCH: - base[PATCH] += 1 + if increment == VersionIncrement.MAJOR: + base[VersionIncrement.MAJOR] += 1 + base[VersionIncrement.MINOR] = 0 + base[VersionIncrement.PATCH] = 0 + elif increment == VersionIncrement.MINOR: + base[VersionIncrement.MINOR] += 1 + base[VersionIncrement.PATCH] = 0 + elif increment == VersionIncrement.PATCH: + base[VersionIncrement.PATCH] += 1 - return f"{base[MAJOR]}.{base[MINOR]}.{base[PATCH]}" + return f"{base[VersionIncrement.MAJOR]}.{base[VersionIncrement.MINOR]}.{base[VersionIncrement.PATCH]}" def bump( self, - increment: Increment | None, + increment: VersionIncrement, prerelease: Prerelease | None = None, prerelease_offset: int = 0, devrelease: int | None = None, @@ -273,13 +284,16 @@ def bump( ) # type: ignore[return-value] def _get_increment_base( - self, increment: Increment | None, exact_increment: bool + self, increment: VersionIncrement, exact_increment: bool ) -> str: if ( not self.is_prerelease or exact_increment - or (increment == MINOR and self.micro != 0) - or (increment == MAJOR and (self.minor != 0 or self.micro != 0)) + or (increment == VersionIncrement.MINOR and self.micro != 0) + or ( + increment == VersionIncrement.MAJOR + and (self.minor != 0 or self.micro != 0) + ) ): return self.increment_base(increment) return f"{self.major}.{self.minor}.{self.micro}" diff --git a/docs/commands/bump.md b/docs/commands/bump.md index 84666cbc6..d8109da14 100644 --- a/docs/commands/bump.md +++ b/docs/commands/bump.md @@ -536,6 +536,98 @@ Commitizen supports the [PEP 440][pep440] version format, which includes several > **Note**: `post` releases (e.g., `1.0.0.post1`) are not currently supported. +## Custom bump + +You can create custom bump rules to define how version numbers should be incremented based on your commit messages. This is done by configuring three main components: + +### Bump Pattern + +The `bump_pattern` is a regex pattern string used to match commit messages. It defines the structure of your commit messages and captures named groups for different types of changes. The captured groups will be used as keys in the bump map. + +Example: +```python +# Simple pattern matching major/minor/patch types +r"^((?Pmajor)|(?Pminor)|(?Ppatch))(?P\(.+\))?(?P!)?:" + +# Conventional commits style pattern +r"^((?Pfeat)|(?Pfix|perf|refactor)|(?PBREAKING[\-\ ]CHANGE))(?P\(.+\))?(?P!)?:" +``` + +### Bump Map + +The `bump_map` defines how different commit types map to version increments. The keys in this dictionary must match the named capture groups from your pattern. The values are the version increment types: + +- `"MAJOR"` +- `"MINOR"` +- `"PATCH"` + +Example for conventional commits: +```python +{ + # Breaking changes (either by type or bang) + "breaking": "MAJOR", # When type is "BREAKING CHANGE" + "bang": "MAJOR", # When commit ends with ! (e.g., feat!: new feature) + # New features + "minor": "MINOR", + # Bug fixes and improvements + "patch": "PATCH", +} +``` + +Or using regex patterns: +```python +{ + r"^.+!$": "MAJOR", + r"^BREAKING[\-\ ]CHANGE": "MAJOR", + r"^feat": "MINOR", + r"^fix": "PATCH", + r"^refactor": "PATCH", + r"^perf": "PATCH", +} +``` + +### Major Version Zero Map + +The `bump_map_major_version_zero` allows you to define different versioning behavior when your project is in initial development (major version is 0). This is useful for following semantic versioning principles where breaking changes in 0.x.x versions don't require a major version bump. + +Example for conventional commits during initial development: +```python +{ + # Breaking changes (either by type or bang) + "breaking": "MINOR", # When type is "BREAKING CHANGE" + "bang": "MINOR", # When commit ends with ! (e.g., feat!: new feature) + # New features + "minor": "MINOR", + # Bug fixes and improvements + "patch": "PATCH", +} +``` + +Or with regex patterns: +```python +{ + r"^.+!$": "MINOR", + r"^BREAKING[\-\ ]CHANGE": "MINOR", + r"^feat": "MINOR", + r"^fix": "PATCH", + r"^refactor": "PATCH", + r"^perf": "PATCH", +} +``` + +This configuration will handle commit messages like: + +- `BREAKING CHANGE: remove deprecated API` → MAJOR (or MINOR in major version zero) +- `feat!: add new API` → MAJOR (or MINOR in major version zero) +- `feat: add new feature` → MINOR +- `fix: fix bug` → PATCH +- `perf: improve performance` → PATCH +- `refactor: restructure code` → PATCH + +For more details on implementing custom bump rules, see the [customization guide](../customization.md). + + + [pep440]: https://www.python.org/dev/peps/pep-0440/ [semver]: https://semver.org/ [version_files]: ../config/bump.md#version_files diff --git a/tests/commands/test_bump_command.py b/tests/commands/test_bump_command.py index 1e5a162ba..11bd19dde 100644 --- a/tests/commands/test_bump_command.py +++ b/tests/commands/test_bump_command.py @@ -11,6 +11,7 @@ import commitizen.commands.bump as bump from commitizen import cmd, defaults, git, hooks +from commitizen.bump_rule import VersionIncrement from commitizen.config.base_config import BaseConfig from commitizen.exceptions import ( BumpTagFailedError, @@ -836,7 +837,7 @@ def test_bump_with_pre_bump_hooks( new_version="0.2.0", new_tag_version="0.2.0", message="bump: version 0.1.0 → 0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, changelog_file_name=None, ), call( @@ -848,7 +849,7 @@ def test_bump_with_pre_bump_hooks( current_version="0.2.0", current_tag_version="0.2.0", message="bump: version 0.1.0 → 0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, changelog_file_name=None, ), ] diff --git a/tests/test_bump_find_increment.py b/tests/test_bump_find_increment.py deleted file mode 100644 index 8209278ed..000000000 --- a/tests/test_bump_find_increment.py +++ /dev/null @@ -1,124 +0,0 @@ -""" -CC: Conventional commits -SVE: Semantic version at the end -""" - -import pytest - -from commitizen import bump -from commitizen.cz.conventional_commits import ConventionalCommitsCz -from commitizen.git import GitCommit - -NONE_INCREMENT_CC = [ - "docs(README): motivation", - "ci: added travis", - "performance. Remove or disable the reimplemented linters", - "refactor that how this line starts", -] - -PATCH_INCREMENTS_CC = [ - "fix(setup.py): future is now required for every python version", - "docs(README): motivation", -] - -MINOR_INCREMENTS_CC = [ - "feat(cli): added version", - "docs(README): motivation", - "fix(setup.py): future is now required for every python version", - "perf: app is much faster", - "refactor: app is much faster", -] - -MAJOR_INCREMENTS_BREAKING_CHANGE_CC = [ - "feat(cli): added version", - "docs(README): motivation", - "BREAKING CHANGE: `extends` key in config file is now used for extending other config files", - "fix(setup.py): future is now required for every python version", -] - -MAJOR_INCREMENTS_BREAKING_CHANGE_ALT_CC = [ - "feat(cli): added version", - "docs(README): motivation", - "BREAKING-CHANGE: `extends` key in config file is now used for extending other config files", - "fix(setup.py): future is now required for every python version", -] - -MAJOR_INCREMENTS_EXCLAMATION_CC = [ - "feat(cli)!: added version", - "docs(README): motivation", - "fix(setup.py): future is now required for every python version", -] - -MAJOR_INCREMENTS_EXCLAMATION_CC_SAMPLE_2 = [ - "feat(pipeline)!: some text with breaking change" -] - -MAJOR_INCREMENTS_EXCLAMATION_OTHER_TYPE_CC = [ - "chore!: drop support for Python 3.9", - "docs(README): motivation", - "fix(setup.py): future is now required for every python version", -] - -MAJOR_INCREMENTS_EXCLAMATION_OTHER_TYPE_WITH_SCOPE_CC = [ - "chore(deps)!: drop support for Python 3.9", - "docs(README): motivation", - "fix(setup.py): future is now required for every python version", -] - -PATCH_INCREMENTS_SVE = ["readme motivation PATCH", "fix setup.py PATCH"] - -MINOR_INCREMENTS_SVE = [ - "readme motivation PATCH", - "fix setup.py PATCH", - "added version to cli MINOR", -] - -MAJOR_INCREMENTS_SVE = [ - "readme motivation PATCH", - "fix setup.py PATCH", - "added version to cli MINOR", - "extends key is used for other config files MAJOR", -] - -semantic_version_pattern = r"(MAJOR|MINOR|PATCH)" -semantic_version_map = {"MAJOR": "MAJOR", "MINOR": "MINOR", "PATCH": "PATCH"} - - -@pytest.mark.parametrize( - ("messages", "expected_type"), - [ - (PATCH_INCREMENTS_CC, "PATCH"), - (MINOR_INCREMENTS_CC, "MINOR"), - (MAJOR_INCREMENTS_BREAKING_CHANGE_CC, "MAJOR"), - (MAJOR_INCREMENTS_BREAKING_CHANGE_ALT_CC, "MAJOR"), - (MAJOR_INCREMENTS_EXCLAMATION_OTHER_TYPE_CC, "MAJOR"), - (MAJOR_INCREMENTS_EXCLAMATION_OTHER_TYPE_WITH_SCOPE_CC, "MAJOR"), - (MAJOR_INCREMENTS_EXCLAMATION_CC, "MAJOR"), - (MAJOR_INCREMENTS_EXCLAMATION_CC_SAMPLE_2, "MAJOR"), - (NONE_INCREMENT_CC, None), - ], -) -def test_find_increment(messages, expected_type): - commits = [GitCommit(rev="test", title=message) for message in messages] - increment_type = bump.find_increment( - commits, - regex=ConventionalCommitsCz.bump_pattern, - increments_map=ConventionalCommitsCz.bump_map, - ) - assert increment_type == expected_type - - -@pytest.mark.parametrize( - ("messages", "expected_type"), - [ - (PATCH_INCREMENTS_SVE, "PATCH"), - (MINOR_INCREMENTS_SVE, "MINOR"), - (MAJOR_INCREMENTS_SVE, "MAJOR"), - ], -) -def test_find_increment_sve(messages, expected_type): - commits = [GitCommit(rev="test", title=message) for message in messages] - increment_type = bump.find_increment( - commits, regex=semantic_version_pattern, increments_map=semantic_version_map - ) - assert increment_type == expected_type diff --git a/tests/test_bump_rule.py b/tests/test_bump_rule.py new file mode 100644 index 000000000..9c81a2893 --- /dev/null +++ b/tests/test_bump_rule.py @@ -0,0 +1,786 @@ +import pytest + +from commitizen.bump_rule import ( + ConventionalCommitBumpRule, + CustomBumpRule, + VersionIncrement, +) +from commitizen.defaults import ( + BUMP_MAP, + BUMP_MAP_MAJOR_VERSION_ZERO, + BUMP_PATTERN, +) +from commitizen.exceptions import NoPatternMapError + + +@pytest.fixture +def bump_rule(): + return ConventionalCommitBumpRule() + + +class TestConventionalCommitBumpRule: + def test_feat_commit(self, bump_rule): + assert ( + bump_rule.extract_increment("feat: add new feature", False) + == VersionIncrement.MINOR + ) + assert ( + bump_rule.extract_increment("feat: add new feature", True) + == VersionIncrement.MINOR + ) + + def test_fix_commit(self, bump_rule): + assert ( + bump_rule.extract_increment("fix: fix bug", False) == VersionIncrement.PATCH + ) + assert ( + bump_rule.extract_increment("fix: fix bug", True) == VersionIncrement.PATCH + ) + + def test_perf_commit(self, bump_rule): + assert ( + bump_rule.extract_increment("perf: improve performance", False) + == VersionIncrement.PATCH + ) + assert ( + bump_rule.extract_increment("perf: improve performance", True) + == VersionIncrement.PATCH + ) + + def test_refactor_commit(self, bump_rule): + assert ( + bump_rule.extract_increment("refactor: restructure code", False) + == VersionIncrement.PATCH + ) + assert ( + bump_rule.extract_increment("refactor: restructure code", True) + == VersionIncrement.PATCH + ) + + def test_breaking_change_with_bang(self, bump_rule): + assert ( + bump_rule.extract_increment("feat!: breaking change", False) + == VersionIncrement.MAJOR + ) + assert ( + bump_rule.extract_increment("feat!: breaking change", True) + == VersionIncrement.MINOR + ) + + def test_breaking_change_type(self, bump_rule): + assert ( + bump_rule.extract_increment("BREAKING CHANGE: major change", False) + == VersionIncrement.MAJOR + ) + assert ( + bump_rule.extract_increment("BREAKING CHANGE: major change", True) + == VersionIncrement.MINOR + ) + + def test_commit_with_scope(self, bump_rule): + assert ( + bump_rule.extract_increment("feat(api): add new endpoint", False) + == VersionIncrement.MINOR + ) + assert ( + bump_rule.extract_increment("fix(ui): fix button alignment", False) + == VersionIncrement.PATCH + ) + + def test_commit_with_complex_scopes(self, bump_rule): + # Test with multiple word scopes + assert ( + bump_rule.extract_increment("feat(user_management): add user roles", False) + == VersionIncrement.MINOR + ) + assert ( + bump_rule.extract_increment( + "fix(database_connection): handle timeout", False + ) + == VersionIncrement.PATCH + ) + + # Test with nested scopes + assert ( + bump_rule.extract_increment("feat(api/auth): implement OAuth", False) + == VersionIncrement.MINOR + ) + assert ( + bump_rule.extract_increment("fix(ui/components): fix dropdown", False) + == VersionIncrement.PATCH + ) + + # Test with breaking changes and scopes + assert ( + bump_rule.extract_increment( + "feat(api)!: remove deprecated endpoints", False + ) + == VersionIncrement.MAJOR + ) + assert ( + bump_rule.extract_increment("feat(api)!: remove deprecated endpoints", True) + == VersionIncrement.MINOR + ) + + # Test with BREAKING CHANGE and scopes + assert ( + bump_rule.extract_increment( + "BREAKING CHANGE(api): remove deprecated endpoints", False + ) + == VersionIncrement.MAJOR + ) + assert ( + bump_rule.extract_increment( + "BREAKING CHANGE(api): remove deprecated endpoints", True + ) + == VersionIncrement.MINOR + ) + + def test_invalid_commit_message(self, bump_rule): + assert ( + bump_rule.extract_increment("invalid commit message", False) + == VersionIncrement.NONE + ) + assert bump_rule.extract_increment("", False) == VersionIncrement.NONE + assert bump_rule.extract_increment("feat", False) == VersionIncrement.NONE + + def test_other_commit_types(self, bump_rule): + # These commit types should not trigger any version bump + assert ( + bump_rule.extract_increment("docs: update documentation", False) + == VersionIncrement.NONE + ) + assert ( + bump_rule.extract_increment("style: format code", False) + == VersionIncrement.NONE + ) + assert ( + bump_rule.extract_increment("test: add unit tests", False) + == VersionIncrement.NONE + ) + assert ( + bump_rule.extract_increment("build: update build config", False) + == VersionIncrement.NONE + ) + assert ( + bump_rule.extract_increment("ci: update CI pipeline", False) + == VersionIncrement.NONE + ) + + def test_breaking_change_with_refactor(self, bump_rule): + """Test breaking changes with refactor type commit messages.""" + # Breaking change with refactor type + assert ( + bump_rule.extract_increment("refactor!: drop support for Python 2.7", False) + == VersionIncrement.MAJOR + ) + assert ( + bump_rule.extract_increment("refactor!: drop support for Python 2.7", True) + == VersionIncrement.MINOR + ) + + # Breaking change with refactor type and scope + assert ( + bump_rule.extract_increment( + "refactor(api)!: remove deprecated endpoints", False + ) + == VersionIncrement.MAJOR + ) + assert ( + bump_rule.extract_increment( + "refactor(api)!: remove deprecated endpoints", True + ) + == VersionIncrement.MINOR + ) + + # Regular refactor (should be VersionIncrement.PATCH) + assert ( + bump_rule.extract_increment("refactor: improve code structure", False) + == VersionIncrement.PATCH + ) + assert ( + bump_rule.extract_increment("refactor: improve code structure", True) + == VersionIncrement.PATCH + ) + + +class TestFindIncrementByCallable: + @pytest.fixture + def extract_increment(self, bump_rule): + return lambda x: bump_rule.extract_increment(x, False) + + def test_single_commit(self, extract_increment): + commit_messages = ["feat: add new feature"] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.MINOR + ) + + def test_multiple_commits(self, extract_increment): + commit_messages = [ + "feat: new feature", + "fix: bug fix", + "docs: update readme", + ] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.MINOR + ) + + def test_breaking_change(self, extract_increment): + commit_messages = [ + "feat: new feature", + "feat!: breaking change", + ] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.MAJOR + ) + + def test_multi_line_commit(self, extract_increment): + commit_messages = [ + "feat: new feature\n\nBREAKING CHANGE: major change", + ] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.MAJOR + ) + + def test_no_increment_needed(self, extract_increment): + commit_messages = [ + "docs: update documentation", + "style: format code", + ] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.NONE + ) + + def test_empty_commits(self, extract_increment): + commit_messages = [] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.NONE + ) + + def test_major_version_zero(self): + bump_rule = ConventionalCommitBumpRule() + + commit_messages = [ + "feat!: breaking change", + "BREAKING CHANGE: major change", + ] + assert ( + VersionIncrement.get_highest_by_messages( + commit_messages, lambda x: bump_rule.extract_increment(x, True) + ) + == VersionIncrement.MINOR + ) + + def test_mixed_commit_types(self, extract_increment): + commit_messages = [ + "feat: new feature", + "fix: bug fix", + "perf: improve performance", + "refactor: restructure code", + ] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.MINOR + ) + + def test_commit_with_scope(self, extract_increment): + commit_messages = [ + "feat(api): add new endpoint", + "fix(ui): fix button alignment", + ] + assert ( + VersionIncrement.get_highest_by_messages(commit_messages, extract_increment) + == VersionIncrement.MINOR + ) + + +class TestCustomBumpRule: + @pytest.fixture + def bump_pattern(self): + return r"^.*?\[(.*?)\].*$" + + @pytest.fixture + def bump_map(self): + return { + "MAJOR": VersionIncrement.MAJOR, + "MINOR": VersionIncrement.MINOR, + "PATCH": VersionIncrement.PATCH, + } + + @pytest.fixture + def bump_map_major_version_zero(self): + return { + "MAJOR": VersionIncrement.MINOR, # VersionIncrement.MAJOR becomes VersionIncrement.MINOR in version zero + "MINOR": VersionIncrement.MINOR, + "PATCH": VersionIncrement.PATCH, + } + + @pytest.fixture + def custom_bump_rule(self, bump_pattern, bump_map, bump_map_major_version_zero): + return CustomBumpRule(bump_pattern, bump_map, bump_map_major_version_zero) + + def test_major_version(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat: add new feature [MAJOR]", False) + == VersionIncrement.MAJOR + ) + assert ( + custom_bump_rule.extract_increment("fix: bug fix [MAJOR]", False) + == VersionIncrement.MAJOR + ) + + def test_minor_version(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat: add new feature [MINOR]", False) + == VersionIncrement.MINOR + ) + assert ( + custom_bump_rule.extract_increment("fix: bug fix [MINOR]", False) + == VersionIncrement.MINOR + ) + + def test_patch_version(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat: add new feature [PATCH]", False) + == VersionIncrement.PATCH + ) + assert ( + custom_bump_rule.extract_increment("fix: bug fix [PATCH]", False) + == VersionIncrement.PATCH + ) + + def test_major_version_zero(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat: add new feature [MAJOR]", True) + == VersionIncrement.MINOR + ) + assert ( + custom_bump_rule.extract_increment("fix: bug fix [MAJOR]", True) + == VersionIncrement.MINOR + ) + + def test_no_match(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat: add new feature", False) + == VersionIncrement.NONE + ) + assert ( + custom_bump_rule.extract_increment("fix: bug fix", False) + == VersionIncrement.NONE + ) + + def test_invalid_pattern(self, bump_map, bump_map_major_version_zero): + with pytest.raises(NoPatternMapError): + CustomBumpRule("", bump_map, bump_map_major_version_zero) + + def test_invalid_bump_map(self, bump_pattern): + with pytest.raises(NoPatternMapError): + CustomBumpRule(bump_pattern, {}, {}) + + def test_invalid_bump_map_major_version_zero(self, bump_pattern, bump_map): + # ``bump_map_major_version_zero`` is optional at construction time. + # An empty map is allowed; it only triggers ``NoPatternMapError`` when + # ``extract_increment`` is called with ``major_version_zero=True``. + rule = CustomBumpRule(bump_pattern, bump_map, {}) + # Non-zero mode keeps working with the regular bump_map. + assert ( + rule.extract_increment("feat: x [MAJOR]", False) == VersionIncrement.MAJOR + ) + # Zero mode raises because the MVZ map is empty. + with pytest.raises(NoPatternMapError): + rule.extract_increment("feat: x [MAJOR]", True) + + def test_all_invalid(self): + with pytest.raises(NoPatternMapError): + CustomBumpRule("", {}, {}) + + def test_none_values(self): + with pytest.raises(NoPatternMapError): + CustomBumpRule(None, {}, {}) + + def test_empty_pattern_with_valid_maps(self, bump_map, bump_map_major_version_zero): + with pytest.raises(NoPatternMapError): + CustomBumpRule("", bump_map, bump_map_major_version_zero) + + def test_empty_maps_with_valid_pattern(self, bump_pattern): + with pytest.raises(NoPatternMapError): + CustomBumpRule(bump_pattern, {}, {}) + + def test_complex_pattern(self): + pattern = r"^.*?\[(.*?)\].*?\[(.*?)\].*$" + bump_map = { + "MAJOR": VersionIncrement.MAJOR, + "MINOR": VersionIncrement.MINOR, + "PATCH": VersionIncrement.PATCH, + } + rule = CustomBumpRule(pattern, bump_map, bump_map) + + assert ( + rule.extract_increment( + "feat: add new feature [MAJOR] [MINOR]", + False, + ) + == VersionIncrement.MAJOR + ) + assert ( + rule.extract_increment("fix: bug fix [MINOR] [PATCH]", False) + == VersionIncrement.MINOR + ) + + def test_with_find_increment_by_callable(self, custom_bump_rule): + commit_messages = [ + "feat: add new feature [MAJOR]", + "fix: bug fix [PATCH]", + "docs: update readme [MINOR]", + ] + assert ( + VersionIncrement.get_highest_by_messages( + commit_messages, lambda x: custom_bump_rule.extract_increment(x, False) + ) + == VersionIncrement.MAJOR + ) + + def test_flexible_bump_map(self, custom_bump_rule): + """Test that _find_highest_increment is used correctly in bump map processing.""" + # Test with multiple matching patterns + pattern = r"^((?Pmajor)|(?Pminor)|(?Ppatch))(?P\(.+\))?(?P!)?:" + bump_map = { + "major": VersionIncrement.MAJOR, + "bang": VersionIncrement.MAJOR, + "minor": VersionIncrement.MINOR, + "patch": VersionIncrement.PATCH, + } + bump_map_major_version_zero = { + "major": VersionIncrement.MINOR, + "bang": VersionIncrement.MINOR, + "minor": VersionIncrement.MINOR, + "patch": VersionIncrement.PATCH, + } + rule = CustomBumpRule(pattern, bump_map, bump_map_major_version_zero) + + # Test with multiple version tags + assert ( + rule.extract_increment("major!: drop support for Python 2.7", False) + == VersionIncrement.MAJOR + ) + assert ( + rule.extract_increment("major!: drop support for Python 2.7", True) + == VersionIncrement.MINOR + ) + assert ( + rule.extract_increment("major: drop support for Python 2.7", False) + == VersionIncrement.MAJOR + ) + assert ( + rule.extract_increment("major: drop support for Python 2.7", True) + == VersionIncrement.MINOR + ) + assert ( + rule.extract_increment("patch!: drop support for Python 2.7", False) + == VersionIncrement.MAJOR + ) + assert ( + rule.extract_increment("patch!: drop support for Python 2.7", True) + == VersionIncrement.MINOR + ) + assert ( + rule.extract_increment("patch: drop support for Python 2.7", False) + == VersionIncrement.PATCH + ) + assert ( + rule.extract_increment("patch: drop support for Python 2.7", True) + == VersionIncrement.PATCH + ) + assert ( + rule.extract_increment("minor: add new feature", False) + == VersionIncrement.MINOR + ) + assert ( + rule.extract_increment("minor: add new feature", True) + == VersionIncrement.MINOR + ) + assert rule.extract_increment("patch: fix bug", False) == VersionIncrement.PATCH + assert rule.extract_increment("patch: fix bug", True) == VersionIncrement.PATCH + + +class TestCustomBumpRuleWithDefault: + @pytest.fixture + def custom_bump_rule(self): + return CustomBumpRule( + BUMP_PATTERN, + VersionIncrement.safe_cast_dict(BUMP_MAP), + VersionIncrement.safe_cast_dict(BUMP_MAP_MAJOR_VERSION_ZERO), + ) + + def test_breaking_change_with_bang(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat!: breaking change", False) + == VersionIncrement.MAJOR + ) + assert ( + custom_bump_rule.extract_increment("fix!: breaking change", False) + == VersionIncrement.MAJOR + ) + assert ( + custom_bump_rule.extract_increment("feat!: breaking change", True) + == VersionIncrement.MINOR + ) + assert ( + custom_bump_rule.extract_increment("fix!: breaking change", True) + == VersionIncrement.MINOR + ) + + def test_breaking_change_type(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("BREAKING CHANGE: major change", False) + == VersionIncrement.MAJOR + ) + assert ( + custom_bump_rule.extract_increment("BREAKING-CHANGE: major change", False) + == VersionIncrement.MAJOR + ) + assert ( + custom_bump_rule.extract_increment("BREAKING CHANGE: major change", True) + == VersionIncrement.MINOR + ) + assert ( + custom_bump_rule.extract_increment("BREAKING-CHANGE: major change", True) + == VersionIncrement.MINOR + ) + + def test_feat_commit(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat: add new feature", False) + == VersionIncrement.MINOR + ) + assert ( + custom_bump_rule.extract_increment("feat: add new feature", True) + == VersionIncrement.MINOR + ) + + def test_fix_commit(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("fix: fix bug", False) + == VersionIncrement.PATCH + ) + assert ( + custom_bump_rule.extract_increment("fix: fix bug", True) + == VersionIncrement.PATCH + ) + + def test_refactor_commit(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("refactor: restructure code", False) + == VersionIncrement.PATCH + ) + assert ( + custom_bump_rule.extract_increment("refactor: restructure code", True) + == VersionIncrement.PATCH + ) + + def test_perf_commit(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("perf: improve performance", False) + == VersionIncrement.PATCH + ) + assert ( + custom_bump_rule.extract_increment("perf: improve performance", True) + == VersionIncrement.PATCH + ) + + def test_commit_with_scope(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("feat(api): add new endpoint", False) + == VersionIncrement.MINOR + ) + assert ( + custom_bump_rule.extract_increment("fix(ui): fix button alignment", False) + == VersionIncrement.PATCH + ) + assert ( + custom_bump_rule.extract_increment("refactor(core): restructure", False) + == VersionIncrement.PATCH + ) + + def test_no_match(self, custom_bump_rule): + assert ( + custom_bump_rule.extract_increment("docs: update documentation", False) + == VersionIncrement.NONE + ) + assert ( + custom_bump_rule.extract_increment("style: format code", False) + == VersionIncrement.NONE + ) + assert ( + custom_bump_rule.extract_increment("test: add unit tests", False) + == VersionIncrement.NONE + ) + assert ( + custom_bump_rule.extract_increment("build: update build config", False) + == VersionIncrement.NONE + ) + assert ( + custom_bump_rule.extract_increment("ci: update CI pipeline", False) + == VersionIncrement.NONE + ) + + def test_with_find_increment_by_callable(self, custom_bump_rule): + commit_messages = [ + "feat!: breaking change", + "fix: bug fix", + "perf: improve performance", + ] + assert ( + VersionIncrement.get_highest_by_messages( + commit_messages, lambda x: custom_bump_rule.extract_increment(x, False) + ) + == VersionIncrement.MAJOR + ) + + +class TestCustomBumpRuleWithoutMajorVersionZeroMap: + """Backward-compat: legacy plugins may only define ``bump_pattern`` and + ``bump_map`` and never set ``bump_map_major_version_zero``. The rule must + still construct cleanly and only fail when ``major_version_zero`` is True. + Mirrors master's lazy validation in ``commands/bump.py::_find_increment``. + """ + + @pytest.fixture + def rule(self): + return CustomBumpRule( + BUMP_PATTERN, + VersionIncrement.safe_cast_dict(BUMP_MAP), + # bump_map_major_version_zero intentionally omitted + ) + + def test_construct_without_mvz_map(self, rule): + assert rule.bump_map_major_version_zero is None + + def test_extract_with_major_version_zero_false_works(self, rule): + assert ( + rule.extract_increment("feat: add new feature", False) + == VersionIncrement.MINOR + ) + assert rule.extract_increment("fix: bug fix", False) == VersionIncrement.PATCH + + def test_extract_with_major_version_zero_true_raises(self, rule): + with pytest.raises(NoPatternMapError): + rule.extract_increment("feat: add new feature", True) + + +class TestCustomBumpRuleFallbackOrder: + """The legacy fallback path returns the FIRST matching pattern. Iteration + order of the bump_map matters and must be preserved. + """ + + def test_first_matching_pattern_wins(self): + # Both r"^.+!$" and r"^feat" match "feat!"; the first one in insertion + # order should win. With this ordering the result is MAJOR. + rule_major_first = CustomBumpRule( + r"^((BREAKING[\-\ ]CHANGE|\w+)(\(.+\))?!?):", + { + r"^.+!$": VersionIncrement.MAJOR, + r"^feat": VersionIncrement.MINOR, + }, + ) + assert ( + rule_major_first.extract_increment("feat!: breaking", False) + == VersionIncrement.MAJOR + ) + + # Reversed insertion order: now MINOR wins because r"^feat" is tried first. + rule_minor_first = CustomBumpRule( + r"^((BREAKING[\-\ ]CHANGE|\w+)(\(.+\))?!?):", + { + r"^feat": VersionIncrement.MINOR, + r"^.+!$": VersionIncrement.MAJOR, + }, + ) + assert ( + rule_minor_first.extract_increment("feat!: breaking", False) + == VersionIncrement.MINOR + ) + + +class TestBaseCommitizenBumpRuleProperty: + """Verifies the cached_property in ``commitizen.cz.base.BaseCommitizen`` + that lazily resolves a ``BumpRule`` from class-level ``bump_pattern`` / + ``bump_map`` / ``bump_map_major_version_zero`` attributes — used by + third-party plugins. + """ + + @pytest.fixture + def config(self): + from commitizen.config import BaseConfig + + c = BaseConfig() + c.settings.update({"name": "cz_legacy_plugin"}) + return c + + def test_plugin_with_only_bump_pattern_and_bump_map_works(self, config): + """Master-compatible: a plugin that omits ``bump_map_major_version_zero`` + must still produce a working rule when ``major_version_zero=False``.""" + from commitizen.cz.base import BaseCommitizen + + class _LegacyCz(BaseCommitizen): + bump_pattern = BUMP_PATTERN + bump_map = BUMP_MAP + # bump_map_major_version_zero deliberately not set + + def questions(self): + return [] + + def message(self, answers): + return "" + + def example(self): + return "" + + def schema(self): + return "" + + def schema_pattern(self): + return "" + + def info(self): + return "" + + rule = _LegacyCz(config).bump_rule + assert rule.extract_increment("feat: x", False) == VersionIncrement.MINOR + # And only fails when major_version_zero is actually required. + with pytest.raises(NoPatternMapError): + rule.extract_increment("feat: x", True) + + def test_plugin_without_bump_pattern_raises(self, config): + from commitizen.cz.base import BaseCommitizen + + class _BrokenCz(BaseCommitizen): + bump_pattern = None + bump_map = BUMP_MAP + + def questions(self): + return [] + + def message(self, answers): + return "" + + def example(self): + return "" + + def schema(self): + return "" + + def schema_pattern(self): + return "" + + def info(self): + return "" + + with pytest.raises(NoPatternMapError): + _BrokenCz(config).bump_rule diff --git a/tests/test_deprecated.py b/tests/test_deprecated.py index ebaae82c3..a0eaeb4f6 100644 --- a/tests/test_deprecated.py +++ b/tests/test_deprecated.py @@ -16,6 +16,9 @@ (lambda: defaults.change_type_order, defaults.CHANGE_TYPE_ORDER), (lambda: defaults.encoding, defaults.ENCODING), (lambda: defaults.name, defaults.DEFAULT_SETTINGS["name"]), + (lambda: defaults.MAJOR, "MAJOR"), + (lambda: defaults.MINOR, "MINOR"), + (lambda: defaults.PATCH, "PATCH"), ( lambda: changelog_formats.guess_changelog_format, changelog_formats._guess_changelog_format, diff --git a/tests/test_version_increment.py b/tests/test_version_increment.py index 5832140a8..ceac49323 100644 --- a/tests/test_version_increment.py +++ b/tests/test_version_increment.py @@ -11,14 +11,22 @@ ("PATCH", VersionIncrement.PATCH), ("NONE", VersionIncrement.NONE), ("not_a_valid_name", VersionIncrement.NONE), + ("major", VersionIncrement.NONE), # case sensitive + ("", VersionIncrement.NONE), (None, VersionIncrement.NONE), (123, VersionIncrement.NONE), + (True, VersionIncrement.NONE), + ([], VersionIncrement.NONE), + ({}, VersionIncrement.NONE), + (VersionIncrement.MAJOR, VersionIncrement.NONE), # enum value itself ], ) def test_version_increment_from_value( value: object, expected: VersionIncrement ) -> None: assert VersionIncrement.from_value(value) == expected + # ``safe_cast`` is an alias used by the BumpRule plumbing. + assert VersionIncrement.safe_cast(value) == expected def test_version_increment_str() -> None: diff --git a/tests/test_version_scheme_pep440.py b/tests/test_version_scheme_pep440.py index 479c2f775..85e6fba0e 100644 --- a/tests/test_version_scheme_pep440.py +++ b/tests/test_version_scheme_pep440.py @@ -1,5 +1,6 @@ import pytest +from commitizen.bump_rule import VersionIncrement from commitizen.version_schemes import Pep440, VersionProtocol from tests.utils import VersionSchemeTestArgs @@ -10,7 +11,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -20,7 +21,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -30,7 +31,7 @@ ( VersionSchemeTestArgs( current_version="2.1.1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -40,7 +41,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -50,7 +51,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -60,7 +61,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -70,7 +71,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -80,7 +81,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -90,7 +91,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=1, devrelease=None, @@ -100,7 +101,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0beta1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -110,7 +111,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -121,7 +122,7 @@ ( VersionSchemeTestArgs( current_version="1.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -131,7 +132,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -141,7 +142,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -151,7 +152,7 @@ ( VersionSchemeTestArgs( current_version="1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -161,7 +162,7 @@ ( VersionSchemeTestArgs( current_version="1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -171,7 +172,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -181,7 +182,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=1, devrelease=None, @@ -191,7 +192,7 @@ ( VersionSchemeTestArgs( current_version="1beta", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -201,7 +202,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0alpha1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -211,7 +212,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -221,7 +222,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc1+e20d7b57f3eb", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -232,7 +233,7 @@ ( VersionSchemeTestArgs( current_version="0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -242,7 +243,7 @@ ( VersionSchemeTestArgs( current_version="0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=1, @@ -252,7 +253,7 @@ ( VersionSchemeTestArgs( current_version="0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -262,7 +263,7 @@ ( VersionSchemeTestArgs( current_version="0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=1, @@ -272,7 +273,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -282,7 +283,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -292,7 +293,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -302,7 +303,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -312,7 +313,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -322,7 +323,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease=None, prerelease_offset=0, devrelease=None, @@ -332,7 +333,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -342,7 +343,7 @@ ( VersionSchemeTestArgs( current_version="0.4.2", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -352,7 +353,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -362,7 +363,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -372,7 +373,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=1, @@ -382,7 +383,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2.dev0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=1, @@ -392,7 +393,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2.dev0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=0, @@ -402,7 +403,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -412,7 +413,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0b0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -422,7 +423,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0b1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -432,7 +433,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -442,7 +443,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=1, @@ -452,7 +453,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -462,7 +463,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a3.dev0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -472,7 +473,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -482,7 +483,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -492,7 +493,7 @@ ( VersionSchemeTestArgs( current_version="1.0.2", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -502,7 +503,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -512,7 +513,7 @@ ( VersionSchemeTestArgs( current_version="1.2.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -522,7 +523,7 @@ ( VersionSchemeTestArgs( current_version="1.2.1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -533,7 +534,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1b1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -543,7 +544,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -553,7 +554,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -564,7 +565,7 @@ ( VersionSchemeTestArgs( current_version="3.3.3", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -574,7 +575,7 @@ ( VersionSchemeTestArgs( current_version="3.3.4a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -584,7 +585,7 @@ ( VersionSchemeTestArgs( current_version="3.3.4a1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -594,7 +595,7 @@ ( VersionSchemeTestArgs( current_version="3.4.0a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -604,7 +605,7 @@ ( VersionSchemeTestArgs( current_version="3.4.0a1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -614,7 +615,7 @@ ( VersionSchemeTestArgs( current_version="3.4.0a2", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -624,7 +625,7 @@ ( VersionSchemeTestArgs( current_version="4.0.0a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -634,7 +635,7 @@ ( VersionSchemeTestArgs( current_version="4.0.0a1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -644,7 +645,7 @@ ( VersionSchemeTestArgs( current_version="4.0.0a2", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -655,7 +656,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -665,7 +666,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -675,7 +676,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1a1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -685,7 +686,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -695,7 +696,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -705,7 +706,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a2", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -716,7 +717,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -726,7 +727,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a2", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -736,7 +737,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a3", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -747,7 +748,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -757,7 +758,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -767,7 +768,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -777,7 +778,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a2", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -787,7 +788,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a3", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -797,7 +798,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a4", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -807,7 +808,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a5", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -818,7 +819,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -828,7 +829,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -839,7 +840,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -849,7 +850,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1a0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -859,7 +860,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1a0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -870,7 +871,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -880,7 +881,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -890,7 +891,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0a0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -901,7 +902,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -911,7 +912,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -921,7 +922,7 @@ ( VersionSchemeTestArgs( current_version="2.0.0a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -932,7 +933,7 @@ ( VersionSchemeTestArgs( current_version="3.0.0a1", - increment=None, + increment=VersionIncrement.NONE, prerelease=None, prerelease_offset=0, devrelease=None, @@ -942,7 +943,7 @@ ( VersionSchemeTestArgs( current_version="3.0.0b1", - increment=None, + increment=VersionIncrement.NONE, prerelease=None, prerelease_offset=0, devrelease=None, @@ -952,7 +953,7 @@ ( VersionSchemeTestArgs( current_version="3.0.0rc1", - increment=None, + increment=VersionIncrement.NONE, prerelease=None, prerelease_offset=0, devrelease=None, @@ -963,7 +964,7 @@ ( VersionSchemeTestArgs( current_version="3.1.4", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -973,7 +974,7 @@ ( VersionSchemeTestArgs( current_version="3.1.4", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -983,7 +984,7 @@ ( VersionSchemeTestArgs( current_version="3.1.4", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -993,7 +994,7 @@ ( VersionSchemeTestArgs( current_version="3.1.4a0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -1003,7 +1004,7 @@ ( VersionSchemeTestArgs( current_version="3.1.4a0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -1013,7 +1014,7 @@ ( VersionSchemeTestArgs( current_version="3.1.4a0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -1042,7 +1043,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -1052,7 +1053,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -1063,7 +1064,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -1074,7 +1075,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0b0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -1085,7 +1086,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0b1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -1096,7 +1097,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -1107,7 +1108,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="rc", prerelease_offset=0, devrelease=1, @@ -1118,7 +1119,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -1129,7 +1130,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -1140,7 +1141,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -1151,7 +1152,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0b1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -1162,7 +1163,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -1173,7 +1174,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="rc", prerelease_offset=0, devrelease=1, @@ -1184,7 +1185,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -1195,7 +1196,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -1206,7 +1207,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -1217,7 +1218,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -1228,7 +1229,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -1239,7 +1240,7 @@ def test_bump_pep440_version(version_args, expected_version): ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -1269,7 +1270,7 @@ def test_bump_pep440_version_force(version_args, expected_version): ( VersionSchemeTestArgs( current_version="4.5.0+0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -1279,7 +1280,7 @@ def test_bump_pep440_version_force(version_args, expected_version): ( VersionSchemeTestArgs( current_version="4.5.0+0.1.1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -1289,7 +1290,7 @@ def test_bump_pep440_version_force(version_args, expected_version): ( VersionSchemeTestArgs( current_version="4.5.0+0.2.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, diff --git a/tests/test_version_scheme_semver.py b/tests/test_version_scheme_semver.py index b5a275e98..e09ab28f1 100644 --- a/tests/test_version_scheme_semver.py +++ b/tests/test_version_scheme_semver.py @@ -2,6 +2,7 @@ import pytest +from commitizen.bump_rule import VersionIncrement from commitizen.version_schemes import SemVer, VersionProtocol from tests.utils import VersionSchemeTestArgs @@ -12,7 +13,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -22,7 +23,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -32,7 +33,7 @@ ( VersionSchemeTestArgs( current_version="2.1.1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -42,7 +43,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -52,7 +53,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -62,7 +63,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -72,7 +73,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -82,7 +83,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -92,7 +93,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=1, devrelease=None, @@ -102,7 +103,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0beta1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -112,7 +113,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -122,7 +123,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -132,7 +133,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -143,7 +144,7 @@ ( VersionSchemeTestArgs( current_version="1.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -153,7 +154,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -163,7 +164,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -173,7 +174,7 @@ ( VersionSchemeTestArgs( current_version="1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -183,7 +184,7 @@ ( VersionSchemeTestArgs( current_version="1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -193,7 +194,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -203,7 +204,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=1, devrelease=None, @@ -213,7 +214,7 @@ ( VersionSchemeTestArgs( current_version="1beta", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -223,7 +224,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0alpha1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -233,7 +234,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -243,7 +244,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc1+e20d7b57f3eb", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -254,7 +255,7 @@ ( VersionSchemeTestArgs( current_version="0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -264,7 +265,7 @@ ( VersionSchemeTestArgs( current_version="0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=1, @@ -274,7 +275,7 @@ ( VersionSchemeTestArgs( current_version="0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -284,7 +285,7 @@ ( VersionSchemeTestArgs( current_version="0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=1, @@ -294,7 +295,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -304,7 +305,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -314,7 +315,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -324,7 +325,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -334,7 +335,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -344,7 +345,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1a0", - increment=None, + increment=VersionIncrement.NONE, prerelease=None, prerelease_offset=0, devrelease=None, @@ -354,7 +355,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -364,7 +365,7 @@ ( VersionSchemeTestArgs( current_version="0.4.2", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -374,7 +375,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -384,7 +385,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -394,7 +395,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=1, @@ -404,7 +405,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2.dev0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=1, @@ -414,7 +415,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a2.dev0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=0, @@ -424,7 +425,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -434,7 +435,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0b0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -444,7 +445,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0b1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -454,7 +455,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -464,7 +465,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=1, @@ -474,7 +475,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -484,7 +485,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0a3.dev0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -494,7 +495,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -504,7 +505,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -514,7 +515,7 @@ ( VersionSchemeTestArgs( current_version="1.0.2", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -524,7 +525,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -534,7 +535,7 @@ ( VersionSchemeTestArgs( current_version="1.2.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -544,7 +545,7 @@ ( VersionSchemeTestArgs( current_version="1.2.1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -555,7 +556,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1b1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -565,7 +566,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -575,7 +576,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1rc0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -606,7 +607,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -616,7 +617,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -627,7 +628,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -638,7 +639,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0b0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -649,7 +650,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0b1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -660,7 +661,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -671,7 +672,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="rc", prerelease_offset=0, devrelease=1, @@ -682,7 +683,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0a1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -693,7 +694,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -704,7 +705,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0b1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -715,7 +716,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -726,7 +727,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="1.0.0rc0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="rc", prerelease_offset=0, devrelease=1, @@ -737,7 +738,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -748,7 +749,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -759,7 +760,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -770,7 +771,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -781,7 +782,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -792,7 +793,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="2.0.0b0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -824,7 +825,7 @@ def test_bump_semver_version_force( ( VersionSchemeTestArgs( current_version="4.5.0+0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -834,7 +835,7 @@ def test_bump_semver_version_force( ( VersionSchemeTestArgs( current_version="4.5.0+0.1.1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -844,7 +845,7 @@ def test_bump_semver_version_force( ( VersionSchemeTestArgs( current_version="4.5.0+0.2.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, diff --git a/tests/test_version_scheme_semver2.py b/tests/test_version_scheme_semver2.py index ddd975bf7..ca309d21b 100644 --- a/tests/test_version_scheme_semver2.py +++ b/tests/test_version_scheme_semver2.py @@ -2,6 +2,7 @@ import pytest +from commitizen.bump_rule import VersionIncrement from commitizen.version_schemes import SemVer2, VersionProtocol from tests.utils import VersionSchemeTestArgs @@ -12,7 +13,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -22,7 +23,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -32,7 +33,7 @@ ( VersionSchemeTestArgs( current_version="2.1.1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -42,7 +43,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -52,7 +53,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -62,7 +63,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -72,7 +73,7 @@ ( VersionSchemeTestArgs( current_version="0.9.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -82,7 +83,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.2", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -92,7 +93,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.2", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=1, devrelease=None, @@ -102,7 +103,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-beta.1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -112,7 +113,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-rc.1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -122,7 +123,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -132,7 +133,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -143,7 +144,7 @@ ( VersionSchemeTestArgs( current_version="1.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -153,7 +154,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -163,7 +164,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -173,7 +174,7 @@ ( VersionSchemeTestArgs( current_version="1-alpha.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -183,7 +184,7 @@ ( VersionSchemeTestArgs( current_version="1-alpha.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -193,7 +194,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -203,7 +204,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=1, devrelease=None, @@ -213,7 +214,7 @@ ( VersionSchemeTestArgs( current_version="1-beta", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -223,7 +224,7 @@ ( VersionSchemeTestArgs( current_version="1", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -233,7 +234,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-rc.1+e20d7b57f3eb", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -244,7 +245,7 @@ ( VersionSchemeTestArgs( current_version="0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -254,7 +255,7 @@ ( VersionSchemeTestArgs( current_version="0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=1, @@ -264,7 +265,7 @@ ( VersionSchemeTestArgs( current_version="0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -274,7 +275,7 @@ ( VersionSchemeTestArgs( current_version="0.2.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=1, @@ -284,7 +285,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -294,7 +295,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -304,7 +305,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1-alpha.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -314,7 +315,7 @@ ( VersionSchemeTestArgs( current_version="0.3.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -324,7 +325,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1-alpha.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=1, devrelease=None, @@ -334,7 +335,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1-alpha.0", - increment=None, + increment=VersionIncrement.NONE, prerelease=None, prerelease_offset=0, devrelease=None, @@ -344,7 +345,7 @@ ( VersionSchemeTestArgs( current_version="0.3.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -354,7 +355,7 @@ ( VersionSchemeTestArgs( current_version="0.4.2", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -364,7 +365,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -374,7 +375,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=1, @@ -384,7 +385,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.2.dev.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=1, @@ -394,7 +395,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.2.dev.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=0, @@ -404,7 +405,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.1", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -414,7 +415,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-beta.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -424,7 +425,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-rc.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=None, @@ -434,7 +435,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-rc.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="rc", prerelease_offset=0, devrelease=1, @@ -444,7 +445,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-rc.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -454,7 +455,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0-alpha.3.dev.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -464,7 +465,7 @@ ( VersionSchemeTestArgs( current_version="1.0.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -474,7 +475,7 @@ ( VersionSchemeTestArgs( current_version="1.0.1", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -484,7 +485,7 @@ ( VersionSchemeTestArgs( current_version="1.0.2", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -494,7 +495,7 @@ ( VersionSchemeTestArgs( current_version="1.1.0", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -504,7 +505,7 @@ ( VersionSchemeTestArgs( current_version="1.2.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -514,7 +515,7 @@ ( VersionSchemeTestArgs( current_version="1.2.1", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -525,7 +526,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1-beta.1", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -535,7 +536,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1-rc.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="alpha", prerelease_offset=0, devrelease=None, @@ -545,7 +546,7 @@ ( VersionSchemeTestArgs( current_version="0.1.1-rc.0", - increment=None, + increment=VersionIncrement.NONE, prerelease="beta", prerelease_offset=0, devrelease=None, @@ -576,7 +577,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="4.5.0+0.1.0", - increment="PATCH", + increment=VersionIncrement.PATCH, prerelease=None, prerelease_offset=0, devrelease=None, @@ -586,7 +587,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="4.5.0+0.1.1", - increment="MINOR", + increment=VersionIncrement.MINOR, prerelease=None, prerelease_offset=0, devrelease=None, @@ -596,7 +597,7 @@ def test_bump_semver_version( ( VersionSchemeTestArgs( current_version="4.5.0+0.2.0", - increment="MAJOR", + increment=VersionIncrement.MAJOR, prerelease=None, prerelease_offset=0, devrelease=None, diff --git a/tests/utils.py b/tests/utils.py index 77554c797..3a4697e52 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -18,12 +18,13 @@ from freezegun.api import FrozenDateTimeFactory from pytest_mock import MockerFixture - from commitizen.version_schemes import Increment, Prerelease + from commitizen.bump_rule import VersionIncrement + from commitizen.version_schemes import Prerelease class VersionSchemeTestArgs(NamedTuple): current_version: str - increment: Increment | None + increment: VersionIncrement prerelease: Prerelease | None prerelease_offset: int devrelease: int | None