gitacross 2.3.0__tar.gz → 2.3.1__tar.gz

{gitacross-2.3.0/src/gitacross.egg-info → gitacross-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.3.0
+Version: 2.3.1
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -443,7 +443,7 @@ GitAcross can be driven from the command line or called directly from Python.
 ### CLI
 
 ```
-gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--lint] [--fix] [-v]
+gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--clean-cache] [--lint] [--fix] [-v]
 ```
 
 | Flag | Description |
@@ -453,6 +453,7 @@ gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--re
 | `--workdir PATH` | Where state and cache live (default: `.gitsync`) |
 | `--dry-run` | Preview changes without committing or pushing |
 | `--reset` | Clear saved state and cache before running (fresh start) |
+| `--clean-cache` | Delete mirror caches no longer referenced by the config (e.g. after changing a repo's host or name in the config) |
 | `--lint` | Check the config for YAML errors, invalid settings, and redundant options |
 | `--fix` | Fix misplaced keys and remove redundant options in the config |
 | `-v, --verbose` | Debug logging |

{gitacross-2.3.0 → gitacross-2.3.1}/README.md

@@ -414,7 +414,7 @@ GitAcross can be driven from the command line or called directly from Python.
 ### CLI
 
 ```
-gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--lint] [--fix] [-v]
+gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--clean-cache] [--lint] [--fix] [-v]
 ```
 
 | Flag | Description |
@@ -424,6 +424,7 @@ gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--re
 | `--workdir PATH` | Where state and cache live (default: `.gitsync`) |
 | `--dry-run` | Preview changes without committing or pushing |
 | `--reset` | Clear saved state and cache before running (fresh start) |
+| `--clean-cache` | Delete mirror caches no longer referenced by the config (e.g. after changing a repo's host or name in the config) |
 | `--lint` | Check the config for YAML errors, invalid settings, and redundant options |
 | `--fix` | Fix misplaced keys and remove redundant options in the config |
 | `-v, --verbose` | Debug logging |

{gitacross-2.3.0 → gitacross-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitacross"
-version = "2.3.0"
+version = "2.3.1"
 description = "Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines."
 readme = "README.md"
 requires-python = ">=3.8"

{gitacross-2.3.0 → gitacross-2.3.1}/src/gitacross/cli.py

@@ -50,6 +50,11 @@ def main():
         default=DEFAULT_WORK_DIR,
         help="Directory for state.yml and cache/ (default: .gitsync)",
     )
+    _ = parser.add_argument(
+        "--clean-cache",
+        action="store_true",
+        help="Delete mirror caches no longer referenced by the config",
+    )
     _ = parser.add_argument("-v", "--verbose", action="store_true", help="Debug logging")
     args = parser.parse_args()
 
@@ -62,6 +67,7 @@ def main():
     dry_run_flag = cast(bool, args.dry_run)
     reset_flag = cast(bool, args.reset)
     workdir = cast(str, args.workdir)
+    clean_cache_flag = cast(bool, args.clean_cache)
 
     _setup_logging(verbose)
 
@@ -96,6 +102,7 @@ def main():
             dry_run=dry_run_flag,
             reset=reset_flag,
             work_dir=workdir,
+            clean_cache=clean_cache_flag,
         )
     except (FileNotFoundError, ValueError) as exc:
         sys.exit(str(exc))

{gitacross-2.3.0 → gitacross-2.3.1}/src/gitacross/config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hashlib
 import logging
 import os
 from pathlib import Path
@@ -170,6 +171,41 @@ class _EndpointConfig:
         """Filesystem-safe repo identifier (``owner/name`` → ``owner_name``)."""
         return self.repo.replace("/", "_")
 
+    @property
+    def host(self):
+        """Git host for a remote endpoint.
+
+        GitHub's API lives at api.github.com, but its git host is github.com.
+        Gitea's API typically lives on the same host as git, so no transform is
+        needed there. Returns "" when no ``api`` is configured.
+        """
+        if not self.api:
+            return ""
+        raw_host = self.api.split("://")[1].split("/")[0] if "://" in self.api else self.api
+        return "github.com" if raw_host == "api.github.com" else raw_host
+
+    @property
+    def host_slug(self):
+        """Filesystem-safe host identifier for cache paths.
+
+        Keeps dots and hyphens (so e.g. ``my.host.com`` and ``my-host.com`` stay
+        distinct); only the port separator and any slashes become underscores.
+        """
+        return self.host.lower().replace(":", "_").replace("/", "_")
+
+    def mirror_dir_name(self, role):
+        """Deterministic, collision-resistant cache directory name for a remote endpoint.
+
+        Mirrors persist between runs — that is what makes them a cache — so the
+        name must be a pure function of the endpoint identity, never random.
+        Separator-based slugs alone can still collide (e.g. ``a/b_c`` and
+        ``a_b/c`` on the same host), so a short hash of the full identity
+        (role, type, host, repo) is appended to the readable prefix.
+        """
+        identity = "\0".join([role, self.type, self.host.lower(), self.repo])
+        digest = hashlib.sha1(identity.encode("utf-8")).hexdigest()[:10]
+        return f"{role}_{self.type}_{self.host_slug}_{self.repo_slug}_{digest}.git"
+
     @property
     def owner(self):
         return self.repo.split("/")[0] if "/" in self.repo else ""
@@ -179,11 +215,7 @@ class _EndpointConfig:
         """HTTPS clone URL with token embedded for auth."""
         if not self.api or not self.repo:
             return ""
-        raw_host = self.api.split("://")[1].split("/")[0] if "://" in self.api else self.api
-        # GitHub's API lives at api.github.com, but its git host is github.com.
-        # Gitea's API typically lives on the same host as git, so no transform needed.
-        host = "github.com" if raw_host == "api.github.com" else raw_host
-        return f"https://{self.owner}:{self.token}@{host}/{self.repo}.git"
+        return f"https://{self.owner}:{self.token}@{self.host}/{self.repo}.git"
 
 
 @final

{gitacross-2.3.0 → gitacross-2.3.1}/src/gitacross/git.py

@@ -196,6 +196,11 @@ class GitRepo:
             )
         p.mkdir(parents=True, exist_ok=True)
         _ = _git("init", str(p))
+        # Give a fresh repo a repo-local identity so commits never depend on
+        # the ambient git config (mirrors get the same treatment in
+        # ensure_mirror). Existing repos are opened as-is and left untouched.
+        _ = _git("-C", str(p), "config", "user.name", "GitAcross")
+        _ = _git("-C", str(p), "config", "user.email", "sync@gitacross")
         logger.info("Initialised git repository at %s", p)
         return cls.local(path)
 

{gitacross-2.3.0 → gitacross-2.3.1}/src/gitacross/main.py

@@ -446,6 +446,7 @@ def run(
     dry_run: bool = False,
     reset: bool = False,
     work_dir: str | Path = DEFAULT_WORK_DIR,
+    clean_cache: bool = False,
 ):
     """Sync releases from a config — the primary Python API entry point.
 
@@ -469,6 +470,14 @@ def run(
             syncing so that all releases are treated as new.
         work_dir:    Directory path for ``state.yml`` and ``cache/``.
             Defaults to ``.gitsync``.
+        clean_cache: When ``True``, delete bare mirror clones under
+            ``work_dir/cache/`` that no endpoint in the config references
+            anymore (e.g. after the config changed hosts or repos). Mirrors are
+            disposable clones, so this only ever costs a re-clone. Skipped in
+            dry-run mode. Note: mirrors are identified per config, so if
+            multiple config files share one ``work_dir``, run them with the
+            same ``clean_cache`` setting to avoid deleting each other's
+            mirrors.
 
     Returns:
         A list of dicts — one per enabled project that was attempted — with
@@ -522,6 +531,9 @@ def run(
     if project_name and not projects:
         raise ValueError(f"Project '{project_name}' not found in config")
 
+    if clean_cache and not dry_run and not reset:
+        _clean_mirror_cache(work_dir, config)
+
     results = []
     for proj in projects:
         if not proj.enabled:
@@ -552,6 +564,42 @@ def run(
     return results
 
 
+def _clean_mirror_cache(work_dir: str | Path, config: Config) -> None:
+    """Delete mirror clones under ``work_dir/cache/`` not referenced by *config*.
+
+    Cache keys are deterministic identity names (role, type, host, repo), so a
+    config edit that changes any of those orphans the previous mirror. Orphans
+    are harmless but waste disk, so this removes them. The reference set is
+    built from *every* project in the config — enabled or not — and remote
+    endpoints only, so running a project subset or re-enabling a disabled
+    project never deletes a mirror it still needs.
+    """
+    cache_dir = Path(work_dir) / "cache"
+    if not cache_dir.is_dir():
+        return
+    referenced = {
+        endpoint.mirror_dir_name(role)
+        for proj in config.projects
+        for endpoint, role in ((proj.source, "source"), (proj.target, "target"))
+        if endpoint.is_remote
+    }
+    removed = []
+    for child in sorted(cache_dir.iterdir()):
+        if (
+            child.is_dir()
+            and child.name.endswith(".git")
+            and child.name not in referenced
+        ):
+            shutil.rmtree(child, ignore_errors=True)
+            removed.append(child.name)
+    if removed:
+        logger.info(
+            "Removed %d stale mirror cache(s): %s",
+            len(removed),
+            ", ".join(removed),
+        )
+
+
 
 
 # Imported at the bottom to avoid a circular import (cli.py imports .main.run).

{gitacross-2.3.0 → gitacross-2.3.1}/src/gitacross/source.py

@@ -64,7 +64,7 @@ class _RemoteSource:
         self._api.ensure_repo_exists(create=not dry_run)
         self._git = GitRepo.ensure_mirror(
             config.clone_url,
-            Path(cache_dir) / f"source_{config.type}_{config.repo_slug}.git",
+            Path(cache_dir) / config.mirror_dir_name("source"),
         )
         self._include_prereleases = config.include_prereleases
         self._include_drafts = config.include_drafts

{gitacross-2.3.0 → gitacross-2.3.1}/src/gitacross/state.py

@@ -26,11 +26,24 @@ class State:
         return f"State(work_dir={str(self.work_dir)!r})"
 
     def _load(self):
+        data = {}
         if self.path.exists():
             with open(self.path) as f:
-                data = yaml.safe_load(f) or {}
-        else:
+                data = yaml.safe_load(f)
+        # Tolerate degenerate or hand-edited YAML (e.g. a bare ``projects:``
+        # key with no value, non-map documents, or null entries) so a corrupt
+        # state file can never crash a run — it is simply treated as empty.
+        if not isinstance(data, dict):
             data = {}
+        projects = data.get("projects")
+        if not isinstance(projects, dict):
+            projects = {}
+            data["projects"] = projects
+        for name, project in list(projects.items()):
+            if not isinstance(project, dict):
+                projects[name] = {}
+            elif not isinstance(project.get("releases"), dict):
+                project["releases"] = {}
         return data
 
     def has_release(self, project_name, tag_name):

{gitacross-2.3.0 → gitacross-2.3.1}/src/gitacross/target.py

@@ -58,7 +58,7 @@ class _RemoteTarget:
             )
         self._git = GitRepo.ensure_mirror(
             clone_url,
-            Path(cache_dir) / f"target_{config.type}_{config.repo_slug}.git",
+            Path(cache_dir) / config.mirror_dir_name("target"),
         )
         self._retry_max = retry_max
         self._retry_backoff = retry_backoff

{gitacross-2.3.0 → gitacross-2.3.1/src/gitacross.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitacross
-Version: 2.3.0
+Version: 2.3.1
 Summary: Mirror releases and git commits across platforms (Gitea, GitHub, local) with transform pipelines.
 Author: Matthew Deik
 License-Expression: MIT
@@ -443,7 +443,7 @@ GitAcross can be driven from the command line or called directly from Python.
 ### CLI
 
 ```
-gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--lint] [--fix] [-v]
+gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--reset] [--clean-cache] [--lint] [--fix] [-v]
 ```
 
 | Flag | Description |
@@ -453,6 +453,7 @@ gitacross --config PATH [--project-name NAME] [--workdir PATH] [--dry-run] [--re
 | `--workdir PATH` | Where state and cache live (default: `.gitsync`) |
 | `--dry-run` | Preview changes without committing or pushing |
 | `--reset` | Clear saved state and cache before running (fresh start) |
+| `--clean-cache` | Delete mirror caches no longer referenced by the config (e.g. after changing a repo's host or name in the config) |
 | `--lint` | Check the config for YAML errors, invalid settings, and redundant options |
 | `--fix` | Fix misplaced keys and remove redundant options in the config |
 | `-v, --verbose` | Debug logging |

{gitacross-2.3.0 → gitacross-2.3.1}/tests/test_config.py

@@ -73,6 +73,85 @@ projects:
         os.unlink(config_path)
 
 
+def test_endpoint_host_and_host_slug():
+    """host/host_slug identify the git host and stay filesystem-safe."""
+    from gitacross.config import _EndpointConfig
+
+    gitea = _EndpointConfig(
+        {"type": "gitea", "repo": "a/b", "api": "https://git.nodebay.top/api/v1"},
+        is_source=True,
+    )
+    assert gitea.host == "git.nodebay.top"
+    assert gitea.host_slug == "git.nodebay.top"
+
+    # GitHub's API host maps to its git host
+    gh = _EndpointConfig(
+        {"type": "github", "repo": "a/b", "api": "https://api.github.com"},
+        is_source=True,
+    )
+    assert gh.host == "github.com"
+    assert gh.host_slug == "github.com"
+
+    # Ports are kept in the slug so hosts differing only by port stay distinct
+    port = _EndpointConfig(
+        {"type": "gitea", "repo": "a/b", "api": "https://git.nodebay.top:8443/api/v1"},
+        is_source=True,
+    )
+    assert port.host_slug == "git.nodebay.top_8443"
+
+    # Dots vs hyphens are NOT collapsed into the same slug
+    assert (
+        _EndpointConfig({"api": "https://my.host.com"}, is_source=True).host_slug
+        == "my.host.com"
+    )
+    assert (
+        _EndpointConfig({"api": "https://my-host.com"}, is_source=True).host_slug
+        == "my-host.com"
+    )
+
+    # No api configured -> empty host
+    assert _EndpointConfig({"api": ""}, is_source=True).host == ""
+    print("  ✓ config: endpoint host / host_slug")
+
+
+def test_mirror_dir_name_deterministic_and_unique():
+    """mirror_dir_name is deterministic across runs and collision-resistant."""
+    import re
+
+    from gitacross.config import _EndpointConfig
+
+    def name(repo, api="https://git.nodebay.top/api/v1", kind="gitea", role="source"):
+        raw = {"type": kind, "repo": repo, "api": api}
+        return _EndpointConfig(raw, is_source=True).mirror_dir_name(role)
+
+    # Deterministic: same identity always yields the same cache name
+    assert name("uqkami/Awara") == name("uqkami/Awara")
+
+    # Role is part of the identity (source vs target never share a mirror)
+    assert name("uqkami/Awara", role="target") != name("uqkami/Awara", role="source")
+
+    # Readable prefix + a short hex digest before the .git suffix
+    n = name("uqkami/Awara")
+    assert n.startswith("source_gitea_git.nodebay.top_uqkami_Awara_")
+    digest = n.rsplit("_", 1)[1]
+    assert re.fullmatch(r"[0-9a-f]{10}\.git", digest)
+
+    # Slug-ambiguous owner/repo pairs must never share a mirror
+    assert name("a/b_c") != name("a_b/c")
+
+    # Host case differences resolve to the same host -> same cache (dedup)
+    upper = _EndpointConfig(
+        {"type": "gitea", "repo": "a/b", "api": "https://GIT.NODEBAY.TOP/api/v1"},
+        is_source=True,
+    ).mirror_dir_name("source")
+    assert upper == name("a/b")
+
+    # Different hosts or ports stay distinct
+    assert name("a/b", api="https://git.nodebay.top:8443/api/v1") != name("a/b")
+    assert name("a/b", api="https://gitea.example.com/api/v1") != name("a/b")
+    print("  ✓ config: mirror_dir_name is deterministic and collision-resistant")
+
+
 def test_config_local():
     from gitacross.config import Config
 

{gitacross-2.3.0 → gitacross-2.3.1}/tests/test_git.py

@@ -276,6 +276,41 @@ def test_git_mirror_instance_commands_whitelisted_but_not_local():
         assert not any("safe.directory" in a for a in local_cmd)
     print("  ✓ git: mirror commands whitelisted, local repos left strict")
 
+
+def test_git_ensure_local_new_repo_commits_without_ambient_identity(monkeypatch):
+    """Auto-initialised repos carry a repo-local identity, so commits never
+    depend on the ambient git config.
+
+    Regression: fresh ensure_local repos had no identity configured, so commits
+    failed with exit 128 ("Please tell me who you are") on machines without a
+    global git user.name/email.
+    """
+    from gitacross.git import GitRepo
+
+    # Strip all ambient identity: only repo-local config may be used
+    monkeypatch.setenv("GIT_CONFIG_GLOBAL", "/dev/null")
+    monkeypatch.setenv("GIT_CONFIG_SYSTEM", "/dev/null")
+    for var in (
+        "GIT_AUTHOR_NAME",
+        "GIT_AUTHOR_EMAIL",
+        "GIT_COMMITTER_NAME",
+        "GIT_COMMITTER_EMAIL",
+    ):
+        monkeypatch.delenv(var, raising=False)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        repo = Path(tmp) / "repo"
+        git = GitRepo.ensure_local(repo)
+        git.ensure_branch("main")
+
+        work = Path(tmp) / "work"
+        work.mkdir()
+        _ = _make_file(work, "f.txt", "hello")
+        result = git.commit(work, "Release v1.0")
+        assert result.returncode in (0, 1)
+        assert git.head_sha()
+    print("  ✓ git: auto-initialised repos commit without ambient identity")
+
 def test_git_reset_worktree_bare_noop():
     """reset_worktree is a no-op for bare repos — HEAD must stay untouched."""
     from gitacross.git import GitRepo

{gitacross-2.3.0 → gitacross-2.3.1}/tests/test_source.py

@@ -718,6 +718,95 @@ def test_remote_source_duck_typed_helpers():
     mock_api.list_release_assets.assert_called_with(7)
     print("  ✓ source: remote passthrough helpers delegate correctly")
 
+
+def test_remote_source_cache_separates_hosts():
+    """Same-named repos on different hosts must not share a mirror cache dir.
+
+    Regression: mirror names only encoded type + owner/repo, so two hosts with
+    the same repo slug collided — the shared mirror flipped origin and re-fetched
+    between projects, dirtying each other's cache.
+    """
+    from gitacross.config import _EndpointConfig
+    from gitacross.source import create_source
+
+    calls = []
+
+    def fake_ensure_mirror(url, dest):
+        calls.append((url, dest))
+        return mock.MagicMock()
+
+    host_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "t"},
+        is_source=True,
+    )
+    host_b = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://gitea.example.com/api/v1", "token": "t"},
+        is_source=True,
+    )
+    same_as_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "other-token"},
+        is_source=True,
+    )
+
+    mock_apis = [mock.MagicMock() for _ in range(3)]
+    with mock.patch(
+        "gitacross.source.get_api_client", side_effect=mock_apis
+    ), mock.patch(
+        "gitacross.git.GitRepo.ensure_mirror", side_effect=fake_ensure_mirror
+    ):
+        _ = create_source(host_a, "cache")
+        _ = create_source(host_b, "cache")
+        _ = create_source(same_as_a, "cache")
+
+    dest_a, dest_b, dest_same = (Path(d) for _, d in calls)
+    for d in (dest_a, dest_b):
+        assert str(d).endswith(".git")
+    assert "source_gitea_git.nodebay.top_uqkami_Awara_" in str(dest_a)
+    assert "source_gitea_gitea.example.com_uqkami_Awara_" in str(dest_b)
+    # Different hosts -> separate mirrors; same host (any token) -> shared mirror
+    assert dest_a != dest_b
+    assert dest_a == dest_same
+    print("  ✓ source: remote source cache dirs are separated per host")
+
+
+def test_remote_source_cache_hash_kills_slug_collisions():
+    """Slug-ambiguous repos (a/b_c vs a_b/c) on one host never share a mirror."""
+    from gitacross.config import _EndpointConfig
+    from gitacross.source import create_source
+
+    calls = []
+
+    def fake_ensure_mirror(url, dest):
+        calls.append((url, dest))
+        return mock.MagicMock()
+
+    def cfg(repo):
+        return _EndpointConfig(
+            {"type": "gitea", "repo": repo,
+             "api": "https://git.nodebay.top/api/v1", "token": "t"},
+            is_source=True,
+        )
+
+    mock_apis = [mock.MagicMock() for _ in range(2)]
+    with mock.patch(
+        "gitacross.source.get_api_client", side_effect=mock_apis
+    ), mock.patch(
+        "gitacross.git.GitRepo.ensure_mirror", side_effect=fake_ensure_mirror
+    ):
+        _ = create_source(cfg("a/b_c"), "cache")
+        _ = create_source(cfg("a_b/c"), "cache")
+
+    dest1, dest2 = (Path(d) for _, d in calls)
+    # Both have the same readable slug prefix (a_b_c), but the identity hashes
+    # differ, so they resolve to distinct mirror dirs
+    assert dest1 != dest2
+    assert "a_b_c_" in str(dest1)
+    assert "a_b_c_" in str(dest2)
+    print("  ✓ source: slug collisions resolve to distinct cache dirs")
+
 def test_local_source_duck_typed_helpers():
     from gitacross.config import _EndpointConfig
     from gitacross.source import create_source

{gitacross-2.3.0 → gitacross-2.3.1}/tests/test_state.py

@@ -74,4 +74,37 @@ def test_state():
         print("  ✓ state persistence")
 
 
+def test_state_tolerates_degenerate_yaml():
+    """A corrupt or hand-edited state file must never crash a run.
+
+    Regression: a state.yml containing only ``projects:`` parses to
+    ``{"projects": None}``, which crashed has_release with an AttributeError.
+    """
+    from gitacross.state import State
+
+    degenerate = [
+        "projects:\n",  # bare key, no value (the reported crash)
+        "projects: []\n",  # list instead of map
+        "[]\n",  # scalar document
+        "projects:\n  myapp:\n",  # null project entry
+        "projects:\n  myapp:\n    releases:\n",  # null releases entry
+        "",  # empty file
+    ]
+    for i, content in enumerate(degenerate):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "state.yml"
+            _ = path.write_text(content)
+            state = State(tmp)
+            assert not state.has_release("myapp", "v1.0"), f"case {i}: {content!r}"
+            state.add_release(
+                "myapp",
+                "v1.0",
+                {"tag": "v1.0", "target_commit": "x"},
+            )
+            state.save()
+            # Round-trip: the release is now visible and nothing else crashes
+            assert State(tmp).has_release("myapp", "v1.0"), f"case {i}: {content!r}"
+    print("  ✓ state: degenerate state.yml is treated as empty, never crashes")
+
+
 

{gitacross-2.3.0 → gitacross-2.3.1}/tests/test_sync_api.py

@@ -363,6 +363,106 @@ def test_run_git_missing_reports_clear_error(monkeypatch):
     print("  ✓ run: missing git binary surfaces a clear error message")
 
 
+def test_run_clean_cache_removes_orphaned_mirrors():
+    """clean_cache deletes mirrors no config endpoint references — nothing else."""
+    import gitacross
+
+    from gitacross.config import Config
+
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        cfg_path = tmp / "config.yml"
+        _ = cfg_path.write_text("""
+projects:
+  - name: proj-a
+    source:
+      type: gitea
+      repo: owner/repo
+      api: https://git.nodebay.top/api/v1
+      token: t
+    target:
+      type: local
+      path: /tmp/tgt-a
+  - name: proj-disabled
+    enabled: false
+    source:
+      type: gitea
+      repo: owner/old
+      api: https://gitea.example.com/api/v1
+      token: t
+    target:
+      type: local
+      path: /tmp/tgt-b
+""")
+        cfg = Config(str(cfg_path))
+        referenced = cfg.projects[0].source.mirror_dir_name("source")
+        disabled_ref = cfg.projects[1].source.mirror_dir_name("source")
+        wd = tmp / "workdir"
+
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            # (a) no cache dir yet -> clean-cache is a safe no-op
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+
+            # Build a cache with referenced + orphaned mirrors and junk
+            cache = wd / "cache"
+            (cache / referenced).mkdir(parents=True)
+            (cache / disabled_ref).mkdir()
+            orphan1 = cache / "source_gitea_git.nodebay.top_owner_old_aaaa.git"
+            orphan2 = cache / "target_github_github.com_owner_repo_bbbb.git"
+            orphan1.mkdir()
+            orphan2.mkdir()
+            (cache / "notes.txt").write_text("junk")
+            (cache / "not-a-mirror").mkdir()
+
+            # (b) orphans removed; referenced / disabled-project / junk survive
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+
+        assert not orphan1.exists()
+        assert not orphan2.exists()
+        assert (cache / referenced).is_dir()
+        assert (cache / disabled_ref).is_dir()
+        assert (cache / "notes.txt").read_text() == "junk"
+        assert (cache / "not-a-mirror").is_dir()
+
+        # (c) dry-run never deletes anything
+        (cache / "fresh_orphan_cccc.git").mkdir()
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True, dry_run=True)
+        assert (cache / "fresh_orphan_cccc.git").is_dir()
+
+        # (d) a second clean run removes it; (e) a third has nothing left to do
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+        assert not (cache / "fresh_orphan_cccc.git").exists()
+        with mock.patch("gitacross.main.sync_project", return_value=[]):
+            _ = gitacross.run(cfg, work_dir=wd, clean_cache=True)
+    print("  ✓ run: clean_cache removes only unreferenced mirrors")
+
+
+def test_main_clean_cache_flag_passed_to_run():
+    """CLI --clean-cache is forwarded to run()."""
+    from gitacross.cli import main
+
+    with tempfile.TemporaryDirectory() as tmp:
+        cfg = Path(tmp) / "config.yml"
+        _write_local_config(cfg, [{"name": "proj-cli"}])
+        captured = {}
+
+        def _fake_run(*args, **kwargs):
+            captured.update(kwargs)
+            return []
+
+        with mock.patch("gitacross.main.run", side_effect=_fake_run), mock.patch(
+            "sys.argv", ["gitacross", "--config", str(cfg), "--clean-cache"]
+        ):
+            try:
+                main()
+            except SystemExit as e:
+                assert e.code in (0, None), f"expected exit 0, got {e.code}"
+        assert captured.get("clean_cache") is True
+    print("  ✓ cli: --clean-cache flag is forwarded to run()")
+
+
 def test_run_dry_run_passed_through():
     import gitacross
 

{gitacross-2.3.0 → gitacross-2.3.1}/tests/test_target.py

@@ -248,6 +248,60 @@ def test_create_target_unknown_type():
         assert "Unknown target type" in str(e)
     print("  ✓ target: unknown type rejected")
 
+def test_remote_target_cache_separates_hosts():
+    """Same-named target repos on different hosts get separate mirror caches."""
+    from gitacross.config import _EndpointConfig
+    from gitacross.target import create_target
+
+    calls = []
+
+    def fake_ensure_mirror(url, dest):
+        calls.append((url, dest))
+        return mock.MagicMock()
+
+    host_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "t"},
+        is_source=False,
+    )
+    host_b = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://gitea.example.com/api/v1", "token": "t"},
+        is_source=False,
+    )
+    same_as_a = _EndpointConfig(
+        {"type": "gitea", "repo": "uqkami/Awara",
+         "api": "https://git.nodebay.top/api/v1", "token": "other"},
+        is_source=False,
+    )
+
+    mock_apis = []
+    for _cfg in (host_a, host_b, same_as_a):
+        api = mock.MagicMock()
+        api.ensure_repo_exists.return_value = {
+            "clone_url": f"https://{_cfg.host}/{_cfg.repo}.git"
+        }
+        mock_apis.append(api)
+
+    with mock.patch(
+        "gitacross.target.get_api_client", side_effect=mock_apis
+    ), mock.patch(
+        "gitacross.git.GitRepo.ensure_mirror", side_effect=fake_ensure_mirror
+    ):
+        _ = create_target(host_a, "cache")
+        _ = create_target(host_b, "cache")
+        _ = create_target(same_as_a, "cache")
+
+    dest_a, dest_b, dest_same = (Path(d) for _, d in calls)
+    assert "target_gitea_git.nodebay.top_uqkami_Awara_" in str(dest_a)
+    assert "target_gitea_gitea.example.com_uqkami_Awara_" in str(dest_b)
+    for d in (dest_a, dest_b):
+        assert str(d).endswith(".git")
+    assert dest_a != dest_b
+    assert dest_a == dest_same  # same host + repo shares one mirror (dedup)
+    print("  ✓ target: remote target cache dirs are separated per host")
+
+
 def test_remote_target_no_clone_url_raises():
     """A remote target without any clone URL raises a clear error."""
     from gitacross.config import _EndpointConfig