test(cargo): add unit tests for cargo version updates

Author: Jannchie

tests/unit/test_version.py

@@ -10,6 +10,8 @@
     VersionArgs,
     VersionChoice,
     _apply_version_choice,
+    _find_cargo_lock_for,
+    _get_cargo_package_name,
     _get_default_bump_from_commits,
     _handle_explicit_version_args,
     _handle_interactive_version_selection,
@@ -37,6 +39,7 @@
     get_version_from_version_txt,
     handle_version,
     show_file_diff,
+    update_cargo_lock_version,
     update_cargo_toml_version,
     update_file,
     update_version_files,
@@ -941,6 +944,239 @@ def test_update_cargo_toml_version_file_not_exists(self, tmp_path):
         update_cargo_toml_version(non_existent_file, "1.0.0", 0, show_diff=False)
 
 
+class TestGetCargoPackageName:
+    """Test cases for _get_cargo_package_name."""
+
+    def test_basic(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nname = "arthash"\nversion = "0.2.0"\n')
+        assert _get_cargo_package_name(cargo_toml) == "arthash"
+
+    def test_missing_file(self, tmp_path):
+        assert _get_cargo_package_name(tmp_path / "Cargo.toml") is None
+
+    def test_missing_package_section(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[workspace]\nmembers = ["a"]\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_missing_name_key(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nversion = "0.1.0"\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_empty_name(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text('[package]\nname = ""\nversion = "0.1.0"\n')
+        assert _get_cargo_package_name(cargo_toml) is None
+
+    def test_invalid_toml(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text("this is not valid toml [[[")
+        assert _get_cargo_package_name(cargo_toml) is None
+
+
+class TestFindCargoLockFor:
+    """Test cases for _find_cargo_lock_for."""
+
+    def test_same_directory(self, tmp_path):
+        """Single-crate layout: Cargo.toml and Cargo.lock side-by-side."""
+        (tmp_path / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text("# lock\n")
+        assert _find_cargo_lock_for(tmp_path) == lockfile
+
+    def test_parent_directory(self, tmp_path):
+        """Workspace layout: lockfile lives at workspace root."""
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text("# lock\n")
+        member = tmp_path / "crates" / "alpha"
+        member.mkdir(parents=True)
+        (member / "Cargo.toml").write_text('[package]\nname = "alpha"\nversion = "0.1.0"\n')
+        assert _find_cargo_lock_for(member) == lockfile
+
+    def test_no_lockfile_returns_none(self, tmp_path):
+        (tmp_path / ".git").mkdir()
+        crate = tmp_path / "crate"
+        crate.mkdir()
+        (crate / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        assert _find_cargo_lock_for(crate) is None
+
+    def test_stops_at_git_root(self, tmp_path):
+        """Must not escape the current repo, even if an outer Cargo.lock exists."""
+        outer_lock = tmp_path / "Cargo.lock"
+        outer_lock.write_text("# outer\n")
+        repo = tmp_path / "inner_repo"
+        repo.mkdir()
+        (repo / ".git").mkdir()
+        crate = repo / "crate"
+        crate.mkdir()
+        (crate / "Cargo.toml").write_text('[package]\nname = "x"\nversion = "0.1.0"\n')
+        # Should NOT find the outer Cargo.lock — that's in a different repo.
+        assert _find_cargo_lock_for(crate) is None
+
+
+class TestUpdateCargoLockVersion:
+    """Test cases for update_cargo_lock_version."""
+
+    @staticmethod
+    def _make_lockfile(tmp_path: Path, content: str) -> Path:
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(content, encoding="utf-8")
+        return lockfile
+
+    def test_local_crate_version_updated(self, tmp_path):
+        """Workspace member (no source field) gets its version rewritten."""
+        content = (
+            "# This file is automatically @generated by Cargo.\n"
+            "version = 4\n\n"
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n"
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        new_content = lockfile.read_text()
+        assert 'version = "0.3.0"' in new_content
+        assert 'version = "0.2.0"' not in new_content
+
+    def test_registry_dep_with_same_name_not_touched(self, tmp_path):
+        """A registry dep named identically to the local crate must NOT be hit.
+
+        Registry entries have `source = "registry+..."` between `name` and
+        `version`, so they fail the "name immediately followed by version"
+        anchor. Local crates fit the anchor exactly.
+        """
+        content = (
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'source = "registry+https://github.com/rust-lang/crates.io-index"\n'
+            'version = "9.9.9"\n'
+            'checksum = "deadbeef"\n\n'
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n"
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        new_content = lockfile.read_text()
+        # registry entry untouched
+        assert 'version = "9.9.9"' in new_content
+        # local entry bumped
+        assert 'version = "0.3.0"' in new_content
+        # only one occurrence of the new version (didn't accidentally double-write)
+        assert new_content.count('version = "0.3.0"') == 1
+
+    def test_crate_not_in_lockfile_is_noop(self, tmp_path):
+        """If the crate isn't recorded, nothing changes."""
+        content = (
+            "[[package]]\n"
+            'name = "other"\n'
+            'version = "1.0.0"\n'
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        assert lockfile.read_text() == content
+
+    def test_missing_lockfile_is_noop(self, tmp_path):
+        """Pure non-Rust projects don't have a Cargo.lock — must not error."""
+        lockfile = tmp_path / "Cargo.lock"
+        # Should not raise.
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        assert not lockfile.exists()
+
+    def test_already_in_sync_is_noop(self, tmp_path):
+        """Idempotent: same version in -> file unchanged."""
+        content = (
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.3.0"\n'
+        )
+        lockfile = self._make_lockfile(tmp_path, content)
+        before = lockfile.stat().st_mtime_ns
+        update_cargo_lock_version("arthash", "0.3.0", lockfile, 0, show_diff=False)
+        # Content identical; we explicitly skip the write in that case.
+        assert lockfile.read_text() == content
+        # And the file was not rewritten (mtime preserved). Some filesystems
+        # have coarse mtime resolution, so this guard is a tightening only —
+        # the content check above is the real assertion.
+        assert lockfile.stat().st_mtime_ns == before
+
+
+class TestUpdateVersionInFileCargoIntegration:
+    """update_version_in_file should sync Cargo.lock when it sees Cargo.toml."""
+
+    def test_cargo_toml_branch_syncs_sibling_lockfile(self, tmp_path):
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "\n"
+            "[dependencies]\n"
+            'matrixmultiply = "0.3"\n',
+            encoding="utf-8",
+        )
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(
+            "[[package]]\n"
+            'name = "arthash"\n'
+            'version = "0.2.0"\n'
+            "dependencies = [\n"
+            ' "matrixmultiply",\n'
+            "]\n",
+            encoding="utf-8",
+        )
+        update_version_in_file(0, "0.3.0", "Cargo.toml", cargo_toml, show_diff=False)
+        # Both files should now report 0.3.0.
+        assert 'version = "0.3.0"' in cargo_toml.read_text()
+        assert 'version = "0.3.0"' in lockfile.read_text()
+
+    def test_cargo_toml_branch_syncs_workspace_root_lockfile(self, tmp_path):
+        """Lockfile in workspace root, Cargo.toml in a member directory."""
+        (tmp_path / ".git").mkdir()
+        lockfile = tmp_path / "Cargo.lock"
+        lockfile.write_text(
+            "[[package]]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        member_dir = tmp_path / "crates" / "alpha"
+        member_dir.mkdir(parents=True)
+        cargo_toml = member_dir / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        update_version_in_file(0, "0.3.0", "Cargo.toml", cargo_toml, show_diff=False)
+        assert 'version = "0.3.0"' in cargo_toml.read_text()
+        assert 'version = "0.3.0"' in lockfile.read_text()
+
+    def test_cargo_toml_branch_no_lockfile_present(self, tmp_path):
+        """When there's no lockfile at all, the manifest update still proceeds."""
+        (tmp_path / ".git").mkdir()
+        cargo_toml = tmp_path / "Cargo.toml"
+        cargo_toml.write_text(
+            "[package]\n"
+            'name = "alpha"\n'
+            'version = "0.2.0"\n',
+            encoding="utf-8",
+        )
+        # Should not raise.
+        update_version_in_file(0, "0.3.0", "Cargo.toml", cargo_toml, show_diff=False)
+        assert 'version = "0.3.0"' in cargo_toml.read_text()
+
+
 class TestParseGitignore:
     """Test cases for _parse_gitignore function."""
 

tgit/version.py

@@ -875,7 +875,18 @@ def update_version_in_file(verbose: int, next_version_str: str, file: str, file_
     elif file == "setup.py":
         update_file(str(file_path), r"version=['\"].*?['\"]", f"version='{next_version_str}'", verbose, show_diff=show_diff)
     elif file == "Cargo.toml":
+        crate_name = _get_cargo_package_name(file_path)
         update_cargo_toml_version(str(file_path), next_version_str, verbose, show_diff=show_diff)
+        # Cargo.lock pins every workspace member's version. Without
+        # syncing it here, `cargo publish` and `cargo build --locked`
+        # refuse to run against a manifest that disagrees with the
+        # lockfile — the most common reason a release tag gets bumped
+        # but the publish CI step fails on "working directory contains
+        # changes". Idempotent / no-op for pure non-Rust projects.
+        if crate_name:
+            lockfile = _find_cargo_lock_for(file_path.parent)
+            if lockfile is not None:
+                update_cargo_lock_version(crate_name, next_version_str, lockfile, verbose, show_diff=show_diff)
     elif file in ("VERSION", "VERSION.txt"):
         update_file(str(file_path), None, next_version_str, verbose, show_diff=show_diff)
     elif file in ("__about__.py", "__init__.py"):
@@ -958,6 +969,82 @@ def replace_version(match: re.Match[str]) -> str:
         f.write(new_content)
 
 
+def _get_cargo_package_name(cargo_toml_path: Path) -> str | None:
+    """Read [package].name from a Cargo.toml. Returns None if missing/invalid.
+
+    Used to anchor lockfile rewrites — we need the crate's own name to
+    find its entry in Cargo.lock.
+    """
+    if not cargo_toml_path.is_file():
+        return None
+    try:
+        with cargo_toml_path.open("rb") as f:
+            data = tomllib.load(f)
+    except (OSError, tomllib.TOMLDecodeError):
+        return None
+    package = data.get("package")
+    if not isinstance(package, dict):
+        return None
+    name = package.get("name")
+    return name if isinstance(name, str) and name else None
+
+
+def _find_cargo_lock_for(cargo_toml_dir: Path) -> Path | None:
+    """Walk up from a Cargo.toml's directory looking for a Cargo.lock.
+
+    Covers both layouts:
+      * single crate with its own Cargo.lock (lockfile in same dir)
+      * cargo workspace where members share a root-level Cargo.lock
+
+    Stops at the directory containing .git (we never escape the current
+    repo) or at the filesystem root.
+    """
+    current = cargo_toml_dir.resolve()
+    while True:
+        candidate = current / "Cargo.lock"
+        if candidate.is_file():
+            return candidate
+        if (current / ".git").exists():
+            return None
+        if current.parent == current:
+            return None
+        current = current.parent
+
+
+def update_cargo_lock_version(
+    crate_name: str,
+    next_version_str: str,
+    lockfile_path: Path,
+    verbose: int,
+    *,
+    show_diff: bool = True,
+) -> None:
+    """Sync a local crate's version in Cargo.lock.
+
+    Cargo.lock records every dep, but registry deps carry a
+    `source = "registry+..."` line between `name` and `version`.
+    Workspace members / path deps do NOT — their `version` is on the
+    line immediately after `name`. We anchor on that two-line shape so
+    registry deps with the same name as a local crate can't be hit by
+    mistake. No-op if the crate isn't in this lockfile or is already
+    in sync.
+    """
+    if not lockfile_path.is_file():
+        return
+    if verbose > 0:
+        console.print(f"Updating {lockfile_path}")
+    content = lockfile_path.read_text(encoding="utf-8")
+    pattern = re.compile(
+        rf'(\[\[package\]\]\nname = "{re.escape(crate_name)}"\nversion = ")[^"]+(")',
+    )
+    new_content, n = pattern.subn(rf"\g<1>{next_version_str}\g<2>", content, count=1)
+    if n == 0 or new_content == content:
+        return
+    if show_diff:
+        show_file_diff(content, new_content, str(lockfile_path))
+    lockfile_path.write_text(new_content, encoding="utf-8")
+
+
 def show_file_diff(old_content: str, new_content: str, filename: str) -> None:
     old_lines = old_content.splitlines()
     new_lines = new_content.splitlines()