python-semantic-release 10.5.1__tar.gz → 10.5.3__tar.gz

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-semantic-release
-Version: 10.5.1
+Version: 10.5.3
 Summary: Automatic Semantic Versioning for Python projects
 Author-email: Rolf Erik Lekang <me@rolflekang.com>, codejedi365 <codejedi365@gmail.com>
 License: MIT

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/docs/configuration/automatic-releases/github-actions.rst

@@ -893,14 +893,14 @@ to the GitHub Release Assets as well.
           - name: Action | Semantic Version Release
             id: release
             # Adjust tag with desired version if applicable.
-            uses: python-semantic-release/python-semantic-release@v10.5.1
+            uses: python-semantic-release/python-semantic-release@v10.5.3
             with:
               github_token: ${{ secrets.GITHUB_TOKEN }}
               git_committer_name: "github-actions"
               git_committer_email: "actions@users.noreply.github.com"
 
           - name: Publish | Upload to GitHub Release Assets
-            uses: python-semantic-release/publish-action@v10.5.1
+            uses: python-semantic-release/publish-action@v10.5.3
             if: steps.release.outputs.released == 'true'
             with:
               github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -1005,7 +1005,7 @@ The equivalent GitHub Action configuration would be:
 
   - name: Action | Semantic Version Release
     # Adjust tag with desired version if applicable.
-    uses: python-semantic-release/python-semantic-release@v10.5.1
+    uses: python-semantic-release/python-semantic-release@v10.5.3
     with:
       github_token: ${{ secrets.GITHUB_TOKEN }}
       force: patch
@@ -1064,14 +1064,14 @@ Publish Action.
 
         - name: Release submodule 1
           id: release-submod-1
-          uses: python-semantic-release/python-semantic-release@v10.5.1
+          uses: python-semantic-release/python-semantic-release@v10.5.3
           with:
             directory: ${{ env.SUBMODULE_1_DIR }}
             github_token: ${{ secrets.GITHUB_TOKEN }}
 
         - name: Release submodule 2
           id: release-submod-2
-          uses: python-semantic-release/python-semantic-release@v10.5.1
+          uses: python-semantic-release/python-semantic-release@v10.5.3
           with:
             directory: ${{ env.SUBMODULE_2_DIR }}
             github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -1083,7 +1083,7 @@ Publish Action.
         # ------------------------------------------------------------------- #
 
         - name: Publish | Upload package 1 to GitHub Release Assets
-          uses: python-semantic-release/publish-action@v10.5.1
+          uses: python-semantic-release/publish-action@v10.5.3
           if: steps.release-submod-1.outputs.released == 'true'
           with:
             directory: ${{ env.SUBMODULE_1_DIR }}
@@ -1091,7 +1091,7 @@ Publish Action.
             tag: ${{ steps.release-submod-1.outputs.tag }}
 
         - name: Publish | Upload package 2 to GitHub Release Assets
-          uses: python-semantic-release/publish-action@v10.5.1
+          uses: python-semantic-release/publish-action@v10.5.3
           if: steps.release-submod-2.outputs.released == 'true'
           with:
             directory: ${{ env.SUBMODULE_2_DIR }}

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-semantic-release"
-version = "10.5.1"
+version = "10.5.3"
 description = "Automatic Semantic Versioning for Python projects"
 requires-python = "~= 3.8"
 license = { text = "MIT" }
@@ -409,6 +409,7 @@ sections = { "tests" = ["tests"] }
 ignore_names = ["change_to_ex_proj_dir", "init_example_project"]
 
 [tool.semantic_release]
+add_partial_tags = true
 logging_use_named_masks = true
 commit_parser = "conventional"
 commit_parser_options = { parse_squash_commits = true, ignore_merge_commits = true }

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/src/semantic_release/cli/commands/version.py

@@ -722,6 +722,7 @@ def version(  # noqa: C901
             )
         except GitCommitEmptyIndexError:
             logger.info("No local changes to add to any commit, skipping")
+            commit_changes = False
 
     # Tag the version after potentially creating a new HEAD commit.
     # This way if no source code is modified, i.e. all metadata updates
