github2gerrit 1.0.5__tar.gz → 1.0.6__tar.gz

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/.pre-commit-config.yaml

@@ -59,7 +59,7 @@ repos:
         types: [yaml]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 45ef068da5f21267bb2a7ec4a623092959f09ce5  # frozen: v0.14.14
+    rev: fa93bc3224c614a0e9786d3e2d3d48edcca246eb  # frozen: v0.15.1
     hooks:
       - id: ruff
         files: ^(src|scripts|tests)/.+\.py$
@@ -110,7 +110,7 @@ repos:
   # Replaces: https://github.com/rhysd/actionlint
   # Permits actionlint to run both locally and with precommit.ci/GitHub
   - repo: https://github.com/Mateusz-Grzelinski/actionlint-py
-    rev: 85c37735ea69e5baf0681530e57e63deee0ce733  # frozen: v1.7.10.24
+    rev: 694e2c0dfb4253d51f3c6c54b8f9fec0a16764dc  # frozen: v1.7.11.24
     hooks:
       - id: actionlint
 
@@ -121,7 +121,7 @@ repos:
       - id: codespell
 
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: ccf21790019848af3eb4464be2a9d5efed6358f3  # frozen: 0.36.1
+    rev: ec368acd16deee9c560c105ab6d27db4ee19a5ec  # frozen: 0.36.2
     hooks:
       - id: check-github-actions
       - id: check-github-workflows

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: github2gerrit
-Version: 1.0.5
+Version: 1.0.6
 Summary: Submit a GitHub pull request to a Gerrit repository.
 Project-URL: Homepage, https://github.com/lfreleng-actions/github2gerrit-action
 Project-URL: Repository, https://github.com/lfreleng-actions/github2gerrit-action
@@ -22,6 +22,7 @@ Classifier: Topic :: Software Development :: Build Tools
 Classifier: Topic :: Software Development :: Version Control
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
+Requires-Dist: cryptography>=46.0.5
 Requires-Dist: git-review>=2.5.0
 Requires-Dist: pygerrit2>=2.0.15
 Requires-Dist: pygithub>=2.8.1

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/action.yaml

@@ -164,7 +164,7 @@ runs:
 
     - name: "Setup uv"
       # yamllint disable-line rule:line-length
-      uses: astral-sh/setup-uv@803947b9bd8e9f986429fa0c5a41c367cd732b41  # v7.2.1
+      uses: astral-sh/setup-uv@eac588ad8def6316056a12d4907a9d4d84ff7a3b  # v7.3.0
       with:
         enable-cache: false
 

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/pyproject.toml

@@ -50,6 +50,9 @@ dependencies = [
 
   # Security: Fix CVE-2026-21441 (decompression-bomb vulnerability)
   "urllib3>=2.6.3",
+
+  # Security: Fix CVE-2026-26007 (SECT curve subgroup attack)
+  "cryptography>=46.0.5",
 ]
 
 [project.urls]

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/src/github2gerrit/core.py

@@ -2739,6 +2739,113 @@ class Orchestrator:
         run_cmd(cmd, cwd=self.workspace)
         log.info("Checkout succeeded after full unshallow")
 
