roboco/tests/unit/services/test_git_rebase_resolve.py

"""GitService PR-divergence primitives: rebase_onto_base + close_pull_request.

These back both the sequence-ordered merge (rebase a later sibling onto the
prior one's merged result) and the conflict resolver (rebase a wedged PR,
then close-if-superseded / re-merge / escalate). The classification a rebase
yields — superseded vs rebased vs conflicts — drives the whole resolution, so
each branch is pinned here against a mocked git.
"""

from __future__ import annotations

from pathlib import Path
from typing import Any
from unittest.mock import AsyncMock, MagicMock, patch
from uuid import uuid4

import pytest
from roboco.services.forge import RepoRef
from roboco.services.git import GitService


def _git_service() -> GitService:
    return GitService.__new__(GitService)


def _result(returncode: int = 0, stdout: str = "") -> Any:
    return type("R", (), {"returncode": returncode, "stdout": stdout})()


_HEAD = "feature/frontend/root--cell--leaf"
_BASE = "feature/frontend/root--cell"


@pytest.mark.asyncio
async def test_rebase_superseded_when_no_unique_commits() -> None:
    """Clean rebase + zero commits ahead of base => superseded (safe to close)."""
    svc = _git_service()
    pushed: list[list[str]] = []

    async def fake_run(_ws: Any, args: list[str], **_kw: Any) -> Any:
        if args[0] == "push":
            pushed.append(args)
        if args[:2] == ["rev-list", "--count"]:
            return _result(stdout="0\n")
        return _result()

    with patch.object(svc, "_run_git", new=fake_run):
        out = await svc.rebase_onto_base(
            Path("/tmp/ws"), head_branch=_HEAD, base_branch=_BASE, git_token="tok"
        )
    assert out == {"status": "superseded"}
    # A superseded branch must NOT be force-pushed — nothing changed.
    assert pushed == []


@pytest.mark.asyncio
async def test_rebase_rebased_force_pushes_when_unique_commits() -> None:
    """Clean rebase + commits ahead of base => rebased + force-push the head."""
    svc = _git_service()
    pushed: list[list[str]] = []

    async def fake_run(_ws: Any, args: list[str], **_kw: Any) -> Any:
        if args[0] == "push":
            pushed.append(args)
            return _result()
        if args[:2] == ["rev-list", "--count"]:
            return _result(stdout="3\n")
        return _result()

    with patch.object(svc, "_run_git", new=fake_run):
        out = await svc.rebase_onto_base(
            Path("/tmp/ws"), head_branch=_HEAD, base_branch=_BASE, git_token="tok"
        )
    assert out == {"status": "rebased", "unique_commits": 3}
    # Only the head branch is force-pushed, with lease, never the base.
    assert pushed == [["push", "--force-with-lease", "origin", f"HEAD:{_HEAD}"]]


@pytest.mark.asyncio
async def test_rebase_conflicts_aborts_and_reports_files() -> None:
    """A failed rebase is aborted and the conflicting files reported."""
    svc = _git_service()
    aborted = False

    async def fake_run(_ws: Any, args: list[str], **_kw: Any) -> Any:
        nonlocal aborted
        if args == ["rebase", f"origin/{_BASE}"]:
            return _result(returncode=1)
        if args[:2] == ["diff", "--name-only"]:
            return _result(stdout="src/a.tsx\nsrc/b.tsx\n")
        if args == ["rebase", "--abort"]:
            aborted = True
            return _result()
        return _result()

    with patch.object(svc, "_run_git", new=fake_run):
        out = await svc.rebase_onto_base(
            Path("/tmp/ws"), head_branch=_HEAD, base_branch=_BASE, git_token="tok"
        )
    assert out == {"status": "conflicts", "files": ["src/a.tsx", "src/b.tsx"]}
    assert aborted is True