@@ -752,6 +753,7 @@ def version(  # noqa: C901
                 project.verify_upstream_unchanged(
                     local_ref="HEAD~1",
                     upstream_ref=config.remote.name,
+                    remote_url=remote_url,
                     noop=opts.noop,
                 )
             except UpstreamBranchChangedError as exc:

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/src/semantic_release/commit_parser/conventional/options_monorepo.py

@@ -43,37 +43,46 @@ class ConventionalCommitMonorepoParserOptions(ConventionalCommitParserOptions):
     to match them literally.
     """
 
-    @classmethod
     @field_validator("path_filters", mode="before")
-    def convert_strs_to_paths(cls, value: Any) -> tuple[Path, ...]:
-        values = value if isinstance(value, Iterable) else [value]
-        results: list[Path] = []
+    @classmethod
+    def convert_strs_to_paths(cls, value: Any) -> tuple[str, ...]:
+        if isinstance(value, str):
+            return (value,)
 
-        for val in values:
-            if isinstance(val, (str, Path)):
-                results.append(Path(val))
-                continue
+        if isinstance(value, Path):
+            return (str(value),)
 
-            raise TypeError(f"Invalid type: {type(val)}, expected str or Path.")
+        if isinstance(value, Iterable):
+            results: list[str] = []
+            for val in value:
+                if isinstance(val, (str, Path)):
+                    results.append(str(Path(val)))
+                    continue
 
-        return tuple(results)
+                msg = f"Invalid type: {type(val)}, expected str or Path."
+                raise TypeError(msg)
+
+            return tuple(results)
+
+        msg = f"Invalid type: {type(value)}, expected str, Path, or Iterable."
+        raise TypeError(msg)
 
-    @classmethod
     @field_validator("path_filters", mode="after")
-    def resolve_path(cls, dir_paths: tuple[Path, ...]) -> tuple[Path, ...]:
+    @classmethod
+    def resolve_path(cls, dir_path_strs: tuple[str, ...]) -> tuple[str, ...]:
         return tuple(
             (
-                Path(f"!{Path(str_path[1:]).expanduser().absolute().resolve()}")
+                f"!{Path(str_path[1:]).expanduser().absolute().resolve()}"
                 # maintains the negation prefix if it exists
-                if (str_path := str(path)).startswith("!")
+                if str_path.startswith("!")
                 # otherwise, resolve the path normally
-                else path.expanduser().absolute().resolve()
+                else str(Path(str_path).expanduser().absolute().resolve())
             )
-            for path in dir_paths
+            for str_path in dir_path_strs
         )
 
-    @classmethod
     @field_validator("scope_prefix", mode="after")
+    @classmethod
     def validate_scope_prefix(cls, scope_prefix: str) -> str:
         if not scope_prefix:
             return ""

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/src/semantic_release/gitproject.py

@@ -336,13 +336,18 @@ class GitProject:
                 raise GitPushError(f"Failed to push tag ({tag}) to remote") from err
 
     def verify_upstream_unchanged(  # noqa: C901
-        self, local_ref: str = "HEAD", upstream_ref: str = "origin", noop: bool = False
+        self,
+        local_ref: str = "HEAD",
+        upstream_ref: str = "origin",
+        remote_url: str | None = None,
+        noop: bool = False,
     ) -> None:
         """
         Verify that the upstream branch has not changed since the given local reference.
 
         :param local_ref: The local reference to compare against upstream (default: HEAD)
         :param upstream_ref: The name of the upstream remote or specific remote branch (default: origin)
+        :param remote_url: Optional authenticated remote URL to use for fetching (default: None, uses configured remote)
         :param noop: Whether to skip the actual verification (for dry-run mode)
 
         :raises UpstreamBranchChangedError: If the upstream branch has changed
@@ -409,7 +414,46 @@ class GitProject:
             # Fetch the latest changes from the remote
             self.logger.info("Fetching latest changes from remote '%s'", remote_name)
             try:
-                remote_ref_obj.fetch()
+                # Check if we should use authenticated URL for fetch
+                # Only use remote_url if:
+                # 1. It's provided and different from the configured remote URL
+                # 2. It contains authentication credentials (@ symbol)
+                # 3. The configured remote is NOT a local path, file:// URL, or test URL (example.com)
+                #    This ensures we don't break tests or local development
+                configured_url = remote_ref_obj.url
+                is_local_or_test_remote = (
+                    configured_url.startswith(("file://", "/", "C:/", "H:/"))
+                    or "example.com" in configured_url
+                    or not configured_url.startswith(
+                        (
+                            "https://",
+                            "http://",
+                            "git://",
+                            "git@",
+                            "ssh://",
+                            "git+ssh://",
+                        )
+                    )
+                )
+
+                use_authenticated_fetch = (
+                    remote_url
+                    and "@" in remote_url
+                    and remote_url != configured_url
+                    and not is_local_or_test_remote
+                )
+
+                if use_authenticated_fetch:
+                    # Use authenticated remote URL for fetch
+                    # Fetch the remote branch and update the local tracking ref
+                    repo.git.fetch(
+                        remote_url,
+                        f"refs/heads/{remote_branch_name}:refs/remotes/{upstream_full_ref_name}",
+                    )
+                else:
+                    # Use the default remote configuration for local paths,
+                    # file:// URLs, test URLs, or when no authentication is needed
+                    remote_ref_obj.fetch()
             except GitCommandError as err:
                 self.logger.exception(str(err))
                 err_msg = f"Failed to fetch from remote '{remote_name}'"

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/tests/conftest.py

@@ -206,6 +206,10 @@ def run_cli(clean_os_environment: dict[str, str]) -> RunCliFn:
         invoke_kwargs: dict[str, Any] | None = None,
     ) -> Result:
         from semantic_release.cli.commands.main import main