+    def _merge_squash_with_unshallow_fallback(self, head_sha: str) -> None:
+        """Perform git merge --squash with graduated deepening fallback.
+
+        If the initial merge fails because the shallow clone lacks a common
+        ancestor between the base and head (causing "refusing to merge
+        unrelated histories"), this method will:
+        1. First try to deepen the repository (fetch 100 more commits)
+        2. If that fails, fully unshallow the repository
+        3. Retry the merge after each attempt
+
+        This mirrors the graduated approach used by
+        ``_checkout_with_unshallow_fallback`` but for merge operations,
+        which are equally susceptible to shallow clone limitations.
+
+        Args:
+            head_sha: The SHA to merge (PR head commit)
+
+        Raises:
+            CommandError: If merge fails even after unshallowing, or if
+                the failure is not related to shallow clone history
+        """
+        merge_cmd = ["git", "merge", "--squash", head_sha]
+
+        merge_exc: CommandError | None = None
+        try:
+            run_cmd(merge_cmd, cwd=self.workspace)
+        except CommandError as exc:
+            merge_exc = exc
+
+        if merge_exc is None:
+            return  # Success on first attempt
+
+        # Check if the failure is due to unrelated histories in a shallow clone
+        error_str = str(merge_exc).lower()
+        stderr_str = (merge_exc.stderr or "").lower()
+        combined = f"{error_str} {stderr_str}"
+
+        is_unrelated_histories = (
+            "refusing to merge unrelated histories" in combined
+            or "unrelated histories" in combined
+            or "no common ancestor" in combined
+        )
+
+        if not is_unrelated_histories or not self._is_shallow_clone():
+            # Not a shallow clone issue — let the caller handle the error
+            raise merge_exc
+
+        log.warning(
+            "Merge --squash failed due to unrelated histories in shallow "
+            "clone. Attempting graduated deepening to recover..."
+        )
+
+        # Step 1: Try deepening first (cheaper than full unshallow)
+        if self._deepen_repository(depth=100):
+            log.debug("Retrying merge --squash after deepening...")
+            # Reset the failed merge state before retrying
+            run_cmd(
+                ["git", "merge", "--abort"],
+                cwd=self.workspace,
+                check=False,
+            )
+            try:
+                run_cmd(merge_cmd, cwd=self.workspace)
+            except CommandError as deepen_exc:
+                log.debug(
+                    "Merge --squash still failed after deepening: %s",
+                    deepen_exc,
+                )
+                # Re-check whether this is still a shallow-history problem;
+                # if the error has changed (e.g. real merge conflict), an
+                # expensive full unshallow cannot help — propagate immediately.
+                deepen_combined = (
+                    f"{deepen_exc} {deepen_exc.stderr or ''}".lower()
+                )
+                deepen_is_unrelated = (
+                    "refusing to merge unrelated histories" in deepen_combined
+                    or "unrelated histories" in deepen_combined
+                    or "no common ancestor" in deepen_combined
+                )
+                if not deepen_is_unrelated:
+                    raise
+            else:
+                log.info("Merge --squash succeeded after deepening repository")
+                return
+
+        # Step 2: Full unshallow as last resort
+        log.info(
+            "Deepening insufficient, performing full unshallow for merge..."
+        )
+        # Reset the failed merge state before retrying
+        run_cmd(
+            ["git", "merge", "--abort"],
+            cwd=self.workspace,
+            check=False,
+        )
+        if not self._unshallow_repository():
+            log.error(
+                "Failed to unshallow repository. Cannot merge SHA: %s",
+                head_sha,
+            )
+            raise merge_exc
+
+        # Retry the merge after full unshallow
+        log.debug("Retrying merge --squash after full unshallow...")
+        run_cmd(merge_cmd, cwd=self.workspace)
+        log.info("Merge --squash succeeded after full unshallow")
+
     def _cleanup_ssh(self) -> None:
         """Clean up temporary SSH files created by this tool.
 
@@ -3103,6 +3210,15 @@ class Orchestrator:
 
         except Exception as debug_exc:
             log.warning("Failed to analyze merge situation: %s", debug_exc)
+            # Proactively deepen if merge-base fails in a shallow clone,
+            # as this strongly indicates the shallow history is insufficient
+            # for the upcoming merge --squash operation.
+            if self._is_shallow_clone():
+                log.info(
+                    "merge-base failed in shallow clone — proactively "
+                    "deepening repository to improve merge success chances"
+                )
+                self._deepen_repository(depth=100)
 
         self._checkout_with_unshallow_fallback(
             branch_name=tmp_branch,
@@ -3134,7 +3250,7 @@ class Orchestrator:
 
         log.debug("About to run: git merge --squash %s", head_sha)
         try:
-            run_cmd(["git", "merge", "--squash", head_sha], cwd=self.workspace)
+            self._merge_squash_with_unshallow_fallback(head_sha)
         except CommandError as merge_exc:
             # Enhanced error handling for git merge failures
             error_details = self._analyze_merge_failure(

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/src/github2gerrit/pr_content_filter.py

@@ -44,27 +44,6 @@ _MULTIPLE_NEWLINES_PATTERN = re.compile(r"\n{3,}")
 _EMOJI_PATTERN = re.compile(r":[a-z_]+:")  # GitHub emoji codes like :sparkles:
 
 
-@dataclass
-class FilterConfig:
-    """Configuration for PR content filtering."""
-
-    # Global options
-    enabled: bool = True
-    remove_emoji_codes: bool = True
-    deduplicate_title_in_body: bool = True
-
-    # Author-specific filtering
-    author_rules: dict[str, str] = field(default_factory=dict)
-
-    # Rule-specific configurations
-    dependabot_config: DependabotConfig = field(
-        default_factory=lambda: DependabotConfig()
-    )
-    precommit_config: PrecommitConfig = field(
-        default_factory=lambda: PrecommitConfig()
-    )
-
-
 @dataclass
 class DependabotConfig:
     """Configuration for Dependabot PR filtering."""
@@ -85,6 +64,25 @@ class PrecommitConfig:
     # Future: add pre-commit.ci specific options
 
 
+@dataclass
+class FilterConfig:
+    """Configuration for PR content filtering."""
+
+    # Global options
+    enabled: bool = True
+    remove_emoji_codes: bool = True
+    deduplicate_title_in_body: bool = True
+
+    # Author-specific filtering
+    author_rules: dict[str, str] = field(default_factory=dict)
+
+    # Rule-specific configurations
+    dependabot_config: DependabotConfig = field(
+        default_factory=DependabotConfig
+    )
+    precommit_config: PrecommitConfig = field(default_factory=PrecommitConfig)
+
+
 class FilterRule(ABC):
     """Abstract base class for PR content filtering rules."""
 

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/tests/test_change_id_deduplication.py

@@ -275,7 +275,7 @@ Change-Id: {reused_change_id}
     monkeypatch.setattr("github2gerrit.core.run_cmd", mock_run_cmd)
 
     # Mock GitHub API for Change-ID reuse
-    monkeypatch.setattr("github2gerrit.core.build_client", lambda: object())
+    monkeypatch.setattr("github2gerrit.core.build_client", object)
     monkeypatch.setattr(
         "github2gerrit.core.get_repo_from_env", lambda _: object()
     )

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/tests/test_cli_outputs_file.py

@@ -232,7 +232,7 @@ def test_multi_pr_url_mode_writes_aggregated_outputs(
         def __init__(self, number: int) -> None:
             self.number = number
 
-    monkeypatch.setattr(cli_mod, "build_client", lambda: object())
+    monkeypatch.setattr(cli_mod, "build_client", object)
     monkeypatch.setattr(cli_mod, "get_repo_from_env", lambda _client: object())
     monkeypatch.setattr(
         cli_mod,

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/tests/test_cli_url_and_dryrun.py

@@ -168,7 +168,7 @@ def test_repo_url_dry_run_invokes_for_each_open_pr(
     monkeypatch.setattr(cli_mod, "Orchestrator", _DummyOrchestrator)
 
     # Patch PyGithub wrapper functions used by CLI bulk path
-    monkeypatch.setattr(cli_mod, "build_client", lambda: object())
+    monkeypatch.setattr(cli_mod, "build_client", object)
     monkeypatch.setattr(cli_mod, "get_repo_from_env", lambda _client: object())
     monkeypatch.setattr(
         cli_mod, "iter_open_pulls", lambda _repo: iter(dummy_prs)
@@ -212,7 +212,7 @@ def test_url_mode_sets_environment_for_config_resolution(
     monkeypatch.setattr(cli_mod, "Orchestrator", _DummyOrchestrator)
 
     # Minimal patches for bulk flow
-    monkeypatch.setattr(cli_mod, "build_client", lambda: object())
+    monkeypatch.setattr(cli_mod, "build_client", object)
     monkeypatch.setattr(cli_mod, "get_repo_from_env", lambda _client: object())
     monkeypatch.setattr(
         cli_mod,

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/tests/test_core_close_pr_policy.py

@@ -102,9 +102,7 @@ def test_close_pr_invoked_for_pull_request_target_event(
             self.closed_state: str | None = None
 
     # Patch the GitHub helper functions used by the close path
-    monkeypatch.setattr(
-        "github2gerrit.core.build_client", lambda: DummyClient()
-    )
+    monkeypatch.setattr("github2gerrit.core.build_client", DummyClient)
     monkeypatch.setattr(
         "github2gerrit.core.get_repo_from_env", lambda _c: DummyRepo()
     )

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/tests/test_core_prepare_commits.py

@@ -237,7 +237,7 @@ def test_prepare_squashed_commit_reuses_change_id_from_comments(
     monkeypatch.setattr("github2gerrit.core.run_cmd", fake_run_cmd)
 
     # GitHub API helpers used to fetch PR comments
-    monkeypatch.setattr("github2gerrit.core.build_client", lambda: object())
+    monkeypatch.setattr("github2gerrit.core.build_client", object)
     monkeypatch.setattr(
         "github2gerrit.core.get_repo_from_env", lambda _c: object()
     )

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/tests/test_core_shallow_clone.py

@@ -485,3 +485,342 @@ class TestEnsureWorkspacePrepared:
         # Should only have fetched once
         fetch_calls = [c for c in call_log if c[:2] == ["git", "fetch"]]
         assert len(fetch_calls) == 1
+
+
+class TestMergeSquashWithUnshallowFallback:
+    """Tests for _merge_squash_with_unshallow_fallback method."""
+
+    def test_merge_success_first_attempt(self, tmp_path: Path) -> None:
+        """Merge succeeds on first attempt without any deepening."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+
+        call_log: list[list[str]] = []
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            call_log.append(cmd)
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        # Should have called merge --squash exactly once
+        merge_calls = [c for c in call_log if "merge" in c and "--squash" in c]
+        assert len(merge_calls) == 1
+        assert merge_calls[0] == ["git", "merge", "--squash", "abc123"]
+
+        # No deepen or unshallow calls
+        deepen_calls = [c for c in call_log if "--deepen=" in str(c)]
+        assert len(deepen_calls) == 0
+        unshallow_calls = [c for c in call_log if "--unshallow" in c]
+        assert len(unshallow_calls) == 0
+
+    def test_merge_fails_unrelated_histories_deepen_succeeds(
+        self, tmp_path: Path
+    ) -> None:
+        """Merge fails with unrelated histories, deepen fixes it."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+        (git_dir / "shallow").touch()
+
+        merge_attempts = [0]
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                merge_attempts[0] += 1
+                if merge_attempts[0] == 1:
+                    raise CommandError(
+                        "fatal: refusing to merge unrelated histories",
+                        returncode=128,
+                        stderr="fatal: refusing to merge unrelated histories",
+                    )
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if cmd[:2] == ["git", "merge"] and "--abort" in cmd:
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "--deepen=" in str(cmd):
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "is-shallow-repository" in cmd:
+                return CommandResult(returncode=0, stdout="true\n", stderr="")
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        # Should have attempted merge twice (before and after deepen)
+        assert merge_attempts[0] == 2
+
+    def test_merge_fails_unrelated_histories_deepen_insufficient_unshallow_succeeds(
+        self, tmp_path: Path
+    ) -> None:
+        """Merge fails, deepen insufficient, full unshallow fixes it."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+        (git_dir / "shallow").touch()
+
+        merge_attempts = [0]
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                merge_attempts[0] += 1
+                if merge_attempts[0] <= 2:
+                    raise CommandError(
+                        "fatal: refusing to merge unrelated histories",
+                        returncode=128,
+                        stderr="fatal: refusing to merge unrelated histories",
+                    )
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if cmd[:2] == ["git", "merge"] and "--abort" in cmd:
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "--deepen=" in str(cmd):
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if cmd[:3] == ["git", "fetch", "--unshallow"]:
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "is-shallow-repository" in cmd:
+                return CommandResult(returncode=0, stdout="true\n", stderr="")
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        # Should have attempted merge 3 times:
+        # 1. Initial (fail), 2. After deepen (fail), 3. After unshallow (success)
+        assert merge_attempts[0] == 3
+
+    def test_merge_fails_non_shallow_error_raises_immediately(
+        self, tmp_path: Path
+    ) -> None:
+        """Merge fails with non-shallow error, raises immediately."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                raise CommandError(
+                    "Merge conflict in file.txt",
+                    returncode=1,
+                    stderr="CONFLICT (content): Merge conflict in file.txt",
+                )
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            with pytest.raises(CommandError) as exc_info:
+                orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        assert "conflict" in str(exc_info.value).lower()
+
+    def test_merge_fails_unrelated_histories_not_shallow_raises(
+        self, tmp_path: Path
+    ) -> None:
+        """Unrelated histories in a non-shallow clone raises immediately."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+        # No shallow file — not a shallow clone
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                raise CommandError(
+                    "fatal: refusing to merge unrelated histories",
+                    returncode=128,
+                    stderr="fatal: refusing to merge unrelated histories",
+                )
+            if "is-shallow-repository" in cmd:
+                return CommandResult(returncode=0, stdout="false\n", stderr="")
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            with pytest.raises(CommandError) as exc_info:
+                orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        assert "unrelated histories" in str(exc_info.value).lower()
+
+    def test_merge_fails_all_recovery_fails_raises(
+        self, tmp_path: Path
+    ) -> None:
+        """Merge fails, deepen and unshallow both fail, raises original error."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+        (git_dir / "shallow").touch()
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                raise CommandError(
+                    "fatal: refusing to merge unrelated histories",
+                    returncode=128,
+                    stderr="fatal: refusing to merge unrelated histories",
+                )
+            if cmd[:2] == ["git", "merge"] and "--abort" in cmd:
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "--deepen=" in str(cmd):
+                raise CommandError("deepen failed", returncode=1)
+            if cmd[:3] == ["git", "fetch", "--unshallow"]:
+                raise CommandError("unshallow failed", returncode=1)
+            if "is-shallow-repository" in cmd:
+                return CommandResult(returncode=0, stdout="true\n", stderr="")
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            with pytest.raises(CommandError) as exc_info:
+                orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        assert "unrelated histories" in str(exc_info.value).lower()
+
+    def test_merge_abort_called_before_retry(self, tmp_path: Path) -> None:
+        """Ensure git merge --abort is called before retrying merge."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+        (git_dir / "shallow").touch()
+
+        call_log: list[list[str]] = []
+        merge_attempts = [0]
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            call_log.append(list(cmd))
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                merge_attempts[0] += 1
+                if merge_attempts[0] == 1:
+                    raise CommandError(
+                        "fatal: refusing to merge unrelated histories",
+                        returncode=128,
+                        stderr="fatal: refusing to merge unrelated histories",
+                    )
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if cmd[:2] == ["git", "merge"] and "--abort" in cmd:
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "--deepen=" in str(cmd):
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "is-shallow-repository" in cmd:
+                return CommandResult(returncode=0, stdout="true\n", stderr="")
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        # Find the position of the abort call and the second merge call
+        abort_indices = [
+            i
+            for i, c in enumerate(call_log)
+            if c[:2] == ["git", "merge"] and "--abort" in c
+        ]
+        second_merge_indices = [
+            i
+            for i, c in enumerate(call_log)
+            if c == ["git", "merge", "--squash", "abc123"]
+        ]
+        # abort should come before the second merge attempt
+        assert len(abort_indices) >= 1
+        assert len(second_merge_indices) == 2
+        assert abort_indices[0] < second_merge_indices[1]
+
+    @pytest.mark.parametrize(
+        "error_message,stderr_message",
+        [
+            (
+                "fatal: refusing to merge unrelated histories",
+                "fatal: refusing to merge unrelated histories",
+            ),
+            (
+                "merge failed: unrelated histories",
+                "unrelated histories detected",
+            ),
+            (
+                "no common ancestor found",
+                "fatal: no common ancestor",
+            ),
+        ],
+    )
+    def test_recognizes_unrelated_history_errors(
+        self,
+        tmp_path: Path,
+        error_message: str,
+        stderr_message: str,
+    ) -> None:
+        """All variations of unrelated history errors trigger deepening."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+        (git_dir / "shallow").touch()
+
+        merge_attempts = [0]
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                merge_attempts[0] += 1
+                if merge_attempts[0] == 1:
+                    raise CommandError(
+                        error_message,
+                        returncode=128,
+                        stderr=stderr_message,
+                    )
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if cmd[:2] == ["git", "merge"] and "--abort" in cmd:
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "--deepen=" in str(cmd):
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "is-shallow-repository" in cmd:
+                return CommandResult(returncode=0, stdout="true\n", stderr="")
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        # Should have attempted merge twice (before and after deepen)
+        assert merge_attempts[0] == 2
+
+    def test_deepen_changes_error_to_conflict_raises_without_unshallow(
+        self, tmp_path: Path
+    ) -> None:
+        """After deepen, if error changes from unrelated histories to a merge
+        conflict, raise immediately instead of attempting expensive unshallow."""
+        git_dir = tmp_path / ".git"
+        git_dir.mkdir()
+        (git_dir / "shallow").touch()
+
+        merge_attempts = [0]
+        call_log: list[list[str]] = []
+
+        def fake_run_cmd(cmd: list[str], **kwargs: Any) -> CommandResult:
+            call_log.append(list(cmd))
+            if cmd[:2] == ["git", "merge"] and "--squash" in cmd:
+                merge_attempts[0] += 1
+                if merge_attempts[0] == 1:
+                    # First attempt: unrelated histories (shallow clone issue)
+                    raise CommandError(
+                        "fatal: refusing to merge unrelated histories",
+                        returncode=128,
+                        stderr="fatal: refusing to merge unrelated histories",
+                    )
+                # Second attempt after deepen: now a real merge conflict
+                raise CommandError(
+                    "Merge conflict in file.txt",
+                    returncode=1,
+                    stderr="CONFLICT (content): Merge conflict in file.txt",
+                )
+            if cmd[:2] == ["git", "merge"] and "--abort" in cmd:
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "--deepen=" in str(cmd):
+                return CommandResult(returncode=0, stdout="", stderr="")
+            if "is-shallow-repository" in cmd:
+                return CommandResult(returncode=0, stdout="true\n", stderr="")
+            return CommandResult(returncode=0, stdout="", stderr="")
+
+        with patch("github2gerrit.core.run_cmd", side_effect=fake_run_cmd):
+            orch = Orchestrator(workspace=tmp_path)
+            with pytest.raises(CommandError) as exc_info:
+                orch._merge_squash_with_unshallow_fallback(head_sha="abc123")
+
+        # Should have raised the conflict error, not the original
+        assert "conflict" in str(exc_info.value).lower()
+
+        # Should have attempted merge twice only (no third attempt after unshallow)
+        assert merge_attempts[0] == 2
+
+        # Should NOT have attempted unshallow
+        unshallow_calls = [c for c in call_log if "--unshallow" in c]
+        assert len(unshallow_calls) == 0

{github2gerrit-1.0.5 → github2gerrit-1.0.6}/tests/test_gerrit_change_id_footer.py

@@ -99,7 +99,7 @@ def test_apply_pr_title_body_preserves_change_id_footer(
     )
 
     # Stub GitHub API helpers used by _apply_pr_title_body_if_requested
-    monkeypatch.setattr("github2gerrit.core.build_client", lambda: object())
+    monkeypatch.setattr("github2gerrit.core.build_client", object)
     monkeypatch.setattr(
         "github2gerrit.core.get_repo_from_env", lambda client: object()
     )