Merge pull request #326 from callowayproject/fix-moveable-tags

Bug Fixes

Author: coordt

bumpversion/files.py

@@ -7,6 +7,7 @@
 from pathlib import Path
 from typing import Dict, List, MutableMapping, Optional
 
+from bumpversion.config import DEFAULTS as DEFAULT_CONFIG
 from bumpversion.config.models import FileChange
 from bumpversion.exceptions import VersionNotFoundError
 from bumpversion.ui import get_indented_logger
@@ -129,7 +130,7 @@ def write_file_contents(self, contents: str) -> None:
             f.write(contents)
 
     def _contains_change_pattern(
-        self, search_expression: re.Pattern, raw_search_expression: str, version: Version, context: MutableMapping
+        self, search_expression: re.Pattern, raw_search_expression: str, version: Version
     ) -> bool:
         """
         Does the file contain the change pattern?
@@ -138,7 +139,6 @@ def _contains_change_pattern(
             search_expression: The compiled search expression
             raw_search_expression: The raw search expression
             version: The version to check, in case it's not the same as the original
-            context: The context to use
 
         Raises:
             VersionNotFoundError: if the version number isn't present in this file.
@@ -155,7 +155,7 @@ def _contains_change_pattern(
         # match instead. This is probably the case if environment variables are used.
 
         # check whether `search` isn't customized
-        search_pattern_is_default = self.file_change.search == self.version_config.search
+        search_pattern_is_default = self.file_change.search == DEFAULT_CONFIG["search"]
 
         if search_pattern_is_default and contains_pattern(re.compile(re.escape(version.original)), file_contents):
             # The original version is present, and we're not looking for something
@@ -195,7 +195,7 @@ def make_file_change(
         search_for, raw_search_pattern = self.file_change.get_search_pattern(context)
         replace_with = self.version_config.replace.format(**context)
 
-        if not self._contains_change_pattern(search_for, raw_search_pattern, current_version, context):
+        if not self._contains_change_pattern(search_for, raw_search_pattern, current_version):
             logger.dedent()
             return
 

bumpversion/scm/git.py

@@ -103,7 +103,7 @@ def commit_and_tag(self, files: List[Pathlike], context: MutableMapping, dry_run
             tag(tag_name, sign=self.config.sign_tags, message=tag_message)
 
             for m_tag_name in self.config.moveable_tags:
-                moveable_tag(m_tag_name)
+                moveable_tag(m_tag_name.format(**context))
 
     def assert_nondirty(self) -> None:
         """

tests/test_cli/test_replace.py

@@ -197,14 +197,7 @@ def test_unintentional_valid_regex_still_found(self, tmp_path: Path, caplog, run
             )
             config_file = tmp_path / ".bumpversion.toml"
             config_file.write_text(
-                "[tool.bumpversion]\n"
-                'current_version = "0.0.1"\n'
-                "allow_dirty = true\n\n"
-                "[[tool.bumpversion.files]]\n"
-                'filename = "VERSION"\n'
-                "regex = false\n"
-                f'search = "{search}"\n'
-                f'replace = "{replace}"\n',
+                "[tool.bumpversion]\n" 'current_version = "0.0.1"\n' "allow_dirty = true\n\n",
                 encoding="utf-8",
             )
 