+        from semantic_release.globals import logger
+
+        # Prevent logs from being propagated to the root logger (pytest)
+        logger.propagate = False
 
         cli_runner = CliRunner(mix_stderr=False)
         env_vars = {**clean_os_environment, **(env or {})}
@@ -213,7 +217,11 @@ def run_cli(clean_os_environment: dict[str, str]) -> RunCliFn:
 
         with mock.patch.dict(os.environ, env_vars, clear=True):
             # run the CLI with the provided arguments
-            return cli_runner.invoke(main, args=args, **(invoke_kwargs or {}))
+            result = cli_runner.invoke(main, args=args, **(invoke_kwargs or {}))
+            # Force the output to be printed to stdout which will be captured by pytest
+            sys.stdout.write(result.stdout)
+            sys.stderr.write(result.stderr)
+            return result
 
     return _run_cli
 

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/tests/e2e/cmd_version/test_version_print.py

@@ -105,7 +105,6 @@ def test_version_print_next_version(
     next_release_version: str,
     file_in_repo: str,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
 ):
@@ -270,7 +269,6 @@ def test_version_print_tag_prints_next_tag(
     get_cfg_value_from_def: GetCfgValueFromDefFn,
     file_in_repo: str,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
 ):
@@ -386,7 +384,6 @@ def test_version_print_tag_prints_next_tag_no_zero_versions(
     get_cfg_value_from_def: GetCfgValueFromDefFn,
     file_in_repo: str,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
 ):