@pytest.mark.asyncio
async def test_rebase_never_force_pushes_on_conflict() -> None:
    """Guard: the destructive force-push must not fire when a rebase conflicts."""
    svc = _git_service()
    pushed: list[list[str]] = []

    async def fake_run(_ws: Any, args: list[str], **_kw: Any) -> Any:
        if args[0] == "push":
            pushed.append(args)
        if args == ["rebase", f"origin/{_BASE}"]:
            return _result(returncode=1)
        if args[:2] == ["diff", "--name-only"]:
            return _result(stdout="")
        return _result()

    with patch.object(svc, "_run_git", new=fake_run):
        await svc.rebase_onto_base(
            Path("/tmp/ws"), head_branch=_HEAD, base_branch=_BASE, git_token="tok"
        )
    assert pushed == []


@pytest.mark.asyncio
async def test_close_pull_request_patches_state_closed(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """close_pull_request issues a PATCH state=closed (and an optional comment)."""
    svc = _git_service()
    # Stub the task/project/workspace/token/remote resolution chain via
    # monkeypatch.setattr (not direct assignment) so mypy's method-assign check
    # stays satisfied without silencing it.
    task = type("T", (), {"id": "t", "assigned_to": None, "created_by": None})()
    session = AsyncMock()
    session.execute = AsyncMock(
        return_value=type("Res", (), {"scalar_one_or_none": lambda _self: task})()
    )
    delete_branch = AsyncMock()
    monkeypatch.setattr(svc, "session", session, raising=False)
    monkeypatch.setattr(
        svc,
        "_project_for_task",
        AsyncMock(return_value=type("P", (), {"slug": "proj"})()),
    )
    monkeypatch.setattr(
        svc, "_resolve_workspace_agent_id", MagicMock(return_value=None)
    )
    monkeypatch.setattr(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
    monkeypatch.setattr(
        svc, "_get_project_token_or_raise", AsyncMock(return_value="tok")
    )
    monkeypatch.setattr(
        svc, "_parse_github_remote", MagicMock(return_value=RepoRef("owner", "repo"))
    )
    monkeypatch.setattr(svc, "_delete_pr_branch_best_effort", delete_branch)

    calls: list[tuple[str, str]] = []

    class _Resp:
        is_success = True
        status_code = 200
        text = ""

        def json(self) -> dict[str, str]:
            return {"state": "open"}

    class _Client:
        async def __aenter__(self) -> _Client:
            return self

        async def __aexit__(self, *_a: Any) -> None:
            return None

        async def get(self, url: str, **_kw: Any) -> _Resp:
            calls.append(("GET", url))
            return _Resp()

        async def post(self, url: str, **_kw: Any) -> _Resp:
            calls.append(("POST", url))
            return _Resp()

        async def patch(self, url: str, **_kw: Any) -> _Resp:
            calls.append(("PATCH", url))
            return _Resp()

    with patch("roboco.services.git.httpx.AsyncClient", return_value=_Client()):
        await svc.close_pull_request(
            159,
            project_id=uuid4(),
            comment="superseded by #158",
            delete_branch=True,
        )

    assert (
        "POST",
        "https://api.github.com/repos/owner/repo/issues/159/comments",
    ) in calls
    assert ("PATCH", "https://api.github.com/repos/owner/repo/pulls/159") in calls
    delete_branch.assert_awaited_once()


@pytest.mark.asyncio
async def test_close_pull_request_does_not_delete_branch_by_default(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """#109: close_pull_request defaulted delete_branch=True, so the
    choreographer supersede path deleted a superseded PR's branch while the
    orchestrator supersede path explicitly preserved it — the two disagreed,
    and the destructive default ran on the "close the dead PR" path where the
    branch may still be referenced / useful for audit. The default is now
    False (opt-in deletion); a superseded-PR close preserves the branch unless
    the caller explicitly asks to delete. The PATCH still fires.
    """
    svc = _git_service()
    task = type("T", (), {"id": "t", "assigned_to": None, "created_by": None})()
    session = AsyncMock()
    session.execute = AsyncMock(
        return_value=type("Res", (), {"scalar_one_or_none": lambda _self: task})()
    )
    delete_branch = AsyncMock()
    monkeypatch.setattr(svc, "session", session, raising=False)
    monkeypatch.setattr(
        svc,
        "_project_for_task",
        AsyncMock(return_value=type("P", (), {"slug": "proj"})()),
    )
    monkeypatch.setattr(
        svc, "_resolve_workspace_agent_id", MagicMock(return_value=None)
    )
    monkeypatch.setattr(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
    monkeypatch.setattr(
        svc, "_get_project_token_or_raise", AsyncMock(return_value="tok")
    )
    monkeypatch.setattr(
        svc, "_parse_github_remote", MagicMock(return_value=RepoRef("owner", "repo"))
    )
    monkeypatch.setattr(svc, "_delete_pr_branch_best_effort", delete_branch)

    class _Resp:
        is_success = True
        status_code = 200
        text = ""

        def json(self) -> dict[str, str]:
            return {"state": "open"}

    class _Client:
        async def __aenter__(self) -> _Client:
            return self

        async def __aexit__(self, *_a: Any) -> None:
            return None

        async def get(self, _url: str, **_kw: Any) -> _Resp:
            return _Resp()

        async def post(self, _url: str, **_kw: Any) -> _Resp:
            return _Resp()

        async def patch(self, _url: str, **_kw: Any) -> _Resp:
            return _Resp()

    with patch("roboco.services.git.httpx.AsyncClient", return_value=_Client()):
        # No delete_branch kwarg → default must preserve the branch.
        await svc.close_pull_request(159, project_id=uuid4(), comment="superseded")

    # The close PATCH still fires (the PR is closed); the branch is NOT deleted.
    delete_branch.assert_not_awaited()


@pytest.mark.asyncio
async def test_close_pull_request_idempotent_when_already_closed(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """An already-closed PR is a no-op: no duplicate comment, no PATCH.

    Guards the close-on-land retry path — a transient failure between the
    comment POST and the close PATCH must not re-post the explanatory comment
    on the next sweep.
    """
    svc = _git_service()
    task = type("T", (), {"id": "t", "assigned_to": None, "created_by": None})()
    session = AsyncMock()
    session.execute = AsyncMock(
        return_value=type("Res", (), {"scalar_one_or_none": lambda _self: task})()
    )
    monkeypatch.setattr(svc, "session", session, raising=False)
    monkeypatch.setattr(
        svc,
        "_project_for_task",
        AsyncMock(return_value=type("P", (), {"slug": "proj"})()),
    )
    monkeypatch.setattr(
        svc, "_resolve_workspace_agent_id", MagicMock(return_value=None)
    )
    monkeypatch.setattr(svc, "get_workspace", AsyncMock(return_value=Path("/tmp/ws")))
    monkeypatch.setattr(
        svc, "_get_project_token_or_raise", AsyncMock(return_value="tok")
    )
    monkeypatch.setattr(
        svc, "_parse_github_remote", MagicMock(return_value=RepoRef("owner", "repo"))
    )
    monkeypatch.setattr(svc, "_delete_pr_branch_best_effort", AsyncMock())

    calls: list[tuple[str, str]] = []

    class _Resp:
        is_success = True
        status_code = 200
        text = ""

        def json(self) -> dict[str, str]:
            return {"state": "closed"}

    class _Client:
        async def __aenter__(self) -> _Client:
            return self

        async def __aexit__(self, *_a: Any) -> None:
            return None

        async def get(self, url: str, **_kw: Any) -> _Resp:
            calls.append(("GET", url))
            return _Resp()

        async def post(self, url: str, **_kw: Any) -> _Resp:
            calls.append(("POST", url))
            return _Resp()

        async def patch(self, url: str, **_kw: Any) -> _Resp:
            calls.append(("PATCH", url))
            return _Resp()

    with patch("roboco.services.git.httpx.AsyncClient", return_value=_Client()):
        await svc.close_pull_request(
            159,
            project_id=uuid4(),
            comment="superseded by #158",
            delete_branch=False,
        )

    assert [c[0] for c in calls] == ["GET"]  # no POST comment, no PATCH