@@ -214,7 +207,7 @@ def test_unintentional_valid_regex_still_found(self, tmp_path: Path, caplog, run
                     cli.cli,
                     [
                         "replace",
-                        "--verbose",
+                        "-vv",
                         "--no-regex",
                         "--no-configured-files",
                         "--search",
@@ -229,7 +222,10 @@ def test_unintentional_valid_regex_still_found(self, tmp_path: Path, caplog, run
             if result.exit_code != 0:
                 print("Here is the output:")
                 print(result.output)
-                print(traceback.print_exception(result.exc_info[1]))
+                # print(traceback.print_exception(result.exc_info[1]))
+                print(caplog.text)
+                print("ouch")
+                print(version_path.read_text())
 
             assert result.exit_code == 0
             assert (

tests/test_files.py

@@ -69,7 +69,7 @@ def test_non_matching_search_does_not_modify_file(self, tmp_path: Path):
             """
         # Unreleased
 
-        * bullet point A
+        * bullet point A prep for 1.0.3
 
         # Release v'older' (2019-09-17)
 

tests/test_scm/test_git.py

@@ -14,53 +14,56 @@
 from tests.conftest import inside_dir
 
 
+@pytest.fixture
+def git_instance(scm_config: SCMConfig) -> Git:
+    """Return a Git instance."""
+    return Git(config=scm_config)
+
+
 class TestGit:
     """Tests related to Git."""
 
     class TestIsAvailable:
         """Tests related to Git.is_available."""
 
-        def test_recognizes_a_git_repo(self, git_repo: Path, scm_config: SCMConfig) -> None:
+        def test_recognizes_a_git_repo(self, git_repo: Path, git_instance: Git) -> None:
             """Should return true if git is available, and it is a git repo."""
             with inside_dir(git_repo):
-                git_tool = Git(scm_config)
-                assert git_tool.is_available()
+                assert git_instance.is_available()
 
-        def test_recognizes_not_a_git_repo(self, tmp_path: Path, scm_config: SCMConfig) -> None:
+        def test_recognizes_not_a_git_repo(self, tmp_path: Path, git_instance: Git) -> None:
             """Should return false if it is not a git repo."""
             with inside_dir(tmp_path):
-                git_tool = Git(scm_config)
-                assert not git_tool.is_available()
+                assert not git_instance.is_available()
 
     class TestLatestTagInfo:
         """Test for the Git.latest_tag_info() function."""
 
-        def test_returns_default_if_not_available(self, tmp_path: Path, scm_config: SCMConfig) -> None:
+        def test_returns_default_if_not_available(self, tmp_path: Path, git_instance: Git) -> None:
             """If git is not available, it returns the default LatestTagInfo object, with all None values."""
             # Arrange
             expected = LatestTagInfo()
-            tool = Git(scm_config)
 
             # Act
             with inside_dir(tmp_path):
-                info = tool.latest_tag_info()
+                info = git_instance.latest_tag_info()
 
             # Assert
             assert info == expected
 
-        def test_returns_correct_commit_and_tag_info(self, git_repo: Path, scm_config: SCMConfig) -> None:
+        def test_returns_correct_commit_and_tag_info(self, git_repo: Path, git_instance: Git) -> None:
             """Should return information that it is a git repo."""
             # Arrange
             tag_prefix = "app/"
             readme = git_repo.joinpath("readme.md")
             readme.touch()
-            scm_config.tag_name = f"{tag_prefix}{{new_version}}"
+            git_instance.config.tag_name = f"{tag_prefix}{{new_version}}"
 
             # Act
             with inside_dir(git_repo):
                 commit_readme("first")
                 tag(f"{tag_prefix}0.1.0", sign=False, message="bumpversion")
-                tag_info = Git(scm_config).latest_tag_info()
+                tag_info = git_instance.latest_tag_info()
 
             # Assert
             assert tag_info.commit_sha is not None
@@ -79,7 +82,7 @@ class TestGitAddPath:
         @patch("bumpversion.scm.git.Git.latest_tag_info")
         @patch("bumpversion.scm.git.is_subpath")
         def test_valid_subpath_is_added(
-            self, mock_is_subpath, mock_latest_tag_info, mock_run_command, scm_config: SCMConfig, tmp_path: Path
+            self, mock_is_subpath, mock_latest_tag_info, mock_run_command, git_instance: Git, tmp_path: Path
         ):
             """A path that is a subpath of the repository root should be added."""
             # Arrange
@@ -89,7 +92,6 @@ def test_valid_subpath_is_added(
             mock_latest_tag_info.return_value.repository_root = repository_root
             mock_is_subpath.return_value = True
             mock_run_command.return_value = None
-            git_instance = Git(scm_config)
 
             # Act
             with inside_dir(repository_root):
@@ -102,7 +104,7 @@ def test_valid_subpath_is_added(
         @patch("bumpversion.scm.git.Git.latest_tag_info")
         @patch("bumpversion.scm.git.is_subpath")
         def test_invalid_subpath_is_not_added(
-            self, mock_is_subpath, mock_latest_tag_info, mock_run_command, scm_config, tmp_path: Path
+            self, mock_is_subpath, mock_latest_tag_info, mock_run_command, git_instance: Git, tmp_path: Path
         ):
             """A path that is not a subpath of the repository root should not be added."""
             # Arrange
@@ -111,7 +113,6 @@ def test_invalid_subpath_is_not_added(
             path_to_add = repository_root / "file.txt"
             mock_latest_tag_info.return_value.repository_root = repository_root
             mock_is_subpath.return_value = False
-            git_instance = Git(scm_config)
 
             # Act
             git_instance.add_path(path_to_add)
@@ -123,7 +124,7 @@ def test_invalid_subpath_is_not_added(
         @patch("bumpversion.scm.git.Git.latest_tag_info")
         @patch("bumpversion.scm.git.is_subpath")
         def test_raises_error_on_command_failure(
-            self, mock_is_subpath, mock_latest_tag_info, mock_run_command, scm_config: SCMConfig, tmp_path: Path
+            self, mock_is_subpath, mock_latest_tag_info, mock_run_command, git_instance: Git, tmp_path: Path
         ):
             """If the git command fails, a BumpVersionError should be raised."""
             # Arrange
@@ -133,13 +134,101 @@ def test_raises_error_on_command_failure(
             mock_latest_tag_info.return_value.repository_root = repository_root
             mock_is_subpath.return_value = True
             mock_run_command.side_effect = subprocess.CalledProcessError(returncode=1, cmd="git add")
-            git_instance = Git(scm_config)
 
             # Act / Assert
             with inside_dir(repository_root):
                 with pytest.raises(BumpVersionError):
                     git_instance.add_path(path_to_add)
 
+    class TestGitCommitAndTag:
+        """Tests for the commit_and_tag() method."""
+
+        def test_dry_run_skips_method(self, git_instance: Git, mocker):
+            """If dry_run is True, the method is short-circuited."""
+            # Arrange
+            files = ["file1.txt", "file2.txt"]
+            context = {"new_version": "1.0.0", "new_major": "1", "current_version": "0.1.0"}
+            mock_add_path = mocker.patch.object(git_instance, "add_path")
+            mock_commit = mocker.patch.object(git_instance, "commit")
+            mock_tag = mocker.patch("bumpversion.scm.git.tag")
+            mock_moveable_tag = mocker.patch("bumpversion.scm.git.moveable_tag")
+
+            # Act
+            git_instance.commit_and_tag(files, context, dry_run=True)
+
+            # Assert
+            mock_add_path.assert_not_called()
+            mock_commit.assert_not_called()
+            mock_tag.assert_not_called()
+            mock_moveable_tag.assert_not_called()
+
+        def test_commits_and_tags_when_configured(self, git_instance: Git, mocker):
+            """Does both commit and tag functions when they are configured."""
+            # Arrange
+            files = ["file1.txt", "file2.txt"]
+            context = {"new_version": "1.0.0", "new_major": "1", "current_version": "0.1.0"}
+            git_instance.config.moveable_tags = ["v{new_major}"]
+            git_instance.config.tag = True
+            git_instance.config.commit = True
+            mock_add_path = mocker.patch.object(git_instance, "add_path")
+            mock_commit = mocker.patch.object(git_instance, "commit")
+            mock_tag = mocker.patch("bumpversion.scm.git.tag")
+            mock_moveable_tag = mocker.patch("bumpversion.scm.git.moveable_tag")
+
+            # Act
+            git_instance.commit_and_tag(files, context, dry_run=False)
+
+            # Assert
+            assert mock_add_path.call_count == len(files)
+            mock_add_path.assert_any_call("file1.txt")
+            mock_add_path.assert_any_call("file2.txt")
+            mock_commit.assert_called_once_with(context)
+            mock_tag.assert_called_once_with("v1.0.0", sign=False, message="Bump version: 0.1.0 → 1.0.0")
+            mock_moveable_tag.assert_called_once_with("v1")
+
+        def test_tags_when_commit_is_false(self, git_instance: Git, mocker):
+            """The method only tags when commit is False."""
+            # Arrange
+            files = ["file1.txt"]
+            context = {"new_version": "1.0.0", "new_major": "1", "current_version": "0.1.0"}
+            git_instance.config.moveable_tags = ["v{new_major}"]
+            git_instance.config.commit = False
+            git_instance.config.tag = True
+            mock_add_path = mocker.patch.object(git_instance, "add_path")
+            mock_commit = mocker.patch.object(git_instance, "commit")
+            mock_tag = mocker.patch("bumpversion.scm.git.tag")
+            mock_moveable_tag = mocker.patch("bumpversion.scm.git.moveable_tag")
+
+            # Act
+            git_instance.commit_and_tag(files, context, dry_run=False)
+
+            # Assert
+            mock_add_path.assert_not_called()
+            mock_commit.assert_not_called()
+            mock_tag.assert_called_once_with("v1.0.0", sign=False, message="Bump version: 0.1.0 → 1.0.0")
+            mock_moveable_tag.assert_called_once_with("v1")
+
+        def test_commits_when_tag_is_false(self, git_instance: Git, mocker):
+            """The method only commits when tag is False."""
+            # Arrange
+            files = ["file1.txt"]
+            context = {"new_version": "1.0.0", "new_major": "1", "current_version": "0.1.0"}
+            git_instance.config.moveable_tags = ["v{new_major}"]
+            git_instance.config.tag = False
+            git_instance.config.commit = True
+            mock_add_path = mocker.patch.object(git_instance, "add_path")
+            mock_commit = mocker.patch.object(git_instance, "commit")
+            mock_tag = mocker.patch("bumpversion.scm.git.tag")
+            mock_moveable_tag = mocker.patch("bumpversion.scm.git.moveable_tag")
+
+            # Act
+            git_instance.commit_and_tag(files, context, dry_run=False)
+
+            mock_add_path.assert_called_with("file1.txt")
+            mock_commit.assert_called_once_with(context)
+            mock_tag.assert_not_called()
+            mock_moveable_tag.assert_not_called()
+
 
 class TestRevisionInfo:
     """Tests for the revision_info function."""