@@ -450,7 +447,6 @@ def test_version_print_last_released_prints_version(
     repo_result: BuiltRepoResult,
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,
@@ -502,7 +498,6 @@ def test_version_print_last_released_prints_released_if_commits(
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     commits: list[str],
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     file_in_repo: str,
@@ -552,10 +547,8 @@ def test_version_print_last_released_prints_released_if_commits(
 def test_version_print_last_released_prints_nothing_if_no_tags(
     repo_result: BuiltRepoResult,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
-    caplog: pytest.LogCaptureFixture,
 ):
     repo = repo_result["repo"]
 
@@ -577,10 +570,7 @@ def test_version_print_last_released_prints_nothing_if_no_tags(
     # Evaluate (no release actions should have occurred on print)
     assert_successful_exit_code(result, cli_cmd)
     assert result.stdout == ""
-
-    # must use capture log to see this, because we use the logger to print this message
-    # not click's output
-    assert "No release tags found." in caplog.text
+    assert "No release tags found." in result.stderr
 
     # assert nothing else happened (no code changes, no commit, no tag, no push, no vcs release)
     assert repo_status_before == repo_status_after
@@ -598,7 +588,6 @@ def test_version_print_last_released_on_detached_head(
     repo_result: BuiltRepoResult,
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,
@@ -647,7 +636,6 @@ def test_version_print_last_released_on_nonrelease_branch(
     repo_result: BuiltRepoResult,
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,
@@ -705,7 +693,6 @@ def test_version_print_last_released_tag_prints_correct_tag(
     get_cfg_value_from_def: GetCfgValueFromDefFn,
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,
@@ -766,7 +753,6 @@ def test_version_print_last_released_tag_prints_released_if_commits(
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     commits: list[str],
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     file_in_repo: str,
@@ -817,10 +803,8 @@ def test_version_print_last_released_tag_prints_released_if_commits(
 def test_version_print_last_released_tag_prints_nothing_if_no_tags(
     repo_result: BuiltRepoResult,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
-    caplog: pytest.LogCaptureFixture,
 ):
     repo = repo_result["repo"]
 
@@ -842,10 +826,7 @@ def test_version_print_last_released_tag_prints_nothing_if_no_tags(
     # Evaluate (no release actions should have occurred on print)
     assert_successful_exit_code(result, cli_cmd)
     assert result.stdout == ""
-
-    # must use capture log to see this, because we use the logger to print this message
-    # not click's output
-    assert "No release tags found." in caplog.text
+    assert "No release tags found." in result.stderr
 
     # assert nothing else happened (no code changes, no commit, no tag, no push, no vcs release)
     assert repo_status_before == repo_status_after
@@ -872,7 +853,6 @@ def test_version_print_last_released_tag_on_detached_head(
     get_cfg_value_from_def: GetCfgValueFromDefFn,
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,
@@ -931,7 +911,6 @@ def test_version_print_last_released_tag_on_nonrelease_branch(
     get_cfg_value_from_def: GetCfgValueFromDefFn,
     get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
     run_cli: RunCliFn,
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,
@@ -989,7 +968,6 @@ def test_version_print_next_version_fails_on_detached_head(
     simulate_change_commits_n_rtn_changelog_entry: SimulateChangeCommitsNReturnChangelogEntryFn,
     get_commit_def_fn: GetCommitDefFn[CommitParser[ParseResult, ParserOptions]],
     default_parser: CommitParser[ParseResult, ParserOptions],
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,
@@ -1052,7 +1030,6 @@ def test_version_print_next_tag_fails_on_detached_head(
     simulate_change_commits_n_rtn_changelog_entry: SimulateChangeCommitsNReturnChangelogEntryFn,
     get_commit_def_fn: GetCommitDefFn[CommitParser[ParseResult, ParserOptions]],
     default_parser: CommitParser[ParseResult, ParserOptions],
-    mocked_git_fetch: MagicMock,
     mocked_git_push: MagicMock,
     post_mocker: Mocker,
     strip_logging_messages: StripLoggingMessagesFn,

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/tests/e2e/cmd_version/test_version_upstream_check.py

@@ -291,6 +291,165 @@ def test_version_upstream_check_success_no_changes_untracked_branch(
     assert expected_vcs_url_post == post_mocker.call_count  # one vcs release created
 
 
+@pytest.mark.parametrize(
+    "repo_fixture_name, build_repo_fn",
+    [
+        (
+            repo_fixture_name,
+            lazy_fixture(build_repo_fn_name),
+        )
+        for repo_fixture_name, build_repo_fn_name in [
+            (
+                repo_w_trunk_only_conventional_commits.__name__,
+                build_trunk_only_repo_w_tags.__name__,
+            ),
+        ]
+    ],
+)
+@pytest.mark.usefixtures(change_to_ex_proj_dir.__name__)
+def test_version_no_upstream_check_on_no_version_commit(
+    repo_fixture_name: str,
+    run_cli: RunCliFn,
+    build_repo_fn: BuildSpecificRepoFn,
+    example_project_dir: ExProjectDir,
+    git_repo_for_directory: GetGitRepo4DirFn,
+    post_mocker: Mocker,
+    get_cfg_value_from_def: GetCfgValueFromDefFn,
+    get_versions_from_repo_build_def: GetVersionsFromRepoBuildDefFn,
+    pyproject_toml_file: Path,
+    update_pyproject_toml: UpdatePyprojectTomlFn,
+):
+    """
+    Test that PSR succeeds when no version commit is needed, so the upstream check is skipped.
+
+    This replicates the scenario that occurred on python-semantic-release/publish-action@v10.5.1
+    where the version command was run and no version commit was needed, but it failed because
+    it attempted to check the upstream branch anyway and we hard coded HEAD~1 because it expects
+    a version commit to be created. This is the only reason why you would check the upstream branch
+    because pushing a tag to the remote can happen even if the upstream branch has changed.
+    """
+    remote_name = "origin"
+    # Create a bare remote (simulating origin)
+    local_origin = Repo.init(str(example_project_dir / "local_origin"), bare=True)
+
+    # build target repo into a temporary directory
+    target_repo_dir = example_project_dir / repo_fixture_name
+    commit_type: CommitConvention = (
+        repo_fixture_name.split("commits", 1)[0].split("_")[-2]  # type: ignore[assignment]
+    )
+    target_repo_definition = build_repo_fn(
+        repo_name=repo_fixture_name,
+        commit_type=commit_type,
+        dest_dir=target_repo_dir,
+    )
+    target_git_repo = git_repo_for_directory(target_repo_dir)
+
+    # Configure the source repo to use the bare remote (removing any existing 'origin')
+    with contextlib.suppress(AttributeError):
+        target_git_repo.delete_remote(target_git_repo.remotes[remote_name])
+
+    target_git_repo.create_remote(remote_name, str(local_origin.working_dir))
+
+    # Remove last release before pushing to upstream
+    tag_format_str = cast(
+        "str", get_cfg_value_from_def(target_repo_definition, "tag_format_str")
+    )
+    latest_tag = tag_format_str.format(
+        version=get_versions_from_repo_build_def(target_repo_definition)[-1]
+    )
+    target_git_repo.git.tag("-d", latest_tag)
+    target_git_repo.git.reset("--hard", "HEAD~1")
+
+    # Remove any version variables to ensure no version commit is needed
+    update_pyproject_toml(
+        "tool.semantic_release.version_variables",
+        None,
+        target_repo_dir / pyproject_toml_file,
+    )
+    update_pyproject_toml(
+        "tool.semantic_release.version_toml",
+        None,
+        target_repo_dir / pyproject_toml_file,
+    )
+    # TODO: when available, switch this to use hvcs=none or similar config to avoid token use for push
+    update_pyproject_toml(
+        "tool.semantic_release.remote.ignore_token_for_push",
+        True,
+        target_repo_dir / pyproject_toml_file,
+    )
+    target_git_repo.git.commit(amend=True, no_edit=True, all=True)
+
+    # push the current state to establish the remote (cannot push tags and branches at the same time)
+    target_git_repo.git.push(remote_name, all=True)  # all branches
+    target_git_repo.git.push(remote_name, tags=True)  # all tags
+
+    # ensure bare remote HEAD points to the active branch so clones can checkout
+    local_origin.git.symbolic_ref(
+        "HEAD", f"refs/heads/{target_git_repo.active_branch.name}"
+    )
+
+    # Simulate CI environment after someone pushes to the repo
+    ci_commit_sha = target_git_repo.head.commit.hexsha
+    ci_branch = target_git_repo.active_branch.name
+
+    # current remote tags
+    remote_origin_tags_before = {tag.name for tag in local_origin.tags}
+
+    # Simulate a CI environment by fetching the repo to a new location
+    test_repo = Repo.init(str(example_project_dir / "ci_repo"))
+    with test_repo.config_writer("repository") as config:
+        config.set_value("core", "hookspath", "")
+        config.set_value("commit", "gpgsign", False)
+        config.set_value("tag", "gpgsign", False)
+
+    # Configure and retrieve the repository (see GitHub actions/checkout@v5)
+    test_repo.git.remote(
+        "add",
+        remote_name,
+        f"file:///{PureWindowsPath(local_origin.working_dir).as_posix()}",
+    )
+    test_repo.git.fetch("--depth=1", remote_name, ci_commit_sha)
+
+    # Simulate CI environment and recommended workflow (in docs)
+    # NOTE: this could be done in 1 step, but most CI pipelines are doing it in 2 steps
+    # 1. Checkout the commit sha (detached head)
+    test_repo.git.checkout(ci_commit_sha, force=True)
+    # 2. Forcefully set the branch to the current detached head
+    test_repo.git.checkout("-B", ci_branch)
+
+    # Act: run PSR on the cloned repo - it should verify upstream and succeed
+    with temporary_working_directory(str(test_repo.working_dir)):
+        # We don't use `--no-commit` here because we want to test that the upstream check is skipped
+        # when PSR determines that no version commit is needed. If we used `--no-commit`, it would skip the
+        # upstream check because it would think that a version commit was not needed.
+        cli_cmd = [
+            MAIN_PROG_NAME,
+            "--strict",
+            VERSION_SUBCMD,
+            "--no-changelog",
+            "--skip-build",
+        ]
+        result = run_cli(cli_cmd[1:], env={Github.DEFAULT_ENV_TOKEN_NAME: "1234"})
+
+    remote_origin_tags_after = {tag.name for tag in local_origin.tags}
+
+    # Evaluate
+    assert_successful_exit_code(result, cli_cmd)
+
+    # Verify release occurred as expected
+    with test_repo:
+        assert latest_tag in test_repo.tags, "Expected release tag to be created"
+        assert (
+            ci_commit_sha == test_repo.head.commit.hexsha
+        ), "Expected no new commit to be created on HEAD"
+        different_tags = remote_origin_tags_after.difference(remote_origin_tags_before)
+        assert latest_tag in different_tags, "Expected new tag to be pushed to remote"
+
+    # Verify VCS release was created
+    expected_vcs_url_post = 1
+    assert expected_vcs_url_post == post_mocker.call_count  # one vcs release created
+
+
 @pytest.mark.parametrize(
     "repo_fixture_name, build_repo_fn",
     [

{python_semantic_release-10.5.1 → python_semantic_release-10.5.3}/tests/fixtures/git_repo.py

@@ -142,6 +142,7 @@ if TYPE_CHECKING:
         sha: str
         datetime: NotRequired[DatetimeISOStr]
         include_in_changelog: bool
+        file_to_change: NotRequired[Path | str]
 
     class BaseRepoVersionDef(TypedDict):
         """A Common Repo definition for a get_commits_repo_*() fixture with all commit convention types"""
@@ -290,6 +291,7 @@ if TYPE_CHECKING:
         scipy: str
         datetime: NotRequired[DatetimeISOStr]
         include_in_changelog: NotRequired[bool]
+        file_to_change: NotRequired[Path | str]
 
     class DetailsBase(TypedDict):
         pre_actions: NotRequired[Sequence[RepoActions]]
@@ -1127,7 +1129,9 @@ def simulate_change_commits_n_rtn_changelog_entry(
         changelog_entries: list[CommitDef] = []
         for commit_msg in commit_msgs:
             if not git_repo.is_dirty(index=True, working_tree=False):
-                add_text_to_file(git_repo, file_in_repo)
+                add_text_to_file(
+                    git_repo, str(commit_msg.get("file_to_change", file_in_repo))
+                )
 
             changelog_entries.append(commit_n_rtn_changelog_entry(git_repo, commit_msg))
 
@@ -1336,39 +1340,6 @@ def configure_base_repo(  # noqa: C901
 
 @pytest.fixture(scope="session")
 def separate_squashed_commit_def() -> SeparateSquashedCommitDefFn:
-    # default_conventional_parser: ConventionalCommitParser,
-    # default_emoji_parser: EmojiCommitParser,
-    # default_scipy_parser: ScipyCommitParser,
-    # message_parsers: dict[
-    #     CommitConvention,
-    #     ConventionalCommitParser | EmojiCommitParser | ScipyCommitParser,
-    # ] = {
-    #     "conventional": ConventionalCommitParser(
-    #         options=ConventionalCommitParserOptions(
-    #             **{
-    #                 **default_conventional_parser.options.__dict__,
-    #                 "parse_squash_commits": True,
-    #             }
-    #         )
-    #     ),
-    #     "emoji": EmojiCommitParser(
-    #         options=EmojiParserOptions(
-    #             **{
-    #                 **default_emoji_parser.options.__dict__,
-    #                 "parse_squash_commits": True,
-    #             }
-    #         )
-    #     ),
-    #     "scipy": ScipyCommitParser(
-    #         options=ScipyParserOptions(
-    #             **{
-    #                 **default_scipy_parser.options.__dict__,
-    #                 "parse_squash_commits": True,
-    #             }
-    #         )
-    #     ),
-    # }
-
     def _separate_squashed_commit_def(
         squashed_commit_def: CommitDef,
         parser: SquashedCommitSupportedParser,
@@ -1435,7 +1406,7 @@ def convert_commit_spec_to_commit_def(
         )
 
         # Extract the correct commit message for the commit type
-        return {
+        commit_def: CommitDef = {
             **parse_msg_fn(commit_spec[commit_type], parser=parser),
             "cid": commit_spec["cid"],
             "datetime": (
@@ -1443,9 +1414,18 @@ def convert_commit_spec_to_commit_def(
                 if "datetime" in commit_spec
                 else stable_now_date.isoformat(timespec="seconds")
             ),
-            "include_in_changelog": (commit_spec.get("include_in_changelog", True)),
+            "include_in_changelog": commit_spec.get("include_in_changelog", True),
         }
 
+        if "file_to_change" in commit_spec:
+            commit_def.update(
+                {
+                    "file_to_change": commit_spec["file_to_change"],
+                }
+            )
+
+        return commit_def
+
     return _